fix(tests): client_mocks moved inside the package, imports for tests adjusted

Automatically generated by python-semantic-release

.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/pytest-matrix.yml

@@ -27,7 +27,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.10", "3.11", "3.12"]
+        python-version: ["3.11", "3.12", "3.13"]
 
     env:
       BEC_WIDGETS_BRANCH: main  # Set the branch you want for bec_widgets

.github/workflows/stale-issues.yml

@@ -2,10 +2,14 @@ name: 'Close stale issues and PRs'
 on:
   schedule:
     - cron: '00 10 * * *'
+  workflow_dispatch:
 
 jobs:
   stale:
     runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
     steps:
       - uses: actions/stale@v9
         with:

.gitlab-ci.yml

@@ -1,289 +0,0 @@
-# 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
-#commands to run in the Docker container before starting each job.
-variables:
-  DOCKER_TLS_CERTDIR: ""
-  BEC_CORE_BRANCH:
-    description: bec branch
-    value: main
-  OPHYD_DEVICES_BRANCH:
-    description: ophyd_devices branch
-    value: main
-  CHILD_PIPELINE_BRANCH: $CI_DEFAULT_BRANCH
-  CHECK_PKG_VERSIONS:
-    description: Whether to run additional tests against min/max/random selection of dependencies. Set to 1 for running.
-    value: 0
-
-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/unit_tests"
-      pip_args: ".[dev]"
-
-# different stages in the pipeline
-stages:
-  - Formatter
-  - test
-  - AdditionalTests
-  - End2End
-  - 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
-  - echo -e "\033[35;1m Using branch $BEC_CORE_BRANCH of BEC CORE \033[0;m";
-  - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
-  - echo -e "\033[35;1m Using branch $OPHYD_DEVICES_BRANCH of OPHYD_DEVICES \033[0;m";
-  - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
-  - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
-
-.install-repos: &install-repos
-  - pip install -e ./ophyd_devices
-  - pip install -e ./bec/bec_lib[dev]
-  - pip install -e ./bec/bec_ipython_client
-  - pip install -e ./bec/pytest_bec_e2e
-
-.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 xvfb
-  - *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 -e ./[dev]
-    - isort --check --diff --line-length=100 --profile=black --multi-line=3 --trailing-comma ./
-    - black --check --diff --color --line-length=100 --skip-magic-trailing-comma ./
-  rules:
-    - if: $CI_PROJECT_PATH == "bec/bec_widgets"
-
-pylint:
-  stage: Formatter
-  needs: []
-  before_script:
-    - pip install pylint pylint-exit anybadge
-    - pip install -e .[dev]
-  script:
-    - mkdir ./pylint
-    - pylint ./bec_widgets --output-format=text --output=./pylint/pylint.log | tee ./pylint/pylint.log || pylint-exit $?
-    - PYLINT_SCORE=$(sed -n 's/^Your code has been rated at \([-0-9.]*\)\/.*/\1/p' ./pylint/pylint.log)
-    - anybadge --label=Pylint --file=pylint/pylint.svg --value=$PYLINT_SCORE 2=red 4=orange 8=yellow 10=green
-    - echo "Pylint score is $PYLINT_SCORE"
-  artifacts:
-    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
-  needs: []
-  variables:
-    QT_QPA_PLATFORM: "offscreen"
-  script:
-    - *clone-repos
-    - *install-os-packages
-    - *install-repos
-    - pip install -e .[dev,pyside6]
-    - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --maxfail=2 --random-order --full-trace ./tests/unit_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
-    paths:
-      - tests/reference_failures/
-    when: always
-
-generate-client-check:
-  stage: test
-  needs: []
-  variables:
-    QT_QPA_PLATFORM: "offscreen"
-  script:
-    - *clone-repos
-    - *install-os-packages
-    - *install-repos
-    - pip install -e .[dev,pyside6]
-    - bw-generate-cli --target bec_widgets
-    # if there are changes in the generated files, fail the job
-    - git diff --exit-code
-
-test-matrix:
-  parallel:
-    matrix:
-      - PYTHON_VERSION:
-          - "3.10"
-          - "3.11"
-          - "3.12"
-        QT_PCKG:
-          - "pyside6"
-
-  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
-    - *install-repos
-    - pip install -e .[dev,$QT_PCKG]
-    - pytest -v --maxfail=2 --junitxml=report.xml --random-order ./tests/unit_tests
-
-end-2-end-conda:
-  stage: End2End
-  needs: []
-  image: continuumio/miniconda3:25.1.1-2
-  allow_failure: false
-  variables:
-    QT_QPA_PLATFORM: "offscreen"
-  script:
-    - *clone-repos
-    - *install-os-packages
-    - conda config --show-sources
-    - conda config --add channels conda-forge
-    - conda config --system --remove channels https://repo.anaconda.com/pkgs/main
-    - conda config --system --remove channels https://repo.anaconda.com/pkgs/r
-    - conda config --remove channels https://repo.anaconda.com/pkgs/main
-    - conda config --remove channels https://repo.anaconda.com/pkgs/r
-    - conda config --show-sources
-    - 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
-    - cd ../
-    - pip install -e ./ophyd_devices
-
-    - pip install -e .[dev,pyside6]
-    - pytest -v --files-path ./ --start-servers --random-order  ./tests/end-2-end
-
-  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"'
-    - if: "$CI_MERGE_REQUEST_TARGET_BRANCH_NAME =~ /^pre_release.*$/"
-
-semver:
-  stage: Deploy
-  needs: ["tests"]
-  script:
-    - git config --global user.name "ci_update_bot"
-    - git config --global user.email "ci_update_bot@bec.ch"
-    - git checkout "$CI_COMMIT_REF_NAME"
-    - git reset --hard origin/"$CI_COMMIT_REF_NAME"
-
-    # delete all local tags
-    - git tag -l | xargs git tag -d
-    - git fetch --tags
-    - git tag
-
-    # build and publish package
-    - pip install python-semantic-release==9.* wheel build twine
-    - 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
-
-  allow_failure: false
-  rules:
-    - if: '$CI_COMMIT_REF_NAME == "main" && $CI_PROJECT_PATH == "bec/bec_widgets"'
-
-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/

.pylintrc

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

CHANGELOG.md

@@ -1,6 +1,221 @@
 # CHANGELOG
 
 
+## v2.42.0 (2025-10-21)
+
+### Features
+
+- **image_roi**: Enhance get_coordinates to include rectangle center and dimensions
+  ([`96664c3`](https://github.com/bec-project/bec_widgets/commit/96664c3923737df0b09aa8f35df388f9fd630b55))
+
+- **positioner_box_2d**: Added properties to enable/disable vertical and horizontal controls
+  ([`1e19092`](https://github.com/bec-project/bec_widgets/commit/1e190923196f8b28c92dfdd83b9ce90873dd792d))
+
+
+## v2.41.1 (2025-10-15)
+
+### Bug Fixes
+
+- **dependencies**: Bec lib versions fixed
+  ([`3941050`](https://github.com/bec-project/bec_widgets/commit/3941050883a791f800ab7178af2435ac14f837b6))
+
+
+## v2.41.0 (2025-10-15)
+
+### Bug Fixes
+
+- **image_roi**: Delete button added to compact version
+  ([`ef27de4`](https://github.com/bec-project/bec_widgets/commit/ef27de40ceee8375d95a0f3a8e451b7d05d0ae2c))
+
+- **image_roi**: Rois can be removed with right click context menu
+  ([`37df95e`](https://github.com/bec-project/bec_widgets/commit/37df95ead8d6a07a6c5794a97a486d9f380004cc))
+
+### Build System
+
+- **bec_lib**: Version bump to 3.69.3
+  ([`28ac9c5`](https://github.com/bec-project/bec_widgets/commit/28ac9c5cc369bdfa712c70c45591243631c65066))
+
+### Features
+
+- **image_roi_tree**: Compact mode added
+  ([`c87a6cf`](https://github.com/bec-project/bec_widgets/commit/c87a6cfce9c36588b32f5279e63072bc2646c36f))
+
+### Refactoring
+
+- **serializer**: Upgrade to new serializer interface
+  ([`3d807ea`](https://github.com/bec-project/bec_widgets/commit/3d807eaa63980fd2bb11661696c4d8548fffde8c))
+
+### Testing
+
+- **deviceconfig-form-update**: Add onFailure default to test
+  ([`1dd20d5`](https://github.com/bec-project/bec_widgets/commit/1dd20d5986485f3bfe7ee02596ca23027ec4b756))
+
+
+## v2.40.0 (2025-10-08)
+
+### Bug Fixes
+
+- **curve_tree**: Fetching scan numbers directly from the bec client
+  ([`8111a4a`](https://github.com/bec-project/bec_widgets/commit/8111a4a21b7c1bd75316e9a1f1166b88ea52326d))
+
+- **curve_tree**: Safeguard fetching scan numbers from BEC client
+  ([`df8065e`](https://github.com/bec-project/bec_widgets/commit/df8065ea4000b24235520756515aa18f812bb390))
+
+- **curve_tree**: Scans are always fetched by scan ids
+  ([`20a59af`](https://github.com/bec-project/bec_widgets/commit/20a59af648a9808057df2226a3a3c12893cc5059))
+
+- **waveform**: Cleanup of scan_history dialog if not closed manually before widget
+  ([`d681ba5`](https://github.com/bec-project/bec_widgets/commit/d681ba538be9ccec45a1ebd412cbc33c8c7c0ae2))
+
+- **waveform**: Fetching scan number is not done from list but from .get_by_scan_number
+  ([`962ab77`](https://github.com/bec-project/bec_widgets/commit/962ab774e6afc73a321a5680e2862d9e41812888))
+
+- **waveform**: If scan id and scan number is provided, the scan is fetched from the scan id
+  ([`e59f27a`](https://github.com/bec-project/bec_widgets/commit/e59f27a22de490768c814c80642a7a91bebfef5b))
+
+- **waveform**: Safeguard added to the fetching history data
+  ([`540cfc3`](https://github.com/bec-project/bec_widgets/commit/540cfc37be65afcf721773564adc85de681a9d07))
+
+- **waveform**: Safeguard for _scan_history_closed
+  ([`2bf4896`](https://github.com/bec-project/bec_widgets/commit/2bf489600e96bb5b47d89bed261614f62c970ca9))
+
+- **waveform**: Safeguard for if scan_item is a list
+  ([`7e88a00`](https://github.com/bec-project/bec_widgets/commit/7e88a002b6ca40fc85fde993282b8706f140d9aa))
+
+- **waveform**: Update x suffix label with x property change, do not wait for next update cycle
+  ([`d19001c`](https://github.com/bec-project/bec_widgets/commit/d19001c94e652c0c3e18f8d7903fd1ccff1111cd))
+
+- **waveform**: X_data checked with is scalar instead of len()
+  ([`db7dd4f`](https://github.com/bec-project/bec_widgets/commit/db7dd4f8d4b1210e65c852f6193fc8cf0f4809a5))
+
+### Build System
+
+- **bec_lib**: Bec_lib dependency raised to 3.68
+  ([`2f3dc2c`](https://github.com/bec-project/bec_widgets/commit/2f3dc2ce6b7133fc5582bd6996a674590cf1002d))
+
+### Chores
+
+- Add dependabot config
+  ([`f25f865`](https://github.com/bec-project/bec_widgets/commit/f25f86522f0a2e9dd24ca862ea8de89873951f83))
+
+### Features
+
+- **waveform**: New type of curve - history curve
+  ([`f083dff`](https://github.com/bec-project/bec_widgets/commit/f083dff6128c6256443b49f54ab12b54f1b90d66))
+
+### Refactoring
+
+- **test_waveform**: Test waveform renamed
+  ([`2f798be`](https://github.com/bec-project/bec_widgets/commit/2f798be7b0d43d304ccbd0e992a9d62f1aa1dd5f))
+
+- **waveform**: Separate method to fetch scan item from history
+  ([`4be7058`](https://github.com/bec-project/bec_widgets/commit/4be70580a60293204b135c6ea77978f1dcf8aa5f))
+
+### Testing
+
+- **conftest**: Suppress_message_box for error popups fixture autouse True
+  ([`0844a9e`](https://github.com/bec-project/bec_widgets/commit/0844a9e11975a34780b1dc413f5145517d1a1a22))
+
+- **plotting_framework_e2e**: Fetching history curve
+  ([`a006f95`](https://github.com/bec-project/bec_widgets/commit/a006f95f211ad115019967e365a6627d9678a1e3))
+
+- **waveform,curve_tree**: Test extended to cover history curve behaviour
+  ([`5a5d323`](https://github.com/bec-project/bec_widgets/commit/5a5d32312b08e1edeb69243daddfaaa9bac22273))
+
+
+## v2.39.1 (2025-10-07)
+
+### Bug Fixes
+
+- Explicitly pass the cached readout flag
+  ([`50696bc`](https://github.com/bec-project/bec_widgets/commit/50696bce4ce14c61b4bdda8c6fb40967972e6b23))
+
+
+## v2.39.0 (2025-09-24)
+
+### Bug Fixes
+
+- **rpc**: Fix hide/show
+  ([`975404f`](https://github.com/bec-project/bec_widgets/commit/975404f483ddae041d9f4d819f39c53cec191439))
+
+### Features
+
+- **rpc_base**: Windows can be raised to front from CLI
+  ([`565c0bd`](https://github.com/bec-project/bec_widgets/commit/565c0bd1e7f4684d8401b6a2827c35422b1125c4))
+
+
+## v2.38.4 (2025-09-23)
+
+### Bug Fixes
+
+- **image**: Add support for specifying preview signals through cli
+  ([`108ddae`](https://github.com/bec-project/bec_widgets/commit/108ddae6ca3501a57b499c7080a36cf41a653074))
+
+
+## v2.38.3 (2025-09-23)
+
+### Bug Fixes
+
+- **connector**: Only flush pending events
+  ([`475ca9f`](https://github.com/bec-project/bec_widgets/commit/475ca9f2d81bcc2bb0c7b104c0712b13d6616c08))
+
+- **ringprogressbar**: Fix client signature
+  ([`65bc5f5`](https://github.com/bec-project/bec_widgets/commit/65bc5f5421077da70ef5068d51e36119e1055955))
+
+- **ringprogressbar**: Various fixes and improvements
+  ([`bbb5fc6`](https://github.com/bec-project/bec_widgets/commit/bbb5fc6ce17248a948c6fd4a7652d17d64a79d2a))
+
+### Chores
+
+- Deprecate 3.10, add 3.13
+  ([`3e33934`](https://github.com/bec-project/bec_widgets/commit/3e339348dd3d0a3b12522312132fca139dc22835))
+
+### Testing
+
+- **ringprogressbar**: Extend e2e test
+  ([`b1b6c5e`](https://github.com/bec-project/bec_widgets/commit/b1b6c5e6a5dd81965baa5c742e9bdae8cdb4f09b))
+
+
+## v2.38.2 (2025-09-11)
+
+### Bug Fixes
+
+- **crosshair**: Ignore fetching data and markers from invisible items
+  ([`72b6f74`](https://github.com/bec-project/bec_widgets/commit/72b6f74252e1f36339945c549049b166cccf3561))
+
+- **plot_base**: Crosshair items are excluded from visible curves and from auto_range
+  ([`4dc4ede`](https://github.com/bec-project/bec_widgets/commit/4dc4ede1d251d081e5bcf3d37fcc784982c9258e))
+
+- **plot_base**: Visible items injected into plot item
+  ([`b703b37`](https://github.com/bec-project/bec_widgets/commit/b703b37bbdbf97182b58ac4c69c1384fa78d0c12))
+
+- **waveform**: Changing curve visibility refresh markers
+  ([`556832f`](https://github.com/bec-project/bec_widgets/commit/556832fd48bcb16b95df8cf91417d7045bbca2a3))
+
+### Continuous Integration
+
+- Fix stale issues job permissions; add workflow dispatch option
+  ([`fe67a4f`](https://github.com/bec-project/bec_widgets/commit/fe67a4f325cbd41f13102e5698d86ed9e90b048e))
+
+### Documentation
+
+- Move to autoapi
+  ([`18ef35f`](https://github.com/bec-project/bec_widgets/commit/18ef35f22a1b7496b13f833e63a4f3875e1497e3))
+
+### Testing
+
+- **crosshair**: Visibility test added with plotbase fixture
+  ([`3a2ec9f`](https://github.com/bec-project/bec_widgets/commit/3a2ec9f1b74c4bb5f239940b874576a877ce45c0))
+
+
+## v2.38.1 (2025-08-22)
+
+### Bug Fixes
+
+- Move thefuzz dependency to prod
+  ([`ad7cdc6`](https://github.com/bec-project/bec_widgets/commit/ad7cdc60dd6da6c5291f8b42932aacb12aa671a6))
+
+
 ## v2.38.0 (2025-08-19)
 
 ### Features

README.md

@@ -5,7 +5,7 @@
 [![badge](https://img.shields.io/pypi/v/bec-widgets)](https://pypi.org/project/bec-widgets/)
 [![License](https://img.shields.io/github/license/bec-project/bec_widgets)](./LICENSE)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
-[![Python](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12-blue?logo=python&logoColor=white)](https://www.python.org)
+[![Python](https://img.shields.io/badge/python-3.11%20%7C%203.12%20%7C%203.13-blue?logo=python&logoColor=white)](https://www.python.org)
 [![PySide6](https://img.shields.io/badge/PySide6-blue?logo=qt&logoColor=white)](https://doc.qt.io/qtforpython/)
 [![Conventional Commits](https://img.shields.io/badge/conventional%20commits-1.0.0-yellow?logo=conventionalcommits&logoColor=white)](https://conventionalcommits.org)
 [![codecov](https://codecov.io/gh/bec-project/bec_widgets/graph/badge.svg?token=0Z9IQRJKMY)](https://codecov.io/gh/bec-project/bec_widgets)

bec_widgets/cli/client.py

@@ -2218,7 +2218,7 @@ class Image(RPCBase):
         Set the image source and update the image.
 
         Args:
-            monitor(str): The name of the monitor to use for the image.
+            monitor(str|tuple|None): The name of the monitor to use for the image, or a tuple of (device, signal) for preview signals. If None or empty string, the current monitor will be disconnected.
             monitor_type(str): The type of monitor to use. Options are "1d", "2d", or "auto".
             color_map(str): The color map to use for the image.
             color_bar(str): The type of color bar to use. Options are "simple" or "full".
@@ -3534,6 +3534,34 @@ class PositionerBox2D(RPCBase):
         Take a screenshot of the dock area and save it to a file.
         """
 
+    @property
+    @rpc_call
+    def enable_controls_hor(self) -> "bool":
+        """
+        Persisted switch for horizontal control buttons (tweak/step).
+        """
+
+    @enable_controls_hor.setter
+    @rpc_call
+    def enable_controls_hor(self) -> "bool":
+        """
+        Persisted switch for horizontal control buttons (tweak/step).
+        """
+
+    @property
+    @rpc_call
+    def enable_controls_ver(self) -> "bool":
+        """
+        Persisted switch for vertical control buttons (tweak/step).
+        """
+
+    @enable_controls_ver.setter
+    @rpc_call
+    def enable_controls_ver(self) -> "bool":
+        """
+        Persisted switch for vertical control buttons (tweak/step).
+        """
+
 
 class PositionerControlLine(RPCBase):
     """A widget that controls a single device."""
@@ -3653,8 +3681,8 @@ class RectangularROI(RPCBase):
     @rpc_call
     def get_coordinates(self, typed: "bool | None" = None) -> "dict | tuple":
         """
-        Returns the coordinates of a rectangle's corners. Supports returning them
-        as either a dictionary with descriptive keys or a tuple of coordinates.
+        Returns the coordinates of a rectangle's corners, rectangle center and dimensions.
+        Supports returning them as either a dictionary with descriptive keys or a tuple of coordinates.
 
         Args:
             typed (bool | None): If True, returns coordinates as a dictionary with
@@ -3662,7 +3690,7 @@ class RectangularROI(RPCBase):
                 the value of `self.description`.
 
         Returns:
-            dict | tuple: The rectangle's corner coordinates, where the format
+            dict | tuple: The rectangle's corner coordinates, rectangle center and dimensions, where the format
                 depends on the `typed` parameter.
         """
 
@@ -3880,7 +3908,7 @@ class RingProgressBar(RPCBase):
         """
 
     @rpc_call
-    def set_precision(self, precision: "int", bar_index: "int" = None):
+    def set_precision(self, precision: "int", bar_index: "int | None" = None):
         """
         Set the precision for the progress bars. If bar_index is not provide, the precision will be set for all progress bars.
 
@@ -5079,6 +5107,8 @@ class Waveform(RPCBase):
         color: "str | None" = None,
         label: "str | None" = None,
         dap: "str | None" = None,
+        scan_id: "str | None" = None,
+        scan_number: "int | None" = None,
         **kwargs,
     ) -> "Curve":
         """
@@ -5101,6 +5131,10 @@ class Waveform(RPCBase):
             dap(str): The dap model to use for the curve, only available for sync devices.
             If not specified, none will be added.
             Use the same string as is the name of the LMFit model.
+            scan_id(str):  Optional scan ID. When provided, the curve is treated as a **history** curve and
+                the y‑data (and optional x‑data) are fetched from that historical scan. Such curves are
+                never cleared by live‑scan resets.
+            scan_number(int): Optional scan index. When provided, the curve is treated as a **history** curve and
 
         Returns:
             Curve: The curve object.
@@ -5143,11 +5177,11 @@ class Waveform(RPCBase):
     def update_with_scan_history(self, scan_index: "int" = None, scan_id: "str" = None):
         """
         Update the scan curves with the data from the scan storage.
-        Provide only one of scan_id or scan_index.
+        If both arguments are provided, scan_id takes precedence and scan_index is ignored.
 
         Args:
             scan_id(str, optional): ScanID of the scan to be updated. Defaults to None.
-            scan_index(int, optional): Index of the scan to be updated. Defaults to None.
+            scan_index(int, optional): Index (scan number) of the scan to be updated. Defaults to None.
         """
 
     @rpc_call

bec_widgets/cli/client_utils.py

@@ -285,6 +285,18 @@ class BECGuiClient(RPCBase):
         """Hide the GUI window."""
         return self._hide_all()
 
+    def raise_window(self, wait: bool = True) -> None:
+        """
+        Bring GUI windows to the front.
+        If the GUI server is not running, it will be started.
+
+        Args:
+            wait(bool): Whether to wait for the server to start. Defaults to True.
+        """
+        if self._check_if_server_is_alive():
+            return self._raise_all()
+        return self._start(wait=wait)
+
     def new(
         self,
         name: str | None = None,
@@ -443,8 +455,8 @@ class BECGuiClient(RPCBase):
         self._update_dynamic_namespace(self._server_registry)
 
     def _do_show_all(self):
-        rpc_client = RPCBase(gui_id=f"{self._gui_id}:launcher", parent=self)
-        rpc_client._run_rpc("show")  # pylint: disable=protected-access
+        if self.launcher and len(self._top_level) == 0:
+            self.launcher._run_rpc("show")  # pylint: disable=protected-access
         for window in self._top_level.values():
             window.show()
 
@@ -454,11 +466,24 @@ class BECGuiClient(RPCBase):
 
     def _hide_all(self):
         with wait_for_server(self):
-            rpc_client = RPCBase(gui_id=f"{self._gui_id}:launcher", parent=self)
-            rpc_client._run_rpc("hide")  # pylint: disable=protected-access
-            if not self._killed:
-                for window in self._top_level.values():
-                    window.hide()
+            if self._killed:
+                return
+            self.launcher._run_rpc("hide")
+            for window in self._top_level.values():
+                window.hide()
+
+    def _do_raise_all(self):
+        """Bring GUI windows to the front."""
+        if self.launcher and len(self._top_level) == 0:
+            self.launcher._run_rpc("raise")  # pylint: disable=protected-access
+        for window in self._top_level.values():
+            window._run_rpc("raise")  # type: ignore[attr-defined]
+
+    def _raise_all(self):
+        with wait_for_server(self):
+            if self._killed:
+                return
+            return self._do_raise_all()
 
     def _update_dynamic_namespace(self, server_registry: dict):
         """

bec_widgets/cli/rpc/rpc_base.py

@@ -202,6 +202,11 @@ class RPCBase:
             parent = parent._parent
         return parent  # type: ignore
 
+    def raise_window(self):
+        """Bring this widget (or its container) to the front."""
+        # Use explicit call to ensure action name is 'raise' (not 'raise_')
+        return self._run_rpc("raise")
+
     def _run_rpc(
         self,
         method,
@@ -225,6 +230,12 @@ class RPCBase:
         Returns:
             The result of the RPC call.
         """
+        if method in ["show", "hide", "raise"] and gui_id is None:
+            obj = self._root._server_registry.get(self._gui_id)
+            if obj is None:
+                raise ValueError(f"Widget {self._gui_id} not found.")
+            gui_id = obj.get("container_proxy")  # type: ignore
+
         request_id = str(uuid.uuid4())
         rpc_msg = messages.GUIInstructionMessage(
             action=method,

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -55,7 +55,7 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
                     # "btn6": self.btn6,
                     # "pb": self.pb,
                     # "pi": self.pi,
-                    # "wf": self.wf,
+                    "wf": self.wf,
                     # "scatter": self.scatter,
                     # "scatter_mi": self.scatter,
                     # "mwf": self.mwf,
@@ -105,12 +105,11 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         # self.btn5 = QPushButton("Button 5")
         # self.btn6 = QPushButton("Button 6")
         #
-        # fifth_tab = QWidget()
-        # fifth_tab_layout = QVBoxLayout(fifth_tab)
-        # self.wf = Waveform()
-        # fifth_tab_layout.addWidget(self.wf)
-        # tab_widget.addTab(fifth_tab, "Waveform Next Gen")
-        # tab_widget.setCurrentIndex(4)
+        fifth_tab = QWidget()
+        fifth_tab_layout = QVBoxLayout(fifth_tab)
+        self.wf = Waveform()
+        fifth_tab_layout.addWidget(self.wf)
+        tab_widget.addTab(fifth_tab, "Waveform Next Gen")
         #
         sixth_tab = QWidget()
         sixth_tab_layout = QVBoxLayout(sixth_tab)

bec_widgets/tests/client_mocks.py

@@ -7,8 +7,9 @@ import pytest
 from bec_lib.bec_service import messages
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.redis_connector import RedisConnector
+from bec_lib.scan_history import ScanHistory
 
-from bec_widgets.tests.utils import DEVICES, DMMock, FakePositioner, Positioner
+from bec_widgets.tests.fake_devices import DEVICES, DMMock, FakePositioner, Positioner
 
 
 def fake_redis_server(host, port):
@@ -238,3 +239,18 @@ def create_dummy_scan_item():
         "scan_report_devices": ["samx"],
     }
     return dummy_scan
+
+
+def inject_scan_history(widget, scan_history_factory, *history_args):
+    """
+    Helper to inject scan history messages into client history.
+    """
+    history_msgs = []
+    for scan_id, scan_number in history_args:
+        history_msgs.append(scan_history_factory(scan_id=scan_id, scan_number=scan_number))
+    widget.client.history = ScanHistory(widget.client, False)
+    for msg in history_msgs:
+        widget.client.history._scan_data[msg.scan_id] = msg
+        widget.client.history._scan_ids.append(msg.scan_id)
+    widget.client.queue.scan_storage.current_scan = None
+    return history_msgs

bec_widgets/tests/fake_devices.py

@@ -0,0 +1,285 @@
+from unittest.mock import MagicMock
+
+from bec_lib.device import Device as BECDevice
+from bec_lib.device import Positioner as BECPositioner
+from bec_lib.device import ReadoutPriority
+from bec_lib.devicemanager import DeviceContainer
+
+
+class FakeDevice(BECDevice):
+    """Fake minimal positioner class for testing."""
+
+    def __init__(self, name, enabled=True, readout_priority=ReadoutPriority.MONITORED):
+        super().__init__(name=name)
+        self._enabled = enabled
+        self.signals = {self.name: {"value": 1.0}}
+        self.description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
+        self._readout_priority = readout_priority
+        self._config = {
+            "readoutPriority": "baseline",
+            "deviceClass": "ophyd.Device",
+            "deviceConfig": {},
+            "deviceTags": {"user device"},
+            "enabled": enabled,
+            "readOnly": False,
+            "name": self.name,
+        }
+
+    @property
+    def readout_priority(self):
+        return self._readout_priority
+
+    @readout_priority.setter
+    def readout_priority(self, value):
+        self._readout_priority = value
+
+    @property
+    def limits(self) -> tuple[float, float]:
+        return self._limits
+
+    @limits.setter
+    def limits(self, value: tuple[float, float]):
+        self._limits = value
+
+    def __contains__(self, item):
+        return item == self.name
+
+    @property
+    def _hints(self):
+        return [self.name]
+
+    def set_value(self, fake_value: float = 1.0) -> None:
+        """
+        Setup fake value for device readout
+        Args:
+            fake_value(float): Desired fake value
+        """
+        self.signals[self.name]["value"] = fake_value
+
+    def describe(self) -> dict:
+        """
+        Get the description of the device
+        Returns:
+            dict: Description of the device
+        """
+        return self.description
+
+
+class FakePositioner(BECPositioner):
+
+    def __init__(
+        self,
+        name,
+        enabled=True,
+        limits=None,
+        read_value=1.0,
+        readout_priority=ReadoutPriority.MONITORED,
+    ):
+        super().__init__(name=name)
+        # self.limits = limits if limits is not None else [0.0, 0.0]
+        self.read_value = read_value
+        self.setpoint_value = read_value
+        self.motor_is_moving_value = 0
+        self._enabled = enabled
+        self._limits = limits
+        self._readout_priority = readout_priority
+        self.signals = {self.name: {"value": 1.0}}
+        self.description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
+        self._config = {
+            "readoutPriority": "baseline",
+            "deviceClass": "ophyd_devices.SimPositioner",
+            "deviceConfig": {"delay": 1, "tolerance": 0.01, "update_frequency": 400},
+            "deviceTags": {"user motors"},
+            "enabled": enabled,
+            "readOnly": False,
+            "name": self.name,
+        }
+        self._info = {
+            "signals": {
+                "readback": {
+                    "kind_str": "hinted",
+                    "component_name": "readback",
+                    "obj_name": self.name,
+                },  # hinted
+                "setpoint": {
+                    "kind_str": "normal",
+                    "component_name": "setpoint",
+                    "obj_name": f"{self.name}_setpoint",
+                },  # normal
+                "velocity": {
+                    "kind_str": "config",
+                    "component_name": "velocity",
+                    "obj_name": f"{self.name}_velocity",
+                },  # config
+            }
+        }
+        self.signals = {
+            self.name: {"value": self.read_value},
+            f"{self.name}_setpoint": {"value": self.setpoint_value},
+            f"{self.name}_motor_is_moving": {"value": self.motor_is_moving_value},
+        }
+
+    @property
+    def readout_priority(self):
+        return self._readout_priority
+
+    @readout_priority.setter
+    def readout_priority(self, value):
+        self._readout_priority = value
+
+    @property
+    def enabled(self) -> bool:
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, value: bool):
+        self._enabled = value
+
+    @property
+    def limits(self) -> tuple[float, float]:
+        return self._limits
+
+    @limits.setter
+    def limits(self, value: tuple[float, float]):
+        self._limits = value
+
+    def __contains__(self, item):
+        return item == self.name
+
+    @property
+    def _hints(self):
+        return [self.name]
+
+    def set_value(self, fake_value: float = 1.0) -> None:
+        """
+        Setup fake value for device readout
+        Args:
+            fake_value(float): Desired fake value
+        """
+        self.read_value = fake_value
+
+    def describe(self) -> dict:
+        """
+        Get the description of the device
+        Returns:
+            dict: Description of the device
+        """
+        return self.description
+
+    @property
+    def precision(self):
+        return 3
+
+    def set_read_value(self, value):
+        self.read_value = value
+
+    def read(self, cached=False):
+        return self.signals
+
+    def set_limits(self, limits):
+        self.limits = limits
+
+    def move(self, value, relative=False):
+        """Simulates moving the device to a new position."""
+        if relative:
+            self.read_value += value
+        else:
+            self.read_value = value
+        # Respect the limits
+        self.read_value = max(min(self.read_value, self.limits[1]), self.limits[0])
+
+    @property
+    def readback(self):
+        return MagicMock(get=MagicMock(return_value=self.read_value))
+
+
+class Positioner(FakePositioner):
+    """just placeholder for testing embedded isinstance check in DeviceCombobox"""
+
+    def __init__(self, name="test", limits=None, read_value=1.0, enabled=True):
+        super().__init__(name, limits=limits, read_value=read_value, enabled=enabled)
+
+
+class Device(FakeDevice):
+    """just placeholder for testing embedded isinstance check in DeviceCombobox"""
+
+    def __init__(self, name, enabled=True):
+        super().__init__(name, enabled)
+
+
+class DMMock:
+    def __init__(self):
+        self.devices = DeviceContainer()
+        self.enabled_devices = [device for device in self.devices if device.enabled]
+
+    def add_devices(self, devices: list):
+        """
+        Add devices to the DeviceContainer.
+
+        Args:
+            devices (list): List of device instances to add.
+        """
+        for device in devices:
+            self.devices[device.name] = device
+
+    def get_bec_signals(self, signal_class_name: str):
+        """
+        Emulate DeviceManager.get_bec_signals for unit-tests.
+
+        For “AsyncSignal” we list every device whose readout_priority is
+        ReadoutPriority.ASYNC and build a minimal tuple
+        (device_name, signal_name, signal_info_dict) that matches the real
+        API shape used by Waveform._check_async_signal_found.
+        """
+        signals: list[tuple[str, str, dict]] = []
+        if signal_class_name != "AsyncSignal":
+            return signals
+
+        for device in self.devices.values():
+            if getattr(device, "readout_priority", None) == ReadoutPriority.ASYNC:
+                device_name = device.name
+                signal_name = device.name  # primary signal in our mocks
+                signal_info = {
+                    "component_name": signal_name,
+                    "obj_name": signal_name,
+                    "kind_str": "hinted",
+                    "signal_class": signal_class_name,
+                    "metadata": {
+                        "connected": True,
+                        "precision": None,
+                        "read_access": True,
+                        "timestamp": 0.0,
+                        "write_access": True,
+                    },
+                }
+                signals.append((device_name, signal_name, signal_info))
+        return signals
+
+
+DEVICES = [
+    FakePositioner("samx", limits=[-10, 10], read_value=2.0),
+    FakePositioner("samy", limits=[-5, 5], read_value=3.0),
+    FakePositioner("samz", limits=[-8, 8], read_value=4.0),
+    FakePositioner("aptrx", limits=None, read_value=4.0),
+    FakePositioner("aptry", limits=None, read_value=5.0),
+    FakeDevice("gauss_bpm"),
+    FakeDevice("gauss_adc1"),
+    FakeDevice("gauss_adc2"),
+    FakeDevice("gauss_adc3"),
+    FakeDevice("bpm4i"),
+    FakeDevice("bpm3a"),
+    FakeDevice("bpm3i"),
+    FakeDevice("eiger", readout_priority=ReadoutPriority.ASYNC),
+    FakeDevice("waveform1d"),
+    FakeDevice("async_device", readout_priority=ReadoutPriority.ASYNC),
+    Positioner("test", limits=[-10, 10], read_value=2.0),
+    Device("test_device"),
+]
+
+
+def check_remote_data_size(widget, plot_name, num_elements):
+    """
+    Check if the remote data has the correct number of elements.
+    Used in the qtbot.waitUntil function.
+    """
+    return len(widget.get_all_data()[plot_name]["x"]) == num_elements

bec_widgets/tests/utils.py

@@ -1,285 +1,76 @@
-from unittest.mock import MagicMock
+from pytestqt.exceptions import TimeoutError as QtBotTimeoutError
+from qtpy.QtCore import QTimer
+from qtpy.QtWidgets import QApplication
 
-from bec_lib.device import Device as BECDevice
-from bec_lib.device import Positioner as BECPositioner
-from bec_lib.device import ReadoutPriority
-from bec_lib.devicemanager import DeviceContainer
+from bec_widgets.cli.rpc.rpc_register import RPCRegister
+from bec_widgets.utils import bec_dispatcher as bec_dispatcher_module
+from bec_widgets.utils import error_popups
 
 
-class FakeDevice(BECDevice):
-    """Fake minimal positioner class for testing."""
+class TestableQTimer(QTimer):
+    _instances: list[tuple[QTimer, str]] = []
+    _current_test_name: str = ""
 
-    def __init__(self, name, enabled=True, readout_priority=ReadoutPriority.MONITORED):
-        super().__init__(name=name)
-        self._enabled = enabled
-        self.signals = {self.name: {"value": 1.0}}
-        self.description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
-        self._readout_priority = readout_priority
-        self._config = {
-            "readoutPriority": "baseline",
-            "deviceClass": "ophyd.Device",
-            "deviceConfig": {},
-            "deviceTags": {"user device"},
-            "enabled": enabled,
-            "readOnly": False,
-            "name": self.name,
-        }
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        TestableQTimer._instances.append((self, TestableQTimer._current_test_name))
 
-    @property
-    def readout_priority(self):
-        return self._readout_priority
+    @classmethod
+    def check_all_stopped(cls, qtbot):
+        def _is_done_or_deleted(t: QTimer):
+            try:
+                return not t.isActive()
+            except RuntimeError as e:
+                return "already deleted" in e.args[0]
 
-    @readout_priority.setter
-    def readout_priority(self, value):
-        self._readout_priority = value
-
-    @property
-    def limits(self) -> tuple[float, float]:
-        return self._limits
-
-    @limits.setter
-    def limits(self, value: tuple[float, float]):
-        self._limits = value
-
-    def __contains__(self, item):
-        return item == self.name
-
-    @property
-    def _hints(self):
-        return [self.name]
-
-    def set_value(self, fake_value: float = 1.0) -> None:
-        """
-        Setup fake value for device readout
-        Args:
-            fake_value(float): Desired fake value
-        """
-        self.signals[self.name]["value"] = fake_value
-
-    def describe(self) -> dict:
-        """
-        Get the description of the device
-        Returns:
-            dict: Description of the device
-        """
-        return self.description
+        try:
+            qtbot.waitUntil(lambda: all(_is_done_or_deleted(timer) for timer, _ in cls._instances))
+        except QtBotTimeoutError as exc:
+            active_timers = list(filter(lambda t: t[0].isActive(), cls._instances))
+            (t.stop() for t, _ in cls._instances)
+            raise TimeoutError(f"Failed to stop all timers: {active_timers}") from exc
+        cls._instances = []
 
 
-class FakePositioner(BECPositioner):
+def qapplication_fixture(qtbot, request, testable_qtimer_class):
+    yield
 
-    def __init__(
-        self,
-        name,
-        enabled=True,
-        limits=None,
-        read_value=1.0,
-        readout_priority=ReadoutPriority.MONITORED,
-    ):
-        super().__init__(name=name)
-        # self.limits = limits if limits is not None else [0.0, 0.0]
-        self.read_value = read_value
-        self.setpoint_value = read_value
-        self.motor_is_moving_value = 0
-        self._enabled = enabled
-        self._limits = limits
-        self._readout_priority = readout_priority
-        self.signals = {self.name: {"value": 1.0}}
-        self.description = {self.name: {"source": self.name, "dtype": "number", "shape": []}}
-        self._config = {
-            "readoutPriority": "baseline",
-            "deviceClass": "ophyd_devices.SimPositioner",
-            "deviceConfig": {"delay": 1, "tolerance": 0.01, "update_frequency": 400},
-            "deviceTags": {"user motors"},
-            "enabled": enabled,
-            "readOnly": False,
-            "name": self.name,
-        }
-        self._info = {
-            "signals": {
-                "readback": {
-                    "kind_str": "hinted",
-                    "component_name": "readback",
-                    "obj_name": self.name,
-                },  # hinted
-                "setpoint": {
-                    "kind_str": "normal",
-                    "component_name": "setpoint",
-                    "obj_name": f"{self.name}_setpoint",
-                },  # normal
-                "velocity": {
-                    "kind_str": "config",
-                    "component_name": "velocity",
-                    "obj_name": f"{self.name}_velocity",
-                },  # config
-            }
-        }
-        self.signals = {
-            self.name: {"value": self.read_value},
-            f"{self.name}_setpoint": {"value": self.setpoint_value},
-            f"{self.name}_motor_is_moving": {"value": self.motor_is_moving_value},
-        }
+    if request.node.stash._storage.get("failed"):
+        print("Test failed, skipping cleanup checks")
+        return
 
-    @property
-    def readout_priority(self):
-        return self._readout_priority
+    bec_dispatcher = bec_dispatcher_module.BECDispatcher()
+    bec_dispatcher.stop_cli_server()
 
-    @readout_priority.setter
-    def readout_priority(self, value):
-        self._readout_priority = value
-
-    @property
-    def enabled(self) -> bool:
-        return self._enabled
-
-    @enabled.setter
-    def enabled(self, value: bool):
-        self._enabled = value
-
-    @property
-    def limits(self) -> tuple[float, float]:
-        return self._limits
-
-    @limits.setter
-    def limits(self, value: tuple[float, float]):
-        self._limits = value
-
-    def __contains__(self, item):
-        return item == self.name
-
-    @property
-    def _hints(self):
-        return [self.name]
-
-    def set_value(self, fake_value: float = 1.0) -> None:
-        """
-        Setup fake value for device readout
-        Args:
-            fake_value(float): Desired fake value
-        """
-        self.read_value = fake_value
-
-    def describe(self) -> dict:
-        """
-        Get the description of the device
-        Returns:
-            dict: Description of the device
-        """
-        return self.description
-
-    @property
-    def precision(self):
-        return 3
-
-    def set_read_value(self, value):
-        self.read_value = value
-
-    def read(self):
-        return self.signals
-
-    def set_limits(self, limits):
-        self.limits = limits
-
-    def move(self, value, relative=False):
-        """Simulates moving the device to a new position."""
-        if relative:
-            self.read_value += value
-        else:
-            self.read_value = value
-        # Respect the limits
-        self.read_value = max(min(self.read_value, self.limits[1]), self.limits[0])
-
-    @property
-    def readback(self):
-        return MagicMock(get=MagicMock(return_value=self.read_value))
+    testable_qtimer_class.check_all_stopped(qtbot)
+    qapp = QApplication.instance()
+    qapp.processEvents()
+    if hasattr(qapp, "os_listener") and qapp.os_listener:
+        qapp.removeEventFilter(qapp.os_listener)
+    try:
+        qtbot.waitUntil(lambda: qapp.topLevelWidgets() == [])
+    except QtBotTimeoutError as exc:
+        raise TimeoutError(f"Failed to close all widgets: {qapp.topLevelWidgets()}") from exc
 
 
-class Positioner(FakePositioner):
-    """just placeholder for testing embedded isinstance check in DeviceCombobox"""
-
-    def __init__(self, name="test", limits=None, read_value=1.0, enabled=True):
-        super().__init__(name, limits=limits, read_value=read_value, enabled=enabled)
+def rpc_register_fixture():
+    try:
+        yield RPCRegister()
+    finally:
+        RPCRegister.reset_singleton()
 
 
-class Device(FakeDevice):
-    """just placeholder for testing embedded isinstance check in DeviceCombobox"""
-
-    def __init__(self, name, enabled=True):
-        super().__init__(name, enabled)
+def bec_dispatcher_fixture(threads_check):
+    bec_dispatcher = bec_dispatcher_module.BECDispatcher()
+    try:
+        yield bec_dispatcher
+    finally:
+        bec_dispatcher.disconnect_all()
+        bec_dispatcher.client.shutdown()
+        bec_dispatcher.stop_cli_server()
+        bec_dispatcher_module.BECDispatcher.reset_singleton()
 
 
-class DMMock:
-    def __init__(self):
-        self.devices = DeviceContainer()
-        self.enabled_devices = [device for device in self.devices if device.enabled]
-
-    def add_devices(self, devices: list):
-        """
-        Add devices to the DeviceContainer.
-
-        Args:
-            devices (list): List of device instances to add.
-        """
-        for device in devices:
-            self.devices[device.name] = device
-
-    def get_bec_signals(self, signal_class_name: str):
-        """
-        Emulate DeviceManager.get_bec_signals for unit-tests.
-
-        For “AsyncSignal” we list every device whose readout_priority is
-        ReadoutPriority.ASYNC and build a minimal tuple
-        (device_name, signal_name, signal_info_dict) that matches the real
-        API shape used by Waveform._check_async_signal_found.
-        """
-        signals: list[tuple[str, str, dict]] = []
-        if signal_class_name != "AsyncSignal":
-            return signals
-
-        for device in self.devices.values():
-            if getattr(device, "readout_priority", None) == ReadoutPriority.ASYNC:
-                device_name = device.name
-                signal_name = device.name  # primary signal in our mocks
-                signal_info = {
-                    "component_name": signal_name,
-                    "obj_name": signal_name,
-                    "kind_str": "hinted",
-                    "signal_class": signal_class_name,
-                    "metadata": {
-                        "connected": True,
-                        "precision": None,
-                        "read_access": True,
-                        "timestamp": 0.0,
-                        "write_access": True,
-                    },
-                }
-                signals.append((device_name, signal_name, signal_info))
-        return signals
-
-
-DEVICES = [
-    FakePositioner("samx", limits=[-10, 10], read_value=2.0),
-    FakePositioner("samy", limits=[-5, 5], read_value=3.0),
-    FakePositioner("samz", limits=[-8, 8], read_value=4.0),
-    FakePositioner("aptrx", limits=None, read_value=4.0),
-    FakePositioner("aptry", limits=None, read_value=5.0),
-    FakeDevice("gauss_bpm"),
-    FakeDevice("gauss_adc1"),
-    FakeDevice("gauss_adc2"),
-    FakeDevice("gauss_adc3"),
-    FakeDevice("bpm4i"),
-    FakeDevice("bpm3a"),
-    FakeDevice("bpm3i"),
-    FakeDevice("eiger", readout_priority=ReadoutPriority.ASYNC),
-    FakeDevice("waveform1d"),
-    FakeDevice("async_device", readout_priority=ReadoutPriority.ASYNC),
-    Positioner("test", limits=[-10, 10], read_value=2.0),
-    Device("test_device"),
-]
-
-
-def check_remote_data_size(widget, plot_name, num_elements):
-    """
-    Check if the remote data has the correct number of elements.
-    Used in the qtbot.waitUntil function.
-    """
-    return len(widget.get_all_data()[plot_name]["x"]) == num_elements
+def clean_singleton_fixture():
+    error_popups._popup_utility_instance = None
+    yield

bec_widgets/utils/bec_connector.py

@@ -213,7 +213,7 @@ class BECConnector:
           - If there's a nearest BECConnector parent, only compare with children of that parent.
           - If parent is None (i.e., top-level object), compare with all other top-level BECConnectors.
         """
-        QApplication.processEvents()
+        QApplication.sendPostedEvents()
         parent_bec = WidgetHierarchy._get_becwidget_ancestor(self)
 
         if parent_bec:

bec_widgets/utils/crosshair.py

@@ -209,8 +209,11 @@ class Crosshair(QObject):
         if self.highlighted_curve_index is not None and hasattr(self.plot_item, "visible_curves"):
             # Focus on the highlighted curve only
             self.items = [self.plot_item.visible_curves[self.highlighted_curve_index]]
-        else:
-            # Handle all curves
+        elif hasattr(self.plot_item, "visible_items"):  # PlotBase general case
+            # Handle visible items in the plot item
+            self.items = self.plot_item.visible_items()
+        else:  # Non PlotBase case
+            # Handle all items
             self.items = self.plot_item.items
 
         # Create or update markers

bec_widgets/utils/forms_from_types/items.py

@@ -4,7 +4,17 @@ import typing
 from abc import abstractmethod
 from decimal import Decimal
 from types import GenericAlias, UnionType
-from typing import Callable, Final, Iterable, Literal, NamedTuple, OrderedDict, get_args
+from typing import (
+    Callable,
+    Final,
+    Generic,
+    Iterable,
+    Literal,
+    NamedTuple,
+    OrderedDict,
+    TypeVar,
+    get_args,
+)
 
 from bec_lib.logger import bec_logger
 from bec_qthemes import material_icon
@@ -350,11 +360,13 @@ class DictFormItem(DynamicFormItem):
         self._main_widget.replace_data(value)
 
 
-class _ItemAndWidgetType(NamedTuple):
-    # TODO: this should be generic but not supported in 3.10
-    item: type[int | float | str]
+_IW = TypeVar("_IW", bound=int | float | str)
+
+
+class _ItemAndWidgetType(NamedTuple, Generic[_IW]):
+    item: type[_IW]
     widget: type[QWidget]
-    default: int | float | str
+    default: _IW
 
 
 class ListFormItem(DynamicFormItem):

bec_widgets/utils/rpc_server.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import functools
+import time
 import traceback
 import types
 from contextlib import contextmanager
@@ -229,6 +230,8 @@ class RPCServer:
         if wait:
             while not self.rpc_register.object_is_registered(connector):
                 QApplication.processEvents()
+                logger.info(f"Waiting for {connector} to be registered...")
+                time.sleep(0.1)
 
         widget_class = getattr(connector, "rpc_widget_class", None)
         if not widget_class:

bec_widgets/utils/serialization.py

@@ -1,44 +1,25 @@
+from bec_lib.codecs import BECCodec
 from bec_lib.serialization import msgpack
 from qtpy.QtCore import QPointF
 
 
+class QPointFEncoder(BECCodec):
+    obj_type = QPointF
+
+    @staticmethod
+    def encode(obj: QPointF) -> list[float]:
+        """Encode a QPointF object to a list of floats."""
+        return [obj.x(), obj.y()]
+
+    @staticmethod
+    def decode(type_name: str, data: list[float]) -> list[float]:
+        """No-op function since QPointF is encoded as a list of floats."""
+        return data
+
+
 def register_serializer_extension():
     """
     Register the serializer extension for the BECConnector.
     """
-    if not module_is_registered("bec_widgets.utils.serialization"):
-        msgpack.register_object_hook(encode_qpointf, decode_qpointf)
-
-
-def module_is_registered(module_name: str) -> bool:
-    """
-    Check if the module is registered in the encoder.
-
-    Args:
-        module_name (str): The name of the module to check.
-
-    Returns:
-        bool: True if the module is registered, False otherwise.
-    """
-    # pylint: disable=protected-access
-    for enc in msgpack._encoder:
-        if enc[0].__module__ == module_name:
-            return True
-    return False
-
-
-def encode_qpointf(obj):
-    """
-    Encode a QPointF object to a list of floats. As this is mostly used for sending
-    data to the client, it is not necessary to convert it back to a QPointF object.
-    """
-    if isinstance(obj, QPointF):
-        return [obj.x(), obj.y()]
-    return obj
-
-
-def decode_qpointf(obj):
-    """
-    no-op function since QPointF is encoded as a list of floats.
-    """
-    return obj
+    if not msgpack.is_registered(QPointF):
+        msgpack.register(QPointF, QPointFEncoder.encode, QPointFEncoder.decode)

bec_widgets/widgets/control/device_control/positioner_box/_base/positioner_box_base.py

@@ -88,7 +88,7 @@ class PositionerBoxBase(BECWidget, CompactPopupWidget):
         if not self._check_device_is_valid(device):
             return
 
-        data = self.dev[device].read()
+        data = self.dev[device].read(cached=True)
         self._on_device_readback(
             device,
             self._device_ui_components(device),

bec_widgets/widgets/control/device_control/positioner_box/positioner_box_2d/positioner_box_2d.py

@@ -34,7 +34,15 @@ class PositionerBox2D(PositionerBoxBase):
 
     PLUGIN = True
     RPC = True
-    USER_ACCESS = ["set_positioner_hor", "set_positioner_ver", "screenshot"]
+    USER_ACCESS = [
+        "set_positioner_hor",
+        "set_positioner_ver",
+        "screenshot",
+        "enable_controls_hor",
+        "enable_controls_hor.setter",
+        "enable_controls_ver",
+        "enable_controls_ver.setter",
+    ]
 
     device_changed_hor = Signal(str, str)
     device_changed_ver = Signal(str, str)
@@ -63,6 +71,8 @@ class PositionerBox2D(PositionerBoxBase):
         self._limits_hor = None
         self._limits_ver = None
         self._dialog = None
+        self._enable_controls_hor = True
+        self._enable_controls_ver = True
         if self.current_path == "":
             self.current_path = os.path.dirname(__file__)
         self.init_ui()
@@ -281,6 +291,7 @@ class PositionerBox2D(PositionerBoxBase):
             self.on_device_readback_hor,
             self._device_ui_components_hv("horizontal"),
         )
+        self._apply_controls_enabled("horizontal")
 
     @SafeSlot(str, str)
     def on_device_change_ver(self, old_device: str, new_device: str):
@@ -300,6 +311,7 @@ class PositionerBox2D(PositionerBoxBase):
             self.on_device_readback_ver,
             self._device_ui_components_hv("vertical"),
         )
+        self._apply_controls_enabled("vertical")
 
     def _device_ui_components_hv(self, device: DeviceId) -> DeviceUpdateUIComponents:
         if device == "horizontal":
@@ -337,6 +349,25 @@ class PositionerBox2D(PositionerBoxBase):
         if device == self.device_ver:
             return self._device_ui_components_hv("vertical")
 
+    def _apply_controls_enabled(self, axis: DeviceId):
+        state = self._enable_controls_hor if axis == "horizontal" else self._enable_controls_ver
+        if axis == "horizontal":
+            widgets = [
+                self.ui.tweak_increase_hor,
+                self.ui.tweak_decrease_hor,
+                self.ui.step_increase_hor,
+                self.ui.step_decrease_hor,
+            ]
+        else:
+            widgets = [
+                self.ui.tweak_increase_ver,
+                self.ui.tweak_decrease_ver,
+                self.ui.step_increase_ver,
+                self.ui.step_decrease_ver,
+            ]
+        for w in widgets:
+            w.setEnabled(state)
+
     @SafeSlot(dict, dict)
     def on_device_readback_hor(self, msg_content: dict, metadata: dict):
         """Callback for device readback.
@@ -417,6 +448,26 @@ class PositionerBox2D(PositionerBoxBase):
         """Step size for tweak"""
         self.ui.step_size_ver.setValue(val)
 
+    @SafeProperty(bool)
+    def enable_controls_hor(self) -> bool:
+        """Persisted switch for horizontal control buttons (tweak/step)."""
+        return self._enable_controls_hor
+
+    @enable_controls_hor.setter
+    def enable_controls_hor(self, value: bool):
+        self._enable_controls_hor = value
+        self._apply_controls_enabled("horizontal")
+
+    @SafeProperty(bool)
+    def enable_controls_ver(self) -> bool:
+        """Persisted switch for vertical control buttons (tweak/step)."""
+        return self._enable_controls_ver
+
+    @enable_controls_ver.setter
+    def enable_controls_ver(self, value: bool):
+        self._enable_controls_ver = value
+        self._apply_controls_enabled("vertical")
+
     @SafeSlot()
     def on_tweak_inc_hor(self):
         """Tweak device a up"""

bec_widgets/widgets/plots/image/image.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import Literal
+from typing import Literal, Sequence
 
 import numpy as np
 from bec_lib import bec_logger
@@ -307,7 +307,7 @@ class Image(ImageBase):
         Set the image source and update the image.
 
         Args:
-            monitor(str): The name of the monitor to use for the image.
+            monitor(str|tuple|None): The name of the monitor to use for the image, or a tuple of (device, signal) for preview signals. If None or empty string, the current monitor will be disconnected.
             monitor_type(str): The type of monitor to use. Options are "1d", "2d", or "auto".
             color_map(str): The color map to use for the image.
             color_bar(str): The type of color bar to use. Options are "simple" or "full".
@@ -322,10 +322,13 @@ class Image(ImageBase):
         if monitor is None or monitor == "":
             logger.warning(f"No monitor specified, cannot set image, old monitor is unsubscribed")
             return None
-        if isinstance(monitor, tuple):
+
+        if isinstance(monitor, str):
+            self.entry_validator.validate_monitor(monitor)
+        elif isinstance(monitor, Sequence):
             self.entry_validator.validate_monitor(monitor[0])
         else:
-            self.entry_validator.validate_monitor(monitor)
+            raise ValueError(f"Invalid monitor type: {type(monitor)}")
 
         self.set_image_update(monitor=monitor, type=monitor_type)
         if color_map is not None:
@@ -347,7 +350,7 @@ class Image(ImageBase):
         if config.monitor is not None:
             for combo in (self.device_combo_box, self.dim_combo_box):
                 combo.blockSignals(True)
-            if isinstance(config.monitor, tuple):
+            if isinstance(config.monitor, (list, tuple)):
                 self.device_combo_box.setCurrentText(f"{config.monitor[0]}_{config.monitor[1]}")
             else:
                 self.device_combo_box.setCurrentText(config.monitor)
@@ -452,7 +455,7 @@ class Image(ImageBase):
         """
 
         # TODO consider moving connecting and disconnecting logic to Image itself if multiple images
-        if isinstance(monitor, tuple):
+        if isinstance(monitor, (list, tuple)):
             device = self.dev[monitor[0]]
             signal = monitor[1]
             if len(monitor) == 3:
@@ -520,7 +523,7 @@ class Image(ImageBase):
         Args:
             monitor(str|tuple): The name of the monitor to disconnect, or a tuple of (device, signal) for preview signals.
         """
-        if isinstance(monitor, tuple):
+        if isinstance(monitor, (list, tuple)):
             if self.subscriptions["main"].source == "device_monitor_1d":
                 self.bec_dispatcher.disconnect_slot(
                     self.on_image_update_1d, MessageEndpoints.device_preview(monitor[0], monitor[1])

bec_widgets/widgets/plots/image/setting_widgets/image_roi_tree.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import math
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 from bec_lib import bec_logger
 from bec_qthemes import material_icon
@@ -73,11 +73,16 @@ class ROIPropertyTree(BECWidget, QWidget):
     - Children: type, line-width (spin box), coordinates (auto-updating).
 
     Args:
+        parent (QWidget, optional): Parent widget. Defaults to None.
         image_widget (Image): The main Image widget that displays the ImageItem.
             Provides ``plot_item`` and owns an ROIController already.
         controller (ROIController, optional): Optionally pass an external controller.
             If None, the manager uses ``image_widget.roi_controller``.
-        parent (QWidget, optional): Parent widget. Defaults to None.
+        compact (bool, optional): If True, use a compact mode with no tree view,
+            only a toolbar with draw actions. Defaults to False.
+        compact_orientation (str, optional): Orientation of the toolbar in compact mode.
+            Either "vertical" or "horizontal". Defaults to "vertical".
+        compact_color (str, optional): Color of the single active ROI in compact mode.
     """
 
     PLUGIN = False
@@ -92,11 +97,18 @@ class ROIPropertyTree(BECWidget, QWidget):
         parent: QWidget = None,
         image_widget: Image,
         controller: ROIController | None = None,
+        compact: bool = False,
+        compact_orientation: Literal["vertical", "horizontal"] = "vertical",
+        compact_color: str = "#f0f0f0",
     ):
 
         super().__init__(
             parent=parent, config=ConnectionConfig(widget_class=self.__class__.__name__)
         )
+        self.compact = compact
+        self.compact_orient = compact_orientation
+        self.compact_color = compact_color
+        self.single_active_roi: BaseROI | None = None
 
         if controller is None:
             # Use the controller already belonging to the Image widget
@@ -112,22 +124,29 @@ class ROIPropertyTree(BECWidget, QWidget):
 
         self.layout = QVBoxLayout(self)
         self._init_toolbar()
-        self._init_tree()
+        if not self.compact:
+            self._init_tree()
+        else:
+            self.tree = None
 
         # connect controller
         self.controller.roiAdded.connect(self._on_roi_added)
         self.controller.roiRemoved.connect(self._on_roi_removed)
-        self.controller.cleared.connect(self.tree.clear)
+        if not self.compact:
+            self.controller.cleared.connect(self.tree.clear)
 
         # initial load
         for r in self.controller.rois:
             self._on_roi_added(r)
 
-        self.tree.collapseAll()
+        if not self.compact:
+            self.tree.collapseAll()
 
     # --------------------------------------------------------------------- UI
     def _init_toolbar(self):
-        tb = self.toolbar = ModularToolBar(self, orientation="horizontal")
+        tb = self.toolbar = ModularToolBar(
+            self, orientation=self.compact_orient if self.compact else "horizontal"
+        )
         self._draw_actions: dict[str, MaterialIconAction] = {}
         # --- ROI draw actions (toggleable) ---
 
@@ -157,6 +176,29 @@ class ROIPropertyTree(BECWidget, QWidget):
         for mode, act in self._draw_actions.items():
             act.action.toggled.connect(lambda on, m=mode: self._on_draw_action_toggled(m, on))
 
+        if self.compact:
+            tb.components.add_safe(
+                "compact_delete",
+                MaterialIconAction("delete", "Delete Current Roi", checkable=False, parent=self),
+            )
+            bundle.add_action("compact_delete")
+            tb.components.get_action("compact_delete").action.triggered.connect(
+                lambda _: (
+                    self.controller.remove_roi(self.single_active_roi)
+                    if self.single_active_roi is not None
+                    else None
+                )
+            )
+            tb.show_bundles(["roi_draw"])
+            self.layout.addWidget(tb)
+
+            # ROI drawing state (needed even in compact mode)
+            self._roi_draw_mode = None
+            self._roi_start_pos = None
+            self._temp_roi = None
+            self.plot.scene().installEventFilter(self)
+            return
+
         # Expand/Collapse toggle
         self.expand_toggle = MaterialIconAction(
             "unfold_more", "Expand/Collapse", checkable=True, parent=self  # icon when collapsed
@@ -327,13 +369,21 @@ class ROIPropertyTree(BECWidget, QWidget):
             self._set_roi_draw_mode(None)
             # register via controller
             self.controller.add_roi(final_roi)
+            if self.compact:
+                final_roi.line_color = self.compact_color
             return True
         return super().eventFilter(obj, event)
 
     # --------------------------------------------------------- controller slots
     def _on_roi_added(self, roi: BaseROI):
+        if self.compact:
+            roi.line_color = self.compact_color
+            if self.single_active_roi is not None and self.single_active_roi is not roi:
+                self.controller.remove_roi(self.single_active_roi)
+            self.single_active_roi = roi
+            return
         # check the global setting from the toolbar
-        if self.lock_all_action.action.isChecked():
+        if hasattr(self, "lock_all_action") and self.lock_all_action.action.isChecked():
             roi.movable = False
         # parent row with blank action column, name in ROI column
         parent = QTreeWidgetItem(self.tree, ["", "", ""])
@@ -424,6 +474,10 @@ class ROIPropertyTree(BECWidget, QWidget):
         roi.movable = not roi.movable
 
     def _on_roi_removed(self, roi: BaseROI):
+        if self.compact:
+            if self.single_active_roi is roi:
+                self.single_active_roi = None
+            return
         item = self.roi_items.pop(roi, None)
         if item:
             idx = self.tree.indexOfTopLevelItem(item)
@@ -449,8 +503,9 @@ class ROIPropertyTree(BECWidget, QWidget):
         self.controller.remove_roi(roi)
 
     def cleanup(self):
-        self.cmap.close()
-        self.cmap.deleteLater()
+        if hasattr(self, "cmap"):
+            self.cmap.close()
+            self.cmap.deleteLater()
         if self.controller and hasattr(self.controller, "rois"):
             for roi in self.controller.rois:  # disconnect all signals from ROIs
                 try:
@@ -491,8 +546,8 @@ if __name__ == "__main__":  # pragma: no cover
     # Add the image widget on the left
     ml.addWidget(image_widget)
 
-    # ROI manager linked to that image
-    mgr = ROIPropertyTree(parent=image_widget, image_widget=image_widget)
+    # ROI manager linked to that image with compact mode
+    mgr = ROIPropertyTree(parent=image_widget, image_widget=image_widget, compact=True)
     mgr.setFixedWidth(350)
     ml.addWidget(mgr)
 

bec_widgets/widgets/plots/motor_map/motor_map.py

@@ -765,7 +765,7 @@ class MotorMap(PlotBase):
             float: Motor initial position.
         """
         entry = self.entry_validator.validate_signal(name, None)
-        init_position = round(float(self.dev[name].read()[entry]["value"]), precision)
+        init_position = round(float(self.dev[name].read(cached=True)[entry]["value"]), precision)
         return init_position
 
     def _sync_motor_map_selection_toolbar(self):

bec_widgets/widgets/plots/plot_base.py

@@ -109,6 +109,7 @@ class PlotBase(BECWidget, QWidget):
         self.plot_widget.ci.setContentsMargins(0, 0, 0, 0)
         self.plot_item = pg.PlotItem(viewBox=BECViewBox(enableMenu=True))
         self.plot_widget.addItem(self.plot_item)
+        self.plot_item.visible_items = lambda: self.visible_items
         self.side_panel = SidePanel(self, orientation="left", panel_max_width=280)
 
         # PlotItem Addons
@@ -893,15 +894,20 @@ class PlotBase(BECWidget, QWidget):
             return
         self._apply_autorange_only_visible_curves()
 
-    def _fetch_visible_curves(self):
-        """
-        Fetch all visible curves from the plot item.
-        """
-        visible_curves = []
-        for curve in self.plot_item.curves:
-            if curve.isVisible():
-                visible_curves.append(curve)
-        return visible_curves
+    @property
+    def visible_items(self):
+        crosshair_items = []
+        if self.crosshair:
+            crosshair_items = [
+                self.crosshair.v_line,
+                self.crosshair.h_line,
+                self.crosshair.coord_label,
+            ]
+        return [
+            item
+            for item in self.plot_item.items
+            if item.isVisible() and item not in crosshair_items
+        ]
 
     def _apply_autorange_only_visible_curves(self):
         """
@@ -910,8 +916,9 @@ class PlotBase(BECWidget, QWidget):
         Args:
             curves (list): List of curves to apply autorange to.
         """
-        visible_curves = self._fetch_visible_curves()
-        self.plot_item.autoRange(items=visible_curves if visible_curves else None)
+        visible_items = self.visible_items
+
+        self.plot_item.autoRange(items=visible_items if visible_items else None)
 
     @SafeProperty(int, doc="The font size of the legend font.")
     def legend_label_size(self) -> int:

bec_widgets/widgets/plots/roi/image_roi.py

@@ -174,6 +174,8 @@ class BaseROI(BECConnector):
         self.remove_scale_handles()  # remove any existing handles from pyqtgraph.RectROI
         if movable:
             self.add_scale_handle()  # add custom scale handles
+        if hasattr(self, "sigRemoveRequested"):
+            self.sigRemoveRequested.connect(self.remove)
 
     def set_parent(self, parent: Image):
         """
@@ -556,8 +558,8 @@ class RectangularROI(BaseROI, pg.RectROI):
 
     def get_coordinates(self, typed: bool | None = None) -> dict | tuple:
         """
-        Returns the coordinates of a rectangle's corners. Supports returning them
-        as either a dictionary with descriptive keys or a tuple of coordinates.
+        Returns the coordinates of a rectangle's corners, rectangle center and dimensions.
+        Supports returning them as either a dictionary with descriptive keys or a tuple of coordinates.
 
         Args:
             typed (bool | None): If True, returns coordinates as a dictionary with
@@ -565,13 +567,17 @@ class RectangularROI(BaseROI, pg.RectROI):
                 the value of `self.description`.
 
         Returns:
-            dict | tuple: The rectangle's corner coordinates, where the format
+            dict | tuple: The rectangle's corner coordinates, rectangle center and dimensions, where the format
                 depends on the `typed` parameter.
         """
         if typed is None:
             typed = self.description
 
         x_left, y_bottom, x_right, y_top = self._normalized_edges()
+        width = x_right - x_left
+        height = y_top - y_bottom
+        cx = x_left + width / 2
+        cy = y_bottom + height / 2
 
         if typed:
             return {
@@ -579,8 +585,19 @@ class RectangularROI(BaseROI, pg.RectROI):
                 "bottom_right": (x_right, y_bottom),
                 "top_left": (x_left, y_top),
                 "top_right": (x_right, y_top),
+                "center_x": cx,
+                "center_y": cy,
+                "width": width,
+                "height": height,
             }
-        return (x_left, y_bottom), (x_right, y_bottom), (x_left, y_top), (x_right, y_top)
+        return (
+            (x_left, y_bottom),
+            (x_right, y_bottom),
+            (x_left, y_top),
+            (x_right, y_top),
+            (cx, cy),
+            (width, height),
+        )
 
     def _lookup_scene_image(self):
         """

bec_widgets/widgets/plots/waveform/curve.py

@@ -42,10 +42,15 @@ class CurveConfig(ConnectionConfig):
     pen_style: Literal["solid", "dash", "dot", "dashdot"] | None = Field(
         "solid", description="The style of the pen of the curve."
     )
-    source: Literal["device", "dap", "custom"] = Field(
+    source: Literal["device", "dap", "custom", "history"] = Field(
         "custom", description="The source of the curve."
     )
     signal: DeviceSignal | None = Field(None, description="The signal of the curve.")
+    scan_id: str | None = Field(None, description="Scan ID to be used when `source` is 'history'.")
+    scan_number: int | None = Field(
+        None, description="Scan index to be used when `source` is 'history'."
+    )
+    current_x_mode: str | None = Field(None, description="The current x mode of the history curve.")
     parent_label: str | None = Field(
         None, description="The label of the parent plot, only relevant for dap curves."
     )
@@ -199,7 +204,7 @@ class Curve(BECConnector, pg.PlotDataItem):
         Raises:
             ValueError: If the source is not custom.
         """
-        if self.config.source == "custom":
+        if self.config.source in ["custom", "history"]:
             self.setData(x, y)
         else:
             raise ValueError(f"Source {self.config.source} do not allow custom data setting.")

bec_widgets/widgets/plots/waveform/settings/curve_settings/curve_tree.py

@@ -5,7 +5,34 @@ from typing import TYPE_CHECKING
 
 from bec_lib.logger import bec_logger
 from bec_qthemes._icon.material_icons import material_icon
-from qtpy.QtCore import Qt
+from qtpy.QtGui import QValidator
+
+
+class ScanIndexValidator(QValidator):
+    """Validator to allow only 'live' or integer scan numbers from an allowed set."""
+
+    def __init__(self, allowed_scans: set[int] | None = None, parent=None):
+        super().__init__(parent)
+        self.allowed_scans = allowed_scans or set()
+
+    def validate(self, input_str: str, pos: int):
+        # Accept empty or 'live'
+        if input_str == "" or input_str == "live":
+            return QValidator.State.Acceptable, input_str, pos
+        # Allow partial editing of "live"
+        if "live".startswith(input_str):
+            return QValidator.State.Intermediate, input_str, pos
+        # Accept integer only if present in the allowed set
+        if input_str.isdigit():
+            try:
+                num = int(input_str)
+            except ValueError:
+                return QValidator.State.Invalid, input_str, pos
+            if num in self.allowed_scans:
+                return QValidator.State.Acceptable, input_str, pos
+        return QValidator.State.Invalid, input_str, pos
+
+
 from qtpy.QtWidgets import (
     QComboBox,
     QHBoxLayout,
@@ -91,8 +118,60 @@ class CurveRow(QTreeWidgetItem):
         # Create columns 1..2, depending on source
         self._init_source_ui()
         # Create columns 3..6 (color, style, width, symbol)
+        self._init_scan_index_ui()
         self._init_style_controls()
 
+    def _init_scan_index_ui(self):
+        """Create the Scan # editable combobox in column 3."""
+        if self.source not in ("device", "history"):
+            return
+        self.scan_index_combo = QComboBox()
+        self.scan_index_combo.setEditable(True)
+        # Populate 'live' and all available history scan indices
+        self.scan_index_combo.addItem("live", None)
+
+        scan_number_list = []
+        scan_id_list = []
+        try:
+            history = getattr(self.curve_tree.client, "history", None)
+            if history is not None:
+                scan_number_list = getattr(history, "_scan_numbers", []) or []
+                scan_id_list = getattr(history, "_scan_ids", []) or []
+        except Exception as e:
+            logger.error(f"Cannot fetch scan numbers from BEC client: {e}")
+            # If scan numbers cannot be fetched, only provide 'live' option
+            scan_number_list = []
+            scan_id_list = []
+
+        # Restrict input to 'live' or valid scan numbers
+        allowed = set()
+        try:
+            allowed = set(int(n) for n in scan_number_list if isinstance(n, (int, str)))
+        except Exception:
+            allowed = set()
+        validator = ScanIndexValidator(allowed, self.scan_index_combo)
+        self.scan_index_combo.lineEdit().setValidator(validator)
+
+        # Add items: show scan numbers, store scan IDs as item data
+        if scan_number_list and scan_id_list and len(scan_number_list) == len(scan_id_list):
+            for num, sid in zip(scan_number_list, scan_id_list):
+                self.scan_index_combo.addItem(str(num), sid)
+        else:
+            logger.error("Scan number and ID lists are mismatched or empty.")
+
+        # Select current based on existing config
+        selected = False
+        if getattr(self.config, "scan_id", None):  # scan_id matching only
+            for i in range(self.scan_index_combo.count()):
+                if self.scan_index_combo.itemData(i) == self.config.scan_id:
+                    self.scan_index_combo.setCurrentIndex(i)
+                    selected = True
+                    break
+        if not selected:
+            self.scan_index_combo.setCurrentText("live")
+
+        self.tree.setItemWidget(self, 3, self.scan_index_combo)
+
     def _init_actions(self):
         """Create the actions widget in column 0, including a delete button and maybe 'Add DAP'."""
         self.actions_widget = QWidget()
@@ -114,7 +193,7 @@ class CurveRow(QTreeWidgetItem):
         actions_layout.addWidget(self.delete_button)
 
         # If device row, add "Add DAP" button
-        if self.source == "device":
+        if self.source in ("device", "history"):
             self.add_dap_button = QPushButton("DAP")
             self.add_dap_button.clicked.connect(lambda: self.add_dap_row())
             actions_layout.addWidget(self.add_dap_button)
@@ -123,7 +202,7 @@ class CurveRow(QTreeWidgetItem):
 
     def _init_source_ui(self):
         """Create columns 1 and 2. For device rows, we have device/entry edits; for dap rows, label/model combo."""
-        if self.source == "device":
+        if self.source in ("device", "history"):
             # Device row: columns 1..2 are device line edits
             self.device_edit = DeviceComboBox(parent=self.tree)
             self.device_edit.insertItem(0, "")
@@ -152,7 +231,6 @@ class CurveRow(QTreeWidgetItem):
 
             self.tree.setItemWidget(self, 1, self.device_edit)
             self.tree.setItemWidget(self, 2, self.entry_edit)
-
         else:
             # DAP row: column1= "Model" label, column2= DapComboBox
             self.label_widget = QLabel("Model")
@@ -171,31 +249,31 @@ class CurveRow(QTreeWidgetItem):
             self.tree.setItemWidget(self, 2, self.dap_combo)
 
     def _init_style_controls(self):
-        """Create columns 3..6: color button, style combo, width spin, symbol spin."""
-        # Color in col 3
+        """Create columns 4..7: color button, style combo, width spin, symbol spin."""
+        # Color in col 4
         self.color_button = ColorButtonNative(color=self.config.color)
         self.color_button.color_changed.connect(self._on_color_changed)
-        self.tree.setItemWidget(self, 3, self.color_button)
+        self.tree.setItemWidget(self, 4, self.color_button)
 
-        # Style in col 4
+        # Style in col 5
         self.style_combo = QComboBox()
         self.style_combo.addItems(["solid", "dash", "dot", "dashdot"])
         idx = self.style_combo.findText(self.config.pen_style)
         if idx >= 0:
             self.style_combo.setCurrentIndex(idx)
-        self.tree.setItemWidget(self, 4, self.style_combo)
+        self.tree.setItemWidget(self, 5, self.style_combo)
 
-        # Pen width in col 5
+        # Pen width in col 6
         self.width_spin = QSpinBox()
         self.width_spin.setRange(1, 20)
         self.width_spin.setValue(self.config.pen_width)
-        self.tree.setItemWidget(self, 5, self.width_spin)
+        self.tree.setItemWidget(self, 6, self.width_spin)
 
-        # Symbol size in col 6
+        # Symbol size in col 7
         self.symbol_spin = QSpinBox()
         self.symbol_spin.setRange(1, 20)
         self.symbol_spin.setValue(self.config.symbol_size)
-        self.tree.setItemWidget(self, 6, self.symbol_spin)
+        self.tree.setItemWidget(self, 7, self.symbol_spin)
 
     @SafeSlot(str, verify_sender=True)
     def _on_color_changed(self, new_color: str):
@@ -209,8 +287,8 @@ class CurveRow(QTreeWidgetItem):
         self.config.symbol_color = new_color
 
     def add_dap_row(self):
-        """Create a new DAP row as a child. Only valid if source='device'."""
-        if self.source != "device":
+        """Create a new DAP row as a child. Only valid if source is 'device' or 'history'."""
+        if self.source not in ("device", "history"):
             return
         curve_tree = self.tree.parent()
         parent_label = self.config.label
@@ -288,7 +366,7 @@ class CurveRow(QTreeWidgetItem):
         Returns:
             dict: The serialized config based on the GUI state.
         """
-        if self.source == "device":
+        if self.source in ("device", "history"):
             # Gather device name/entry
             device_name = ""
             device_entry = ""
@@ -309,8 +387,23 @@ class CurveRow(QTreeWidgetItem):
                     )
 
             self.config.signal = DeviceSignal(name=device_name, entry=device_entry)
-            self.config.source = "device"
-            self.config.label = f"{device_name}-{device_entry}"
+            scan_combo_text = self.scan_index_combo.currentText()
+            if scan_combo_text == "live" or scan_combo_text == "":
+                self.config.scan_number = None
+                self.config.scan_id = None
+                self.config.source = "device"
+                self.config.label = f"{device_name}-{device_entry}"
+            if scan_combo_text.isdigit():
+                try:
+                    scan_num = int(scan_combo_text)
+                except ValueError:
+                    scan_num = None
+                self.config.scan_number = scan_num
+                self.config.scan_id = self.scan_index_combo.currentData()
+                self.config.source = "history"
+                # Label history curves with scan number suffix
+                if scan_num is not None:
+                    self.config.label = f"{device_name}-{device_entry}-scan-{scan_num}"
         else:
             # DAP logic
             parent_conf_dict = {}
@@ -443,10 +536,12 @@ class CurveTree(BECWidget, QWidget):
         self.toolbar.show_bundles(["curve_tree"])
 
     def _init_tree(self):
-        """Initialize the QTreeWidget with 7 columns and compact widths."""
+        """Initialize the QTreeWidget with 8 columns and compact widths."""
         self.tree = QTreeWidget()
-        self.tree.setColumnCount(7)
-        self.tree.setHeaderLabels(["Actions", "Name", "Entry", "Color", "Style", "Width", "Symbol"])
+        self.tree.setColumnCount(8)
+        self.tree.setHeaderLabels(
+            ["Actions", "Name", "Entry", "Scan #", "Color", "Style", "Width", "Symbol"]
+        )
 
         header = self.tree.header()
         for idx in range(self.tree.columnCount()):
@@ -456,10 +551,10 @@ class CurveTree(BECWidget, QWidget):
                 header.setSectionResizeMode(idx, QHeaderView.Fixed)
         header.setStretchLastSection(False)
         self.tree.setColumnWidth(0, 90)
-        self.tree.setColumnWidth(3, 70)
-        self.tree.setColumnWidth(4, 80)
-        self.tree.setColumnWidth(5, 50)
+        self.tree.setColumnWidth(4, 70)
+        self.tree.setColumnWidth(5, 80)
         self.tree.setColumnWidth(6, 50)
+        self.tree.setColumnWidth(7, 50)
 
         self.layout.addWidget(self.tree)
 
@@ -583,9 +678,9 @@ class CurveTree(BECWidget, QWidget):
         self.tree.clear()
         self.all_items = []
 
-        device_curves = [c for c in self.waveform.curves if c.config.source == "device"]
+        top_curves = [c for c in self.waveform.curves if c.config.source in ("device", "history")]
         dap_curves = [c for c in self.waveform.curves if c.config.source == "dap"]
-        for dev in device_curves:
+        for dev in top_curves:
             dr = CurveRow(self.tree, parent_item=None, config=dev.config, device_manager=self.dev)
             for dap in dap_curves:
                 if dap.config.parent_label == dev.config.label:

bec_widgets/widgets/plots/waveform/waveform.py

@@ -8,6 +8,7 @@ import numpy as np
 import pyqtgraph as pg
 from bec_lib import bec_logger, messages
 from bec_lib.endpoints import MessageEndpoints
+from bec_lib.scan_data_container import ScanDataContainer
 from pydantic import Field, ValidationError, field_validator
 from qtpy.QtCore import Qt, QTimer, Signal
 from qtpy.QtWidgets import (
@@ -35,6 +36,9 @@ from bec_widgets.widgets.plots.plot_base import PlotBase
 from bec_widgets.widgets.plots.waveform.curve import Curve, CurveConfig, DeviceSignal
 from bec_widgets.widgets.plots.waveform.settings.curve_settings.curve_setting import CurveSetting
 from bec_widgets.widgets.plots.waveform.utils.roi_manager import WaveformROIManager
+from bec_widgets.widgets.services.scan_history_browser.scan_history_browser import (
+    ScanHistoryBrowser,
+)
 
 logger = bec_logger.logger
 
@@ -163,6 +167,7 @@ class Waveform(PlotBase):
         # Curve data
         self._sync_curves = []
         self._async_curves = []
+        self._history_curves = []
         self._slice_index = None
         self._dap_curves = []
         self._mode = None
@@ -179,12 +184,14 @@ class Waveform(PlotBase):
             "readout_priority": None,
             "label_suffix": "",
         }
+        self._current_x_device: tuple[str, str] | None = None
 
         # Specific GUI elements
         self._init_roi_manager()
         self.dap_summary = None
         self.dap_summary_dialog = None
-        self._add_fit_parameters_popup()
+        self.scan_history_dialog = None
+        self._add_waveform_specific_popup()
         self._enable_roi_toolbar_action(False)  # default state where are no dap curves
         self._init_curve_dialog()
         self.curve_settings_dialog = None
@@ -252,7 +259,7 @@ class Waveform(PlotBase):
         super().add_side_menus()
         self._add_dap_summary_side_menu()
 
-    def _add_fit_parameters_popup(self):
+    def _add_waveform_specific_popup(self):
         """
         Add popups to the Waveform widget.
         """
@@ -262,11 +269,24 @@ class Waveform(PlotBase):
                 icon_name="monitoring", tooltip="Open Fit Parameters", checkable=True, parent=self
             ),
         )
+        self.toolbar.components.add_safe(
+            "scan_history",
+            MaterialIconAction(
+                icon_name="manage_search",
+                tooltip="Open Scan History browser",
+                checkable=True,
+                parent=self,
+            ),
+        )
         self.toolbar.get_bundle("axis_popup").add_action("fit_params")
+        self.toolbar.get_bundle("axis_popup").add_action("scan_history")
 
         self.toolbar.components.get_action("fit_params").action.triggered.connect(
             self.show_dap_summary_popup
         )
+        self.toolbar.components.get_action("scan_history").action.triggered.connect(
+            self.show_scan_history_popup
+        )
 
     @SafeSlot()
     def _reset_view(self):
@@ -414,6 +434,47 @@ class Waveform(PlotBase):
             self.toolbar.components.get_action("roi_linear").action.setChecked(False)
             self._roi_manager.toggle_roi(False)
 
+    ################################################################################
+    # Scan History browser popup
+    # TODO this is so far quick implementation just as popup, we should make scan history also standalone widget later
+    def show_scan_history_popup(self):
+        """
+        Show the scan history popup.
+        """
+        scan_history_action = self.toolbar.components.get_action("scan_history").action
+        if self.scan_history_dialog is None or not self.scan_history_dialog.isVisible():
+            self.scan_history_widget = ScanHistoryBrowser(parent=self)
+            self.scan_history_dialog = QDialog(modal=False)
+            self.scan_history_dialog.setWindowTitle(f"{self.object_name} - Scan History Browser")
+            self.scan_history_dialog.layout = QVBoxLayout(self.scan_history_dialog)
+            self.scan_history_dialog.layout.addWidget(self.scan_history_widget)
+            self.scan_history_widget.scan_history_device_viewer.request_history_plot.connect(
+                lambda scan_id, device_name, signal_name: self.plot(
+                    y_name=device_name, y_entry=signal_name, scan_id=scan_id
+                )
+            )
+            self.scan_history_dialog.finished.connect(self._scan_history_closed)
+            self.scan_history_dialog.show()
+            self.scan_history_dialog.resize(780, 320)
+            scan_history_action.setChecked(True)
+        else:
+            # If already open, bring it to the front
+            self.scan_history_dialog.raise_()
+            self.scan_history_dialog.activateWindow()
+            scan_history_action.setChecked(True)  # keep it toggle
+
+    def _scan_history_closed(self):
+        """
+        Slot for when the scan history dialog is closed.
+        """
+        if self.scan_history_dialog is None:
+            return
+        self.scan_history_widget.close()
+        self.scan_history_widget.deleteLater()
+        self.scan_history_dialog.deleteLater()
+        self.scan_history_dialog = None
+        self.toolbar.components.get_action("scan_history").action.setChecked(False)
+
     ################################################################################
     # Dap Summary
 
@@ -503,7 +564,11 @@ class Waveform(PlotBase):
         self.x_axis_mode["name"] = value
         if value not in ["timestamp", "index", "auto"]:
             self.x_axis_mode["entry"] = self.entry_validator.validate_signal(value, None)
+            self._current_x_device = (value, self.x_axis_mode["entry"])
         self._switch_x_axis_item(mode=value)
+        self._current_x_device = None
+        self._refresh_history_curves()
+        self._update_curve_visibility()
         self.async_signal_update.emit()
         self.sync_signal_update.emit()
         self.plot_item.enableAutoRange(x=True)
@@ -531,6 +596,8 @@ class Waveform(PlotBase):
             return
         self.x_axis_mode["entry"] = self.entry_validator.validate_signal(self.x_mode, value)
         self._switch_x_axis_item(mode="device")
+        self._refresh_history_curves()
+        self._update_curve_visibility()
         self.async_signal_update.emit()
         self.sync_signal_update.emit()
         self.plot_item.enableAutoRange(x=True)
@@ -671,6 +738,8 @@ class Waveform(PlotBase):
         color: str | None = None,
         label: str | None = None,
         dap: str | None = None,
+        scan_id: str | None = None,
+        scan_number: int | None = None,
         **kwargs,
     ) -> Curve:
         """
@@ -693,6 +762,10 @@ class Waveform(PlotBase):
             dap(str): The dap model to use for the curve, only available for sync devices.
             If not specified, none will be added.
             Use the same string as is the name of the LMFit model.
+            scan_id(str):  Optional scan ID. When provided, the curve is treated as a **history** curve and
+                the y‑data (and optional x‑data) are fetched from that historical scan. Such curves are
+                never cleared by live‑scan resets.
+            scan_number(int): Optional scan index. When provided, the curve is treated as a **history** curve and
 
         Returns:
             Curve: The curve object.
@@ -762,6 +835,8 @@ class Waveform(PlotBase):
             label=label,
             color=color,
             source=source,
+            scan_id=scan_id,
+            scan_number=scan_number,
             **kwargs,
         )
 
@@ -769,6 +844,9 @@ class Waveform(PlotBase):
         if source == "device":
             config.signal = DeviceSignal(name=y_name, entry=y_entry)
 
+        if scan_id is not None or scan_number is not None:
+            config.source = "history"
+
         # CREATE THE CURVE
         curve = self._add_curve(config=config, x_data=x_data, y_data=y_data)
 
@@ -807,7 +885,7 @@ class Waveform(PlotBase):
         device_curve = self._find_curve_by_label(device_label)
         if not device_curve:
             raise ValueError(f"No existing curve found with label '{device_label}'.")
-        if device_curve.config.source != "device":
+        if device_curve.config.source not in ("device", "history"):
             raise ValueError(
                 f"Curve '{device_label}' is not a device curve. Only device curves can have DAP."
             )
@@ -816,7 +894,7 @@ class Waveform(PlotBase):
         dev_entry = device_curve.config.signal.entry
 
         # 2) Build a label for the new DAP curve
-        dap_label = f"{dev_name}-{dev_entry}-{dap_name}"
+        dap_label = f"{device_label}-{dap_name}"
 
         # 3) Possibly raise if the DAP curve already exists
         if self._check_curve_id(dap_label):
@@ -869,7 +947,23 @@ class Waveform(PlotBase):
             ValueError: If a duplicate curve label/config is found, or if
                         custom data is missing for `source='custom'`.
         """
+        scan_item: ScanDataContainer | None = None
+        if config.source == "history":
+            scan_item = self.get_history_scan_item(
+                scan_id=config.scan_id, scan_index=config.scan_number
+            )
+            if scan_item is None:
+                raise ValueError(
+                    f"Could not find scan item for history curve '{config.label}' with scan_id='{config.scan_id}' and scan_number='{config.scan_number}'."
+                )
+
+            config.scan_id = scan_item.metadata["bec"]["scan_id"]
+            config.scan_number = scan_item.metadata["bec"]["scan_number"]
+
         label = config.label
+        if config.source == "history":
+            label = f"{config.signal.name}-{config.signal.entry}-scan-{config.scan_number}"
+            config.label = label
         if not label:
             # Fallback label
             label = WidgetContainerUtils.generate_unique_name(
@@ -891,7 +985,7 @@ class Waveform(PlotBase):
                 raise ValueError("For 'custom' curves, x_data and y_data must be provided.")
 
         # Actually create the Curve item
-        curve = self._add_curve_object(name=label, config=config)
+        curve = self._add_curve_object(name=label, config=config, scan_item=scan_item)
 
         # If custom => set initial data
         if config.source == "custom" and x_data is not None and y_data is not None:
@@ -908,6 +1002,8 @@ class Waveform(PlotBase):
             self.setup_dap_for_scan()
             self.roi_enable.emit(True)  # Enable the ROI toolbar action
             self.request_dap()  # Request DAP update directly without blocking proxy
+        if config.source == "history":
+            self._history_curves.append(curve)
 
         QTimer.singleShot(
             150, self.auto_range
@@ -915,22 +1011,182 @@ class Waveform(PlotBase):
 
         return curve
 
-    def _add_curve_object(self, name: str, config: CurveConfig) -> Curve:
+    def _add_curve_object(
+        self, name: str, config: CurveConfig, scan_item: ScanDataContainer | None = None
+    ) -> Curve | None:
         """
         Low-level creation of the PlotDataItem (Curve) from a `CurveConfig`.
 
         Args:
             name (str): The name/label of the curve.
             config (CurveConfig): Configuration model describing the curve.
+            scan_item (ScanDataContainer | None): Optional scan item for history curves.
 
         Returns:
             Curve: The newly created curve object, added to the plot.
         """
         curve = Curve(config=config, name=name, parent_item=self)
         self.plot_item.addItem(curve)
+        if scan_item is not None:
+            self._fetch_history_data_for_curve(curve, scan_item)
         self._categorise_device_curves()
+        curve.visibleChanged.connect(self._refresh_crosshair_markers)
+        curve.visibleChanged.connect(self.auto_range)
         return curve
 
+    def _fetch_history_data_for_curve(
+        self, curve: Curve, scan_item: ScanDataContainer
+    ) -> Curve | None:
+        # Check if the data are already set
+        device = curve.config.signal.name
+        entry = curve.config.signal.entry
+
+        all_devices_used = getattr(
+            getattr(scan_item, "_msg", None), "stored_data_info", None
+        ) or getattr(scan_item, "stored_data_info", None)
+        if all_devices_used is None:
+            curve.remove()
+            raise ValueError(
+                f"No stored data info found in scan item ID:{curve.config.scan_id} for curve '{curve.name()}'. "
+                f"Upgrade BEC to the latest version."
+            )
+
+        # 1. get y data
+        x_data, y_data = None, None
+        if device not in all_devices_used:
+            raise ValueError(f"Device '{device}' not found in scan item ID:{curve.config.scan_id}.")
+        if entry not in all_devices_used[device]:
+            raise ValueError(
+                f"Entry '{entry}' not found in device '{device}' in scan item ID:{curve.config.scan_id}."
+            )
+        y_shape = all_devices_used.get(device).get(entry).shape[0]
+
+        # Determine X-axis data
+        if self.x_axis_mode["name"] == "index":
+            x_data = np.arange(y_shape)
+            curve.config.current_x_mode = "index"
+            self._update_x_label_suffix(" (index)")
+        elif self.x_axis_mode["name"] == "timestamp":
+            y_device = scan_item.devices.get(device)
+            x_data = y_device.get(entry).read().get("timestamp")
+            curve.config.current_x_mode = "timestamp"
+            self._update_x_label_suffix(" (timestamp)")
+        elif self.x_axis_mode["name"] not in ("index", "timestamp", "auto"):  # Custom device mode
+            if self.x_axis_mode["name"] not in all_devices_used:
+                logger.warning(
+                    f"Custom device '{self.x_axis_mode['name']}' not found in scan item of history curve '{curve.name()}'; scan ID: {curve.config.scan_id}."
+                )
+                curve.setVisible(False)
+                return
+            x_entry_custom = self.x_axis_mode.get("entry")
+            if x_entry_custom is None:
+                x_entry_custom = self.entry_validator.validate_signal(
+                    self.x_axis_mode["name"], None
+                )
+            if x_entry_custom not in all_devices_used[self.x_axis_mode["name"]]:
+                logger.warning(
+                    f"Custom entry '{x_entry_custom}' for device '{self.x_axis_mode['name']}' not found in scan item of history curve '{curve.name()}'; scan ID: {curve.config.scan_id}."
+                )
+                curve.setVisible(False)
+                return
+            x_shape = (
+                scan_item._msg.stored_data_info.get(self.x_axis_mode["name"])
+                .get(x_entry_custom)
+                .shape[0]
+            )
+            if x_shape != y_shape:
+                logger.warning(
+                    f"Shape mismatch for x data '{x_shape}' and y data '{y_shape}' in history curve '{curve.name()}'; scan ID: {curve.config.scan_id}."
+                )
+                curve.setVisible(False)
+                return
+            x_device = scan_item.devices.get(self.x_axis_mode["name"])
+            x_data = x_device.get(x_entry_custom).read().get("value")
+            curve.config.current_x_mode = self.x_axis_mode["name"]
+            self._update_x_label_suffix(f" (custom: {self.x_axis_mode['name']}-{x_entry_custom})")
+        elif self.x_axis_mode["name"] == "auto":
+            if (
+                self._current_x_device is None
+            ):  # Scenario where no x device is set yet, because there was no live scan done in this widget yet
+                # If no current x device, use the first motor from scan item
+                scan_motors = self._ensure_str_list(
+                    scan_item.metadata.get("bec").get("scan_report_devices")
+                )
+                if not scan_motors:  # scan was done without reported motor from whatever reason
+                    x_data = np.arange(y_shape)  # Fallback to index
+                    y_data = scan_item.devices.get(device).get(entry).read().get("value")
+                    curve.set_data(x=x_data, y=y_data)
+                    self._update_x_label_suffix(" (auto: index)")
+                    return curve
+                x_entry = self.entry_validator.validate_signal(scan_motors[0], None)
+                if x_entry not in all_devices_used.get(scan_motors[0], {}):
+                    logger.warning(
+                        f"Auto x entry '{x_entry}' for device '{scan_motors[0]}' not found in scan item of history curve '{curve.name()}'; scan ID: {curve.config.scan_id}."
+                    )
+                    curve.setVisible(False)
+                    return
+                if y_shape != all_devices_used.get(scan_motors[0]).get(x_entry, {}).shape[0]:
+                    logger.warning(
+                        f"Shape mismatch for x data '{all_devices_used.get(scan_motors[0]).get(x_entry, {}).get('shape', [0])[0]}' and y data '{y_shape}' in history curve '{curve.name()}'; scan ID: {curve.config.scan_id}."
+                    )
+                    curve.setVisible(False)
+                    return
+                x_data = scan_item.devices.get(scan_motors[0]).get(x_entry).read().get("value")
+                self._current_x_device = (scan_motors[0], x_entry)
+                self._update_x_label_suffix(f" (auto: {scan_motors[0]}-{x_entry})")
+                curve.config.current_x_mode = "auto"
+                self._update_x_label_suffix(f" (auto: {scan_motors[0]}-{x_entry})")
+            else:  # Scan in auto mode was done and live scan already set the current x device
+                if self._current_x_device[0] not in all_devices_used:
+                    logger.warning(
+                        f"Auto x data for device '{self._current_x_device[0]}' "
+                        f"and entry '{self._current_x_device[1]}'"
+                        f" not found in scan item of the history curve {curve.name()}."
+                    )
+                    curve.setVisible(False)
+                    return
+                x_device = scan_item.devices.get(self._current_x_device[0])
+                x_data = x_device.get(self._current_x_device[1]).read().get("value")
+                curve.config.current_x_mode = "auto"
+                self._update_x_label_suffix(
+                    f" (auto: {self._current_x_device[0]}-{self._current_x_device[1]})"
+                )
+        if x_data is None:
+            logger.warning(
+                f"X data for curve '{curve.name()}' could not be determined. "
+                f"Check if the x_mode '{self.x_axis_mode['name']}' is valid for the scan item."
+            )
+            curve.setVisible(False)
+            return
+        if y_data is None:
+            y_data = scan_item.devices.get(device).get(entry).read().get("value")
+            if y_data is None:
+                logger.warning(
+                    f"Y data for curve '{curve.name()}' could not be determined. "
+                    f"Check if the device '{device}' and entry '{entry}' are valid for the scan item."
+                )
+                curve.setVisible(False)
+                return
+        curve.set_data(x=x_data, y=y_data)
+        return curve
+
+    def _refresh_history_curves(self):
+        for curve in self._history_curves:
+            scan_item = self.get_history_scan_item(
+                scan_id=curve.config.scan_id, scan_index=curve.config.scan_number
+            )
+            if scan_item is not None:
+                self._fetch_history_data_for_curve(curve, scan_item)
+            else:
+                logger.warning(f"Scan item for curve {curve.name()} not found.")
+
+    def _refresh_crosshair_markers(self):
+        """
+        Refresh the crosshair markers when a curve visibility changes.
+        """
+        if self.crosshair is not None:
+            self.crosshair.clear_markers()
+
     def _generate_color_from_palette(self) -> str:
         """
         Generate a color for the next new curve, based on the current number of curves.
@@ -958,7 +1214,42 @@ class Waveform(PlotBase):
         Clear all data from the plot widget, but keep the curve references.
         """
         for c in self.curves:
-            c.clear_data()
+            if c.config.source != "history":
+                c.clear_data()
+
+    # X-axis compatibility helpers
+    def _is_curve_compatible(self, curve: Curve) -> bool:
+        """
+        Return True when *curve* can be shown with the current x-axis mode.
+
+        - ‘index’, ‘timestamp’ are always compatible.
+        - For history curves we check whether the requested motor
+          (self.x_axis_mode["name"]) exists in the cached
+          history_data_buffer["x"] dictionary.
+        - DAP is done by checking if the parent curve is visible.
+        - Device curves are fetched by update sync/async curves, which solves the compatibility there.
+        """
+        mode = self.x_axis_mode.get("name", "index")
+        if mode in ("index", "timestamp"):  # always compatible - wild west mode
+            return True
+        if curve.config.source == "history":
+            scan_item = self.get_history_scan_item(
+                scan_id=curve.config.scan_id, scan_index=curve.config.scan_number
+            )
+            curve = self._fetch_history_data_for_curve(curve, scan_item)
+            if curve is None:
+                return False
+        if curve.config.source == "dap":
+            parent_curve = self._find_curve_by_label(curve.config.parent_label)
+            if parent_curve.isVisible():
+                return True
+            return False  # DAP curve is not compatible if parent curve is not visible
+        return True
+
+    def _update_curve_visibility(self) -> None:
+        """Show or hide curves according to `_is_curve_compatible`."""
+        for c in self.curves:
+            c.setVisible(self._is_curve_compatible(c))
 
     def clear_all(self):
         """
@@ -1115,12 +1406,13 @@ class Waveform(PlotBase):
             self.reset()
             self.new_scan.emit()
             self.new_scan_id.emit(current_scan_id)
-            self.auto_range(True)
+            self.auto_range_x = True
+            self.auto_range_y = True
             self.old_scan_id = self.scan_id
             self.scan_id = current_scan_id
             self.scan_item = self.queue.scan_storage.find_scan_by_ID(self.scan_id)  # live scan
             self._slice_index = None  # Reset the slice index
-
+            self._update_curve_visibility()
             self._mode = self._categorise_device_curves()
 
             # First trigger to sync and async data
@@ -1198,7 +1490,7 @@ class Waveform(PlotBase):
                 device_data = entry_obj.read()["value"] if entry_obj else None
             x_data = self._get_x_data(device_name, device_entry)
             if x_data is not None:
-                if len(x_data) == 1:
+                if np.isscalar(x_data):
                     self.clear_data()
                     return
             if device_data is not None and x_data is not None:
@@ -1606,6 +1898,7 @@ class Waveform(PlotBase):
                 entry_obj = data.get(x_name, {}).get(x_entry)
                 x_data = entry_obj.read()["value"] if entry_obj else [0]
             new_suffix = f" (custom: {x_name}-{x_entry})"
+            self._current_x_device = (x_name, x_entry)
 
         # 2 User wants timestamp
         if self.x_axis_mode["name"] == "timestamp":
@@ -1620,11 +1913,13 @@ class Waveform(PlotBase):
                 timestamps = entry_obj.read()["timestamp"] if entry_obj else [0]
             x_data = timestamps
             new_suffix = " (timestamp)"
+            self._current_x_device = None
 
         # 3 User wants index
         if self.x_axis_mode["name"] == "index":
             x_data = None
             new_suffix = " (index)"
+            self._current_x_device = None
 
         # 4 Best effort automatic mode
         if self.x_axis_mode["name"] is None or self.x_axis_mode["name"] == "auto":
@@ -1632,6 +1927,7 @@ class Waveform(PlotBase):
             if len(self._async_curves) > 0:
                 x_data = None
                 new_suffix = " (auto: index)"
+                self._current_x_device = None
             # 4.2 If there are sync curves, use the first device from the scan report
             else:
                 try:
@@ -1654,6 +1950,7 @@ class Waveform(PlotBase):
                         entry_obj = data.get(x_name, {}).get(x_entry)
                         x_data = entry_obj.read()["value"] if entry_obj else None
                     new_suffix = f" (auto: {x_name}-{x_entry})"
+                self._current_x_device = (x_name, x_entry)
         self._update_x_label_suffix(new_suffix)
         return x_data
 
@@ -1756,49 +2053,83 @@ class Waveform(PlotBase):
         logger.info(f"Scan {self.scan_id} => mode={self._mode}")
         return mode
 
-    @SafeSlot(int)
-    @SafeSlot(str)
-    @SafeSlot()
-    def update_with_scan_history(self, scan_index: int = None, scan_id: str = None):
+    def get_history_scan_item(
+        self, scan_index: int = None, scan_id: str = None
+    ) -> ScanDataContainer | None:
         """
-        Update the scan curves with the data from the scan storage.
-        Provide only one of scan_id or scan_index.
+        Get scan item from history based on scan_id or scan_index.
+        If both are provided, scan_id takes precedence and the resolved scan_number
+        will be read from the fetched item.
 
         Args:
-            scan_id(str, optional): ScanID of the scan to be updated. Defaults to None.
-            scan_index(int, optional): Index of the scan to be updated. Defaults to None.
+            scan_id (str, optional): ScanID of the scan to fetch. Defaults to None.
+            scan_index (int, optional): Index (scan number) of the scan to fetch. Defaults to None.
+
+        Returns:
+            ScanDataContainer | None: The fetched scan item or None if no item was found.
         """
         if scan_index is not None and scan_id is not None:
-            raise ValueError("Only one of scan_id or scan_index can be provided.")
+            scan_index = None  # Prefer scan_id when both are given
 
         if scan_index is None and scan_id is None:
-            logger.warning(f"Neither scan_id or scan_number was provided, fetching the latest scan")
+            logger.warning("Neither scan_id or scan_number was provided, fetching the latest scan")
             scan_index = -1
 
         if scan_index is None:
-            self.scan_id = scan_id
-            self.scan_item = self.client.history.get_by_scan_id(scan_id)
-            self._emit_signal_update()
-            return
+            return self.client.history.get_by_scan_id(scan_id)
 
         if scan_index == -1:
             scan_item = self.client.queue.scan_storage.current_scan
             if scan_item is not None:
                 if scan_item.status_message is None:
                     logger.warning(f"Scan item with {scan_item.scan_id} has no status message.")
-                    return
-                self.scan_item = scan_item
-                self.scan_id = scan_item.scan_id
-                self._emit_signal_update()
-                return
+                    return None
+                return scan_item
 
         if len(self.client.history) == 0:
-            logger.info("No scans executed so far. Skipping scan history update.")
+            logger.info("No scans executed so far. Cannot fetch scan history.")
+            return None
+
+        # check if scan_index is negative, then fetch it just from the list from the end
+        if int(scan_index) < 0:
+            return self.client.history[scan_index]
+        scan_item = self.client.history.get_by_scan_number(scan_index)
+        if scan_item is None:
+            logger.warning(f"Scan with scan_number {scan_index} not found in history.")
+            return None
+        if isinstance(scan_item, list):
+            if len(scan_item) > 1:
+                logger.warning(
+                    f"Multiple scans found with scan_number {scan_index}. Returning the latest one."
+                )
+            scan_item = scan_item[-1]
+        return scan_item
+
+    @SafeSlot(int)
+    @SafeSlot(str)
+    @SafeSlot()
+    def update_with_scan_history(self, scan_index: int = None, scan_id: str = None):
+        """
+        Update the scan curves with the data from the scan storage.
+        If both arguments are provided, scan_id takes precedence and scan_index is ignored.
+
+        Args:
+            scan_id(str, optional): ScanID of the scan to be updated. Defaults to None.
+            scan_index(int, optional): Index (scan number) of the scan to be updated. Defaults to None.
+        """
+        self.scan_item = self.get_history_scan_item(scan_index=scan_index, scan_id=scan_id)
+
+        if self.scan_item is None:
             return
 
-        self.scan_item = self.client.history[scan_index]
-        metadata = self.scan_item.metadata
-        self.scan_id = metadata["bec"]["scan_id"]
+        if scan_id is not None:
+            self.scan_id = scan_id
+        else:
+            # If scan_number was used, set the scan_id from the fetched item
+            if hasattr(self.scan_item, "metadata"):
+                self.scan_id = self.scan_item.metadata["bec"]["scan_id"]
+            else:
+                self.scan_id = self.scan_item.scan_id
 
         self._emit_signal_update()
 
@@ -2029,6 +2360,9 @@ class Waveform(PlotBase):
         if self.dap_summary_dialog is not None:
             self.dap_summary_dialog.reject()
             self.dap_summary_dialog = None
+        if self.scan_history_dialog is not None:
+            self.scan_history_dialog.reject()
+            self.scan_history_dialog = None
         super().cleanup()
 
 

bec_widgets/widgets/progress/ring_progress_bar/ring.py

@@ -12,8 +12,8 @@ from bec_widgets.utils import BECConnector, ConnectionConfig
 
 
 class ProgressbarConnections(BaseModel):
-    slot: Literal["on_scan_progress", "on_device_readback"] = None
-    endpoint: EndpointInfo | str = None
+    slot: Literal["on_scan_progress", "on_device_readback", None] = None
+    endpoint: EndpointInfo | str | None = None
     model_config: dict = {"validate_assignment": True}
 
     @field_validator("endpoint")
@@ -222,9 +222,10 @@ class Ring(BECConnector, QObject):
             device(str): Device name for the device readback mode, only used when mode is "device"
         """
         if mode == "manual":
-            self.bec_dispatcher.disconnect_slot(
-                getattr(self, self.config.connections.slot), self.config.connections.endpoint
-            )
+            if self.config.connections.slot is not None:
+                self.bec_dispatcher.disconnect_slot(
+                    getattr(self, self.config.connections.slot), self.config.connections.endpoint
+                )
             self.config.connections.slot = None
             self.config.connections.endpoint = None
         elif mode == "scan":

bec_widgets/widgets/progress/ring_progress_bar/ring_progress_bar.py

@@ -22,13 +22,9 @@ class RingProgressBarConfig(ConnectionConfig):
     color_map: Optional[str] = Field(
         "plasma", description="Color scheme for the progress bars.", validate_default=True
     )
-    min_number_of_bars: int | None = Field(
-        1, description="Minimum number of progress bars to display."
-    )
-    max_number_of_bars: int | None = Field(
-        10, description="Maximum number of progress bars to display."
-    )
-    num_bars: int | None = Field(1, description="Number of progress bars to display.")
+    min_number_of_bars: int = Field(1, description="Minimum number of progress bars to display.")
+    max_number_of_bars: int = Field(10, description="Maximum number of progress bars to display.")
+    num_bars: int = Field(1, description="Number of progress bars to display.")
     gap: int | None = Field(20, description="Gap between progress bars.")
     auto_updates: bool | None = Field(
         True, description="Enable or disable updates based on scan queue status."
@@ -242,7 +238,7 @@ class RingProgressBar(BECWidget, QWidget):
         for i, ring in enumerate(self._rings):
             ring.config.index = i
 
-    def set_precision(self, precision: int, bar_index: int = None):
+    def set_precision(self, precision: int, bar_index: int | None = None):
         """
         Set the precision for the progress bars. If bar_index is not provide, the precision will be set for all progress bars.
 
@@ -271,9 +267,9 @@ class RingProgressBar(BECWidget, QWidget):
             min_values(int|float | list[float]): Minimum value(s) for the progress bars. If multiple progress bars are displayed, provide a list of minimum values for each progress bar.
             max_values(int|float | list[float]): Maximum value(s) for the progress bars. If multiple progress bars are displayed, provide a list of maximum values for each progress bar.
         """
-        if isinstance(min_values, int) or isinstance(min_values, float):
+        if isinstance(min_values, (int, float)):
             min_values = [min_values]
-        if isinstance(max_values, int) or isinstance(max_values, float):
+        if isinstance(max_values, (int, float)):
             max_values = [max_values]
         min_values = self._adjust_list_to_bars(min_values)
         max_values = self._adjust_list_to_bars(max_values)
@@ -441,14 +437,10 @@ class RingProgressBar(BECWidget, QWidget):
         Returns:
             Ring: Ring object.
         """
-        found_ring = None
         for ring in self._rings:
             if ring.config.index == index:
-                found_ring = ring
-                break
-        if found_ring is None:
-            raise ValueError(f"Ring with index {index} not found.")
-        return found_ring
+                return ring
+        raise ValueError(f"Ring with index {index} not found.")
 
     def enable_auto_updates(self, enable: bool = True):
         """
@@ -485,29 +477,30 @@ class RingProgressBar(BECWidget, QWidget):
         primary_queue = msg.get("queue").get("primary")
         info = primary_queue.get("info", None)
 
-        if info:
-            active_request_block = info[0].get("active_request_block", None)
-            if active_request_block:
-                report_instructions = active_request_block.get("report_instructions", None)
-                if report_instructions:
-                    instruction_type = list(report_instructions[0].keys())[0]
-                    if instruction_type == "scan_progress":
-                        self._hook_scan_progress(ring_index=0)
-                    elif instruction_type == "readback":
-                        devices = report_instructions[0].get("readback").get("devices")
-                        start = report_instructions[0].get("readback").get("start")
-                        end = report_instructions[0].get("readback").get("end")
-                        if self.config.num_bars != len(devices):
-                            self.set_number_of_bars(len(devices))
-                        for index, device in enumerate(devices):
-                            self._hook_readback(index, device, start[index], end[index])
-                    else:
-                        logger.error(f"{instruction_type} not supported yet.")
+        if not info:
+            return
+        active_request_block = info[0].get("active_request_block", None)
+        if not active_request_block:
+            return
+        report_instructions = active_request_block.get("report_instructions", None)
+        if not report_instructions:
+            return
 
-                    # elif instruction_type == "device_progress":
-                    #     print("hook device_progress")
+        instruction_type = list(report_instructions[0].keys())[0]
+        if instruction_type == "scan_progress":
+            self._hook_scan_progress(ring_index=0)
+        elif instruction_type == "readback":
+            devices = report_instructions[0].get("readback").get("devices")
+            start = report_instructions[0].get("readback").get("start")
+            end = report_instructions[0].get("readback").get("end")
+            if self.config.num_bars != len(devices):
+                self.set_number_of_bars(len(devices))
+            for index, device in enumerate(devices):
+                self._hook_readback(index, device, start[index], end[index])
+        else:
+            logger.error(f"{instruction_type} not supported yet.")
 
-    def _hook_scan_progress(self, ring_index: int = None):
+    def _hook_scan_progress(self, ring_index: int | None = None):
         """
         Hook the scan progress to the progress bars.
 
@@ -521,8 +514,7 @@ class RingProgressBar(BECWidget, QWidget):
 
         if ring.config.connections.slot == "on_scan_progress":
             return
-        else:
-            ring.set_connections("on_scan_progress", MessageEndpoints.scan_progress())
+        ring.set_connections("on_scan_progress", MessageEndpoints.scan_progress())
 
     def _hook_readback(self, bar_index: int, device: str, min: float | int, max: float | int):
         """
@@ -576,6 +568,8 @@ class RingProgressBar(BECWidget, QWidget):
         return bar_index
 
     def paintEvent(self, event):
+        if not self._rings:
+            return
         painter = QtGui.QPainter(self)
         painter.setRenderHint(QtGui.QPainter.Antialiasing)
         size = min(self.width(), self.height())
@@ -628,9 +622,8 @@ class RingProgressBar(BECWidget, QWidget):
             return QSize(10, 10)
         ring_widths = [self.config.rings[i].line_width for i in range(self.config.num_bars)]
         total_width = sum(ring_widths) + self.config.gap * (self.config.num_bars - 1)
-        diameter = total_width * 2
-        if diameter < 50:
-            diameter = 50
+        diameter = max(total_width * 2, 50)
+
         return QSize(diameter, diameter)
 
     def sizeHint(self):

bec_widgets/widgets/services/device_browser/device_item/device_signal_display.py

@@ -38,8 +38,8 @@ class SignalDisplay(BECWidget, QWidget):
     @SafeSlot()
     def _refresh(self):
         if (dev := self.dev.get(self.device)) is not None:
-            dev.read()
-            dev.read_configuration()
+            dev.read(cached=True)
+            dev.read_configuration(cached=True)
 
     def _add_refresh_button(self):
         button_holder = QWidget()

bec_widgets/widgets/utility/signal_label/signal_label.py

@@ -273,7 +273,9 @@ class SignalLabel(BECWidget, QWidget):
         if not isinstance(self._device_obj, Device | Signal):
             self._value, self._units = "__", ""
             return
-        reading = (self._device_obj.read() or {}) | (self._device_obj.read_configuration() or {})
+        reading = (self._device_obj.read(cached=True) or {}) | (
+            self._device_obj.read_configuration(cached=True) or {}
+        )
         value = reading.get(self._signal_key, {}).get("value")
         if value is None:
             self._value, self._units = "__", ""

docs/api_reference/api_reference.md

@@ -1,12 +1,11 @@
 (api_reference)=
 # API Reference
 
-```{eval-rst}
-.. autosummary::
-   :toctree: _autosummary
-   :template: custom-module-template.rst
-   :recursive:
+This page contains the auto-generated API documentation for all modules, classes, and functions in the BEC Widgets package.
 
-   bec_widgets
+```{toctree}
+:maxdepth: 2
+:caption: API Documentation
 
+../autoapi/bec_widgets/index
 ```

docs/conf.py

@@ -32,16 +32,15 @@ def get_version():
 release = get_version()
 
 extensions = [
-    "sphinx.ext.autodoc",
-    "sphinx.ext.autosummary",
     # "sphinx.ext.coverage",
-    "sphinx.ext.viewcode",
     "sphinx.ext.napoleon",
     "sphinx_toolbox.collapse",
     "sphinx_copybutton",
     "myst_parser",
     "sphinx_design",
     "sphinx_inline_tabs",
+    "autoapi.extension",
+    "sphinx.ext.viewcode",
 ]
 
 myst_enable_extensions = [
@@ -60,7 +59,15 @@ myst_enable_extensions = [
     "tasklist",
 ]
 
-autosummary_generate = True  # Turn on sphinx.ext.autosummary
+# AutoAPI configuration
+autoapi_dirs = ["../bec_widgets"]
+autoapi_type = "python"
+autoapi_generate_api_docs = True
+autoapi_add_toctree_entry = False  # We'll control the toctree manually
+autoapi_keep_files = False
+autoapi_python_class_content = "both"  # Include both class docstring and __init__
+autoapi_member_order = "groupwise"
+
 add_module_names = False  # Remove namespaces from class/method signatures
 autodoc_inherit_docstrings = True  # If no docstring, inherit from base class
 set_type_checking_flag = True  # Enable 'expensive' imports for sphinx_autodoc_typehints
@@ -80,3 +87,30 @@ html_theme = "pydata_sphinx_theme"
 html_static_path = ["_static"]
 html_css_files = ["custom.css"]
 html_logo = "../bec_widgets/assets/app_icons/bec_widgets_icon.png"
+
+
+def skip_submodules(app, what, name, obj, skip, options):
+    if what == "module":
+        if not name.startswith("bec_widgets"):
+            skip = True
+        # print(f"Checking module: {name}")
+        if "bec_widgets.widgets" in name:
+            widget = name.split(".")[-2]
+            submodule = name.split(".")[-1]
+            if submodule in [f"register_{widget}", f"{widget}_plugin"]:
+                # print(f"Skipping submodule: {name}")
+                skip = True
+    elif what in ["data", "attribute"]:
+        obj_name = name.split(".")[-1]
+        if obj_name.startswith("_") or obj_name in ["__all__", "logger", "bec_logger", "app"]:
+            skip = True
+
+    elif what == "class":
+        class_name = name.split(".")[-1]
+        if class_name.startswith("Demo"):
+            skip = True
+    return skip
+
+
+def setup(app):
+    app.connect("autoapi-skip-member", skip_submodules)

docs/developer/introduction/concepts.md

@@ -10,5 +10,5 @@ We offer up to three different options for composing larger GUIs from these modu
 ## Client-Server Architecture
 
 BEC Widgets is built on top of the [BEC](https://bec.readthedocs.io/en/latest/) package, which provides the backend for beamline experiment control. BEC Widgets is a client of BEC, meaning it can interact with the backend through a client-server architecture. To make full usage of the available features of BEC, we recommend to check the documentation about [data access](https://bec.readthedocs.io/en/latest/developer/data_access/data_access.html) in which the messaging and event system of BEC is described.
-In the context of BEC Widgets, the [`BECDispatcher`](/api_reference/_autosummary/bec_widgets.utils.bec_dispatcher.BECDispatcher) connects to this messaging and event system, allowing you to link your Qt [`Slots`](https://www.pythonguis.com/tutorials/pyside6-signals-slots-events/) to messages and event received from BEC.
+In the context of BEC Widgets, the {py:class}`~bec_widgets.utils.bec_dispatcher.BECDispatcher` connects to this messaging and event system, allowing you to link your Qt [`Slots`](https://www.pythonguis.com/tutorials/pyside6-signals-slots-events/) to messages and event received from BEC.
 

docs/developer/introduction/contributing.md

@@ -8,7 +8,7 @@ Therefore, we recommend that you install BEC first following the [developer inst
 If you already have a BEC environment set up, you can install BEC Widgets in editable mode into your BEC Python environment.
 
 **Prerequisites**
-1. **Python Version:** BEC Widgets requires Python version 3.10 or higher. Verify your Python version to ensure compatibility.
+1. **Python Version:** BEC Widgets requires Python version 3.11 or higher. Verify your Python version to ensure compatibility.
 2. **BEC Installation:** BEC Widgets works in conjunction with BEC. While BEC is a dependency and will be installed automatically, you can find more information about BEC and its installation process in the [BEC documentation](https://beamline-experiment-control.readthedocs.io/en/latest/).
 3. **Qt Distributions:** BEC Widgets supports [PySide6](https://doc.qt.io/qtforpython-6/quickstart.html) and [PyQt6](https://www.riverbankcomputing.com/static/Docs/PyQt6/introduction.html). We use [qtpy](https://pypi.org/project/QtPy/) to abstract the underlying QT distribution.
 

docs/requirements.txt

@@ -7,4 +7,5 @@ sphinx-copybutton
 sphinx-inline-tabs
 myst-parser
 sphinx-design
+sphinx-autoapi
 tomli

docs/user/api_reference/api_reference.md

@@ -1,11 +1,10 @@
 (user.api_reference)=
 # User API Reference
 
-```{eval-rst}
-.. autosummary::
-   :toctree: _autosummary
-   :template: custom-module-template.rst
+This section contains the API documentation for the main user-facing modules and classes.
 
-    bec_widgets.cli.client
+```{toctree}
+:maxdepth: 2
 
+../../autoapi/bec_widgets/cli/index
 ```

docs/user/getting_started/installation.md

@@ -4,7 +4,7 @@
 
 Before installing BEC Widgets, please ensure the following requirements are met:
 
-1. **Python Version:** BEC Widgets requires Python version 3.10 or higher. Verify your Python version to ensure compatibility.
+1. **Python Version:** BEC Widgets requires Python version 3.11 or higher. Verify your Python version to ensure compatibility.
 2. **BEC Installation:** BEC Widgets works in conjunction with BEC. While BEC is a dependency and will be installed automatically, you can find more information about BEC and its installation process in the [BEC documentation](https://beamline-experiment-control.readthedocs.io/en/latest/).
 
 **Standard Installation**

docs/user/getting_started/quick_start.md

@@ -3,9 +3,9 @@
 In order to use BEC Widgets as a plotting tool for BEC, it needs to be [installed](#user.installation) in the same Python environment as the BEC IPython client (please refer to the [BEC documentation](https://bec.readthedocs.io/en/latest/user/command_line_interface.html#start-up) for more details). Upon startup, the client will automatically launch a GUI and store it as a `gui` object in the client. The GUI backend will also be automatically connect to the BEC server, giving access to all information on the server and allowing the user to visualize the data in real-time.
 
 ## BECGuiClient
-The `gui` object is the main entry point for interacting with the BEC Widgets framework. It is an instance of the [`BECGuiClient`](/api_reference/_autosummary/bec_widgets.cli.client.BECGuiClient) class, which provides methods to create and manage GUI components. Upon BEC startup, a default [`BECDockArea`](/api_reference/_autosummary/bec_widgets.cli.client.BECDockArea) instance named *bec* is automatically launched.
+The `gui` object is the main entry point for interacting with the BEC Widgets framework. It is an instance of the {py:class}`~bec_widgets.cli.client_utils.BECGuiClient` class, which provides methods to create and manage GUI components. Upon BEC startup, a default {py:class}`~bec_widgets.cli.client.BECDockArea` instance named *bec* is automatically launched.
 
-A launcher interface is available via the top menu bar under New → Open Launcher. This opens a window where users can launch a new [`BECDockArea`](/api_reference/_autosummary/bec_widgets.cli.client.BECDockArea) instance, an [AutoUpdate](#user.auto_updates) instance, individual widgets or a custom *ui file* created with *BEC Designer*. Alternatively, users can launch a new [`BECDockArea`](/api_reference/_autosummary/bec_widgets.cli.client.BECDockArea) from the command line:
+A launcher interface is available via the top menu bar under New → Open Launcher. This opens a window where users can launch a new {py:class}`~bec_widgets.cli.client.BECDockArea` instance, an [AutoUpdate](#user.auto_updates) instance, individual widgets or a custom *ui file* created with *BEC Designer*. Alternatively, users can launch a new {py:class}`~bec_widgets.cli.client.BECDockArea` from the command line:
 
 ```python
 dock_area = gui.new() # launches a new BECDockArea instance
@@ -19,7 +19,7 @@ If a name is provided, the new dock area will use that name. If the name already
 
 
 ## BECDockArea
-The [`BECDockArea`](/api_reference/_autosummary/bec_widgets.cli.client.BECDockArea) is a versatile container for quickly building customized GUIs. It supports adding new widgets either through the CLI or directly via toolbar actions. Widgets must be added into [`BECDock`](/api_reference/_autosummary/bec_widgets.cli.client.BECDock) instances, which serve as the individual containers. These docks can be arranged freely, detached from the main window, and used as floating panels.
+The {py:class}`~bec_widgets.cli.client.BECDockArea` is a versatile container for quickly building customized GUIs. It supports adding new widgets either through the CLI or directly via toolbar actions. Widgets must be added into {py:class}`~bec_widgets.cli.client.BECDockArea` instances, which serve as the individual containers. These docks can be arranged freely, detached from the main window, and used as floating panels.
 
 From the CLI, you can create new docks like this:
 
@@ -34,23 +34,23 @@ dock = gui.new().new()
 ![BECDockArea.png](BECDockArea.png) -->
 
 ## Widgets
-Widgets are the building blocks of the BEC Widgets framework. They are the visual components that allow users to interact with the data and control the behavior of the application. Each dock can contain multiple widgets, albeit we recommend for most use cases a single widget per dock. BEC Widgets provides a set of core widgets (cf. [widgets](#user.widgets)). More widgets can be added by the users, and we invite you to explore the [developer documentation](developer.widgets) to learn how to create custom widgets.
+Widgets are the building blocks of the BEC Widgets framework. They are the visual components that allow users to interact with the data and control the behavior of the application. Each dock can contain multiple widgets, albeit we recommend for most use cases a single widget per dock. BEC Widgets provides a set of core widgets (cf. {ref}`user.widgets`). More widgets can be added by the users, and we invite you to explore the {ref}`developer.widgets` to learn how to create custom widgets.
 For the introduction given here, we will focus on the plotting widgets of BECWidgets. 
 
 <!-- We also provide two methods [`plot()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.plot), [`image()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.image) and [`motor_map()`](/api_reference/_autosummary/bec_widgets.cli.client.BECFigure.rst#bec_widgets.cli.client.BECFigure.motor_map) as shortcuts to add a plot, image or motor map to the BECFigure. -->
 
 **Waveform Plot** 
 
- The [`WaveForm`](/api_reference/_autosummary/bec_widgets.cli.client.WaveForm) is a widget that can be used to visualize 1D waveform data, i.e. to plot data of a monitor against a motor position. The method [`plot()`](/api_reference/_autosummary/bec_widgets.cli.client.WaveForm.rst#bec_widgets.cli.client.WaveForm.plot) returns the plot object. 
+ The {py:class}`~bec_widgets.cli.client.Waveform` is a widget that can be used to visualize 1D waveform data, i.e. to plot data of a monitor against a motor position. The method {py:meth}`~bec_widgets.cli.client.Waveform.plot` returns the plot object. 
 
 ```python
 plt = gui.new().new().new(gui.available_widgets.Waveform)
 plt.plot(x_name='samx', y_name='bpm4i')
 ```
-Here, we create a new plot with a subscription to the devices `samx` and `bpm4i` and assign the plot to the object `plt`. We can now use this object to further customize the plot, e.g. changing the title ([`plt.title = 'my title' `](/api_reference/_autosummary/bec_widgets.cli.client.Waveform.rst#bec_widgets.cli.client.Waveform.title)), axis labels ([`plt.x_label = 'my x label'`](/api_reference/_autosummary/bec_widgets.cli.client.Waveform.rst#bec_widgets.cli.client.Waveform.x_label)) 
-<!-- or limits ([`set_x_lim()`](/api_reference/_autosummary/bec_widgets.cli.client.Waveform.rst#bec_widgets.cli.client.Waveform.x_lim)).  -->
+Here, we create a new plot with a subscription to the devices `samx` and `bpm4i` and assign the plot to the object `plt`. We can now use this object to further customize the plot, e.g. changing the title (`title`), axis labels (`x_label`) 
+<!-- or limits (`x_lim`).  -->
 
-We invite you to explore the API of the WaveForm in the [documentation](user.widgets.waveform_1d) or directly in the command line.
+We invite you to explore the API of the WaveForm in the {ref}`user.widgets.waveform_1d` or directly in the command line.
 
 To plot custom data, i.e. data that is not directly available through a scan in BEC, we can use the same method, but provide the data directly to the plot. 
 
@@ -68,18 +68,18 @@ curve = plt.plot(x=[1,2,3,4], y=[1,4,9,16])
 
 **Scatter Plot**
 
-The [`WaveForm`](/api_reference/_autosummary/bec_widgets.cli.client.WaveForm) widget can also be used to visualize 2D scatter plots. More details on setting up the scatter plot are available in the widget documentation of the [scatter plot](user.widgets.scatter_2d).
+The {py:class}`~bec_widgets.cli.client.Waveform` widget can also be used to visualize 2D scatter plots. More details on setting up the scatter plot are available in the widget documentation of the {ref}`user.widgets.scatter_2d`.
 
 **Motor Map**
 
-The [`MotorMap`](/api_reference/_autosummary/bec_widgets.cli.client.MotorMap) widget can be used to visualize the position of motors. It's focused on tracking and visualizing the position of motors, crucial for precise alignment and movement tracking during scans. More details on setting up the motor map are available in the widget documentation of the [motor map](user.widgets.motor_map).
+The {py:class}`~bec_widgets.cli.client.MotorMap` widget can be used to visualize the position of motors. It's focused on tracking and visualizing the position of motors, crucial for precise alignment and movement tracking during scans. More details on setting up the motor map are available in the widget documentation of the {ref}`user.widgets.motor_map`.
 
 **Image Plot**
 
-The [`Image`](/api_reference/_autosummary/bec_widgets.cli.client.Image) widget can be used to visualize 2D image data for example a camera. More details on setting up the image plot are available in the widget documentation of the [image plot](user.widgets.image).
+The {py:class}`~bec_widgets.cli.client.Image` widget can be used to visualize 2D image data for example a camera. More details on setting up the image plot are available in the widget documentation of the {ref}`user.widgets.image`.
 
 ### Useful Commands
-We recommend users to explore the API of the widgets by themselves since we assume that the user interface is supposed to be intuitive and self-explanatory. We appreciate feedback from user in order to constantly improve the experience and allow easy access to the gui, widgets and their functionality. We recommend checking the [API documentation](user.api_reference), but also by using BEC Widgets, exploring the available functions and check their dockstrings.
+We recommend users to explore the API of the widgets by themselves since we assume that the user interface is supposed to be intuitive and self-explanatory. We appreciate feedback from user in order to constantly improve the experience and allow easy access to the gui, widgets and their functionality. We recommend checking the {ref}`user.api_reference`, but also by using BEC Widgets, exploring the available functions and check their dockstrings.
 ```python
 gui.new? # shows the dockstring of the new method
 ```

docs/user/widgets/bec_progressbar/bec_progressbar.md

@@ -3,7 +3,7 @@
 
 ```{tab} Overview
 
-The [`BECProgressbar`](/api_reference/_autosummary/bec_widgets.cli.client.BECProgressBar) widget is a general purpose progress bar that follows the BEC theme and style. It can be embedded in any application to display the progress of a task or operation. 
+The {py:class}`~bec_widgets.cli.client.BECProgressBar` widget is a general purpose progress bar that follows the BEC theme and style. It can be embedded in any application to display the progress of a task or operation.
 
 ## Key Features:
 - **Modern Design**: The BEC Progressbar widget is designed with a modern and sleek appearance, following the BEC theme.
@@ -35,6 +35,8 @@ pb.set_value(50)
 
 ````{tab} API
 ```{eval-rst} 
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.BECProgressBar.rst
+.. autoclass:: bec_widgets.cli.client.BECProgressBar
+   :members:
+   :show-inheritance:
 ```
 ````

docs/user/widgets/bec_status_box/bec_status_box.md

@@ -3,7 +3,7 @@
 
 ````{tab} Overview
 
-The [`BEC Status Box`](/api_reference/_autosummary/bec_widgets.cli.client.BECStatusBox) widget is designed to monitor the status and health of all running BEC processes. This widget provides a real-time overview of the BEC core services, including DeviceServer, ScanServer, SciHub, ScanBundler, and FileWriter. The top-level display indicates the overall state of the BEC services, while the collapsed view allows users to delve into the status of each individual process. By double-clicking on a specific process, users can access a detailed popup window with live updates of the metrics for that process.
+The {py:class}`~bec_widgets.cli.client.BECStatusBox` widget is designed to monitor the status and health of all running BEC processes. This widget provides a real-time overview of the BEC core services, including DeviceServer, ScanServer, SciHub, ScanBundler, and FileWriter. The top-level display indicates the overall state of the BEC services, while the collapsed view allows users to delve into the status of each individual process. By double-clicking on a specific process, users can access a detailed popup window with live updates of the metrics for that process.
 
 ## Key Features:
 - **Comprehensive Service Monitoring**: Track the state of individual BEC services, including real-time updates on their health and status.
@@ -33,6 +33,8 @@ Once the `BECStatusBox` is added, users can interact with it to view the status
 
 ````{tab} API
 ```{eval-rst} 
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.BECStatusBox.rst
+.. autoclass:: bec_widgets.cli.client.BECStatusBox
+   :members:
+   :show-inheritance:
 ```
 ````

docs/user/widgets/buttons_appearance/buttons_appearance.md

@@ -146,8 +146,14 @@ my_gui.show()
 
 ````{tab} API
 ```{eval-rst} 
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.DarkModeButton.rst
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.ColorButton.rst
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.ColormapSelector.rst
+.. autoclass:: bec_widgets.cli.client.DarkModeButton
+   :members:
+   :show-inheritance:
+.. autoclass:: bec_widgets.cli.client.ColorButton
+   :members:
+   :show-inheritance:
+.. autoclass:: bec_widgets.cli.client.ColormapSelector
+   :members:
+   :show-inheritance:
 ```
 ````

docs/user/widgets/buttons_queue/button_queue.md

@@ -39,7 +39,7 @@ The `Reset Button` is used to reset the scan queue. It prompts the user for conf
 - **Toolbar and Button Options**: Can be configured as a toolbar button or a standard push button.
 ```
 
-`````{tab} Examples
+````{tab} Examples
 
 Integrating these buttons into a BEC GUI layout is straightforward. The following examples demonstrate how to embed these buttons within a custom GUI layout using `QtWidgets`.
 
@@ -66,12 +66,21 @@ app.exec_()
 ```
 
 `ResumeButton`, `ResetButton`, and `AbortButton` may be used in an exactly analogous way.
+````
 
 ````{tab} API
 ```{eval-rst}
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.StopButton.rst
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.ResumeButton.rst
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.AbortButton.rst
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.ResetButton.rst
+.. autoclass:: bec_widgets.cli.client.StopButton
+   :members:
+   :show-inheritance:
+.. autoclass:: bec_widgets.cli.client.ResumeButton
+   :members:
+   :show-inheritance:
+.. autoclass:: bec_widgets.cli.client.AbortButton
+   :members:
+   :show-inheritance:
+.. autoclass:: bec_widgets.cli.client.ResetButton
+   :members:
+   :show-inheritance:
 ```
-`````
+````

docs/user/widgets/dap_combo_box/dap_combo_box.md

@@ -4,8 +4,8 @@
 
 ````{tab} Overview
 
-The [`DAPComboBox`](/api_reference/_autosummary/bec_widgets.widgets.dap_combo_box.dap_combo_box.DAPComboBox) is a widget that extends the functionality of a standard `QComboBox` to allow the user to select a DAP process from all available DAP models.
-One of its signals `new_dap_config` is designed to be connected to the [`add_dap(str, str, str)`](/api_reference/_autosummary/bec_widgets.widgets.waveform.waveform_widget.BECWaveformWidget.rst#bec_widgets.widgets.waveform.waveform_widget.BECWaveformWidget.add_dap) slot from the BECWaveformWidget to add a DAP process.
+The {py:class}`~bec_widgets.widgets.dap_combo_box.dap_combo_box.DAPComboBox` is a widget that extends the functionality of a standard `QComboBox` to allow the user to select a DAP process from all available DAP models.
+One of its signals `new_dap_config` is designed to be connected to the {py:class}`~bec_widgets.widgets.plots.waveform.waveform.Waveform.add_dap_curve` slot from the Waveform widget to add a DAP process.
 
 ## Key Features:
 - **Select DAP model**: Select one of the available DAP models.
@@ -30,11 +30,6 @@ The following slots are available for the `DAP ComboBox` widget:
 - `select_y_axis(str)` : Slot to select the current y axis, emits the `x_axis_updated` signal
 - `select_fit_model(str)` : Slot to select the current fit model, emits the `fit_model_updated` signal. If x and y axis are set, it will also emit the `new_dap_config` signal.
 ````
-````{tab} API
-```{eval-rst} 
-.. include:: /api_reference/_autosummary/bec_widgets.widgets.dap_combo_box.dap_combo_box.DAPCombobox.rst
-```
-````
 
 
 

docs/user/widgets/device_browser/device_browser.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The [`Device Browser`](/api_reference/_autosummary/bec_widgets.cli.client.DeviceBrowser) widget provides a user-friendly interface for browsing through all available devices in the current BEC session. As it supports drag functionality, users can easily drag and drop device into other widgets or applications. 
+The {py:class}`~bec_widgets.cli.client.DeviceBrowser` widget provides a user-friendly interface for browsing through all available devices in the current BEC session. As it supports drag functionality, users can easily drag and drop device into other widgets or applications. 
 
 ```{note}
 The `Device Browser` widget is currently under development. Other widgets may not support drag and drop functionality yet.
@@ -34,6 +34,8 @@ dock_area.device_browser.DeviceBrowser
 
 ````{tab} API
 ```{eval-rst} 
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.DeviceBrowser.rst
+.. autoclass:: bec_widgets.cli.client.DeviceBrowser
+   :members:
+   :show-inheritance:
 ```
 ````

docs/user/widgets/device_input/device_input.md

@@ -114,12 +114,16 @@ The following Qt properties are also included:
 
 ````{tab} API - ComboBox
 ```{eval-rst} 
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.DeviceComboBox.rst
+.. autoclass:: bec_widgets.cli.client.DeviceComboBox
+   :members:
+   :show-inheritance:
 ```
 ````
 
 ````{tab} API - LineEdit
 ```{eval-rst}
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.DeviceLineEdit.rst
+.. autoclass:: bec_widgets.cli.client.DeviceLineEdit
+   :members:
+   :show-inheritance:
 ```
 ````

docs/user/widgets/dock_area/bec_dock_area.md

@@ -4,12 +4,12 @@
 
 ````{tab} Overview
 
-[`BECDockArea`](/api_reference/_autosummary/bec_widgets.cli.client.BECDockArea) is a powerful and flexible container designed to host various widgets and docks within a grid layout. It provides an environment for organizing and managing complex user interfaces, making it ideal for applications that require multiple tools and data visualizations to be displayed simultaneously. BECDockArea is particularly useful for embedding not only visualization tools but also other interactive components, allowing users to tailor their workspace to their specific needs.
+`BECDockArea` is a powerful and flexible container designed to host various widgets and docks within a grid layout. It provides an environment for organizing and managing complex user interfaces, making it ideal for applications that require multiple tools and data visualizations to be displayed simultaneously. BECDockArea is particularly useful for embedding not only visualization tools but also other interactive components, allowing users to tailor their workspace to their specific needs.
 
 - **Flexible Dock Management**: Easily add, remove, and rearrange docks within `BECDockArea`, providing a customized layout for different tasks.
 - **State Persistence**: Save and restore the state of the dock area, enabling consistent user experiences across sessions.
 - **Dock Customization**: Add docks with customizable positions, names, and behaviors, such as floating or closable docks.
-- **Integration with Widgets**: Integrate various widgets like [`WaveformWidget`](user.widgets.waveform_widget), [`ImageWidget`](user.widgets.image_widget), and [`MotorMapWidget`](user.widgets.motor_map) into [`BECDockArea`](/api_reference/_autosummary/bec_widgets.cli.client.BECDockArea), either as standalone tools or as part of a more complex interface.
+- **Integration with Widgets**: Integrate various widgets like [`WaveformWidget`](user.widgets.waveform_widget), [`ImageWidget`](user.widgets.image_widget), and [`MotorMapWidget`](user.widgets.motor_map) into `BECDockArea`, either as standalone tools or as part of a more complex interface.
 
 **BEC Dock Area Components Schema**
 
@@ -114,7 +114,9 @@ When removing a dock, all widgets within the dock will be removed as well. This
 
 ````{tab} API
 ```{eval-rst} 
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.BECDockArea.rst
+.. autoclass:: bec_widgets.cli.client.BECDockArea
+   :members:
+   :show-inheritance:
 ```
 ````
 

docs/user/widgets/heatmap/heatmap_widget.md

@@ -101,6 +101,8 @@ heatmap_widget.v_max = 1000
 
 ````{tab} API
 ```{eval-rst}  
-.. include:: /api_reference/_autosummary/bec_widgets.widgets.plots.heatmap.heatmap.Heatmap.rst
+.. autoclass:: bec_widgets.widgets.plots.heatmap.heatmap.Heatmap
+   :members:
+   :show-inheritance:
 ```
 ````

docs/user/widgets/image/image_widget.md

@@ -105,6 +105,8 @@ Since the Image Widget does not have prior information about the shape of incomi
 
 ````{tab} API
 ```{eval-rst}  
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.Image.rst
+.. autoclass:: bec_widgets.cli.client.Image
+   :members:
+   :show-inheritance:
 ```
 ````

docs/user/widgets/lmfit_dialog/lmfit_dialog.md

@@ -4,8 +4,8 @@
 
 ````{tab} Overview
 
-The [`LMFit Dialog`](/api_reference/_autosummary/bec_widgets.widgets.dap.lmfit_dialog.lmfit_dialog.LMFitDialog) is a widget that is developed to be used together with the [`Waveform`](/api_reference/_autosummary/bec_widgets.widgets.plots.waveform.waveform.Waveform) widget. The `Waveform` widget allows user to submit a fit request to BEC's [DAP server](https://bec.readthedocs.io/en/latest/developer/getting_started/architecture.html) choosing from a selection of [LMFit models](https://lmfit.github.io/lmfit-py/builtin_models.html#) to fit monitored data sources. The `LMFit Dialog` provides an interface to monitor these fits, including statistics and fit parameters in real time. 
-Within the `Waveform` widget, the dialog is accessible via the toolbar and will be automatically linked to the current waveform widget. For a more customised use, we can embed the `LMFit Dialog` in a larger GUI using the *BEC Designer*. In this case, one has to connect the [`update_summary_tree`](/api_reference/_autosummary/bec_widgets.widgets.dap.lmfit_dialog.lmfit_dialog.LMFitDialog.rst#bec_widgets.widgets.lmfit_dialog.lmfit_dialog.LMFitDialog.update_summary_tree) slot of the LMFit Dialog to the [`dap_summary_update`](/api_reference/_autosummary/bec_widgets.widgets.plots.waveform.waveform_widget.Waveform.rst#bec_widgets.widgets.plots.waveform.waveform.Waveform.dap_summary_update) signal of the Waveform widget to ensure its functionality. 
+The `LMFitDialog` is a widget that is developed to be used together with the `Waveform` widget. The `Waveform` widget allows user to submit a fit request to BEC's [DAP server](https://bec.readthedocs.io/en/latest/developer/getting_started/architecture.html) choosing from a selection of [LMFit models](https://lmfit.github.io/lmfit-py/builtin_models.html#) to fit monitored data sources. The `LMFit Dialog` provides an interface to monitor these fits, including statistics and fit parameters in real time. 
+Within the `Waveform` widget, the dialog is accessible via the toolbar and will be automatically linked to the current waveform widget. For a more customised use, we can embed the `LMFit Dialog` in a larger GUI using the *BEC Designer*. In this case, one has to connect the `update_summary_tree` slot of the LMFit Dialog to the `dap_summary_update` signal of the Waveform widget to ensure its functionality. 
 
 
 ## Key Features:
@@ -34,11 +34,7 @@ waveform.dap_summary_update.connect(lmfit_dialog.update_summary_tree)
 
 ```
 ````
-````{tab} API
-```{eval-rst} 
-.. include:: /api_reference/_autosummary/bec_widgets.widgets.lmfit_dialog.lmfit_dialog.LMFitDialog.rst
-```
-````
+
 
 
 

docs/user/widgets/motor_map/motor_map.md

@@ -63,6 +63,8 @@ mm1.map(x_name='aptrx', y_name='aptry')
 
 ````{tab} API
 ```{eval-rst}  
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.MotorMap.rst
+.. autoclass:: bec_widgets.cli.client.MotorMap
+   :members:
+   :show-inheritance:
 ```
 ````

docs/user/widgets/multi_waveform/multi_waveform.md

@@ -89,6 +89,8 @@ multi_waveform.export_to_matplotlib()
 
 ````{tab} API
 ```{eval-rst}  
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.MultiWaveform.rst
+.. autoclass:: bec_widgets.cli.client.MultiWaveform
+   :members:
+   :show-inheritance:
 ```
 ````

docs/user/widgets/position_indicator/position_indicator.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The [`PositionIndicator`](/api_reference/_autosummary/bec_widgets.cli.client.PositionIndicator) widget is a simple yet effective tool for visually indicating the position of a motor within its set limits. This widget is particularly useful in applications where it is important to provide a visual clue of the motor's current position relative to its minimum and maximum values. The `PositionIndicator` can be easily integrated into your GUI application either through direct code instantiation or by using `BEC Designer`.
+The `PositionIndicator` widget is a simple yet effective tool for visually indicating the position of a motor within its set limits. This widget is particularly useful in applications where it is important to provide a visual clue of the motor's current position relative to its minimum and maximum values. The `PositionIndicator` can be easily integrated into your GUI application either through direct code instantiation or by using `BEC Designer`.
 
 ## Key Features:
 - **Position Visualization**: Displays the current position of a motor on a linear scale, showing its location relative to the defined limits.
@@ -36,7 +36,7 @@ Within the BEC Designer's [property editor](https://doc.qt.io/qt-6/designer-widg
 
 ````{tab} Examples
 
-The `PositionIndicator` widget can be embedded in a [`BECDockArea`](#user.widgets.bec_dock_area) or used as an individual component in your application through `BEC Designer`. Below are examples demonstrating how to create and use the `PositionIndicator` from the CLI and also directly within Code.
+The `PositionIndicator` widget can be embedded in a [`BECDockArea`](user.widgets.bec_dock_area) or used as an individual component in your application through `BEC Designer`. Below are examples demonstrating how to create and use the `PositionIndicator` from the CLI and also directly within Code.
 
 ## Example 1 - Creating a Position Indicator in Code
 
@@ -95,6 +95,8 @@ self.position_indicator.set_value(new_position_value)
 
 ````{tab} API
 ```{eval-rst} 
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.PositionIndicator.rst
+.. autoclass:: bec_widgets.cli.client.PositionIndicator
+   :members:
+   :show-inheritance:
 ```
 ````

docs/user/widgets/positioner_box/positioner_box.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The [`PositionerBox`](/api_reference/_autosummary/bec_widgets.cli.client.PositionerBox) widget provides a graphical user interface to control a positioner device within the BEC environment. This widget allows users to interact with a positioner by setting setpoints, tweaking the motor position, and stopping motion. The device selection can be done via a small button under the device label, through `BEC Designer`, or by using the command line interface (CLI). This flexibility makes the `PositionerBox` an essential tool for tasks involving precise position control.
+The `PositionerBox` widget provides a graphical user interface to control a positioner device within the BEC environment. This widget allows users to interact with a positioner by setting setpoints, tweaking the motor position, and stopping motion. The device selection can be done via a small button under the device label, through `BEC Designer`, or by using the command line interface (CLI). This flexibility makes the `PositionerBox` an essential tool for tasks involving precise position control.
 
 ## Key Features:
 - **Device Selection**: Easily select a positioner device by clicking the button under the device label or by configuring the widget in `BEC Designer`.
@@ -58,6 +58,8 @@ self.positioner_box.set_positioner("motor2")
 
 ````{tab} API
 ```{eval-rst} 
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.PositionerBox.rst
+.. autoclass:: bec_widgets.cli.client.PositionerBox
+   :members:
+   :show-inheritance:
 ```
 ````

docs/user/widgets/positioner_box/positioner_box_2d.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The [`PositionerBox2D`](/api_reference/_autosummary/bec_widgets.cli.client.PositionerBox2D) widget is very similar to the [`PositionerBox`](/user/widgets/positioner_box/positioner_box) but allows controlling two positioners at the same time, in a horizontal and vertical orientation respectively. It is intended primarily for controlling axes which have a perpendicular relationship like that. In other cases, it may be better to use a `PositionerGroup` instead. 
+The `PositionerBox2D` widget is very similar to the `PositionerBox` but allows controlling two positioners at the same time, in a horizontal and vertical orientation respectively. It is intended primarily for controlling axes which have a perpendicular relationship like that. In other cases, it may be better to use a `PositionerGroup` instead. 
 
 The `PositionerBox2D` has the same features as the standard `PositionerBox`, but additionally, step buttons which move the positioner by the selected step size, and tweak buttons which move by a tenth of the selected step size.
 
@@ -55,6 +55,8 @@ self.positioner_box.set_positioner_verr("samy")
 
 ````{tab} API
 ```{eval-rst} 
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.PositionerBox2D.rst
+.. autoclass:: bec_widgets.cli.client.PositionerBox2D
+   :members:
+   :show-inheritance:
 ```
 ````

docs/user/widgets/progress_bar/ring_progress_bar.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The [`Ring Progress Bar`](/api_reference/_autosummary/bec_widgets.cli.client.RingProgressBar) widget is a circular progress bar designed to visualize the progress of tasks in a clear and intuitive manner. This widget is particularly useful in applications where task progress needs to be represented as a percentage. The `Ring Progress Bar` can be controlled directly via its API or can be hooked up to track the progress of a device readback or scan, providing real-time visual feedback.
+The `RingProgressBar` widget is a circular progress bar designed to visualize the progress of tasks in a clear and intuitive manner. This widget is particularly useful in applications where task progress needs to be represented as a percentage. The `Ring Progress Bar` can be controlled directly via its API or can be hooked up to track the progress of a device readback or scan, providing real-time visual feedback.
 
 ## Key Features:
 - **Circular Progress Visualization**: Displays a circular progress bar to represent task completion.
@@ -98,7 +98,9 @@ progress.set_value([50, 75, 25])
 
 ````{tab} API
 ```{eval-rst} 
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.RingProgressBar.rst
+.. autoclass:: bec_widgets.cli.client.RingProgressBar
+   :members:
+   :show-inheritance:
 ```
 ````
 

docs/user/widgets/queue/queue.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The [`BEC Queue`](/api_reference/_autosummary/bec_widgets.cli.client.BECQueue) widget provides a real-time display and control of the BEC scan queue, allowing users to monitor, manage, and control the status of ongoing and pending scans. The widget automatically updates to reflect the current state of the scan queue, displaying critical information such as scan numbers, types, and statuses. Additionally, it provides control options to stop individual scans, stop the entire queue, resume, and reset the queue, making it a powerful tool for managing scan operations in the BEC environment.
+The `BECQueue` widget provides a real-time display and control of the BEC scan queue, allowing users to monitor, manage, and control the status of ongoing and pending scans. The widget automatically updates to reflect the current state of the scan queue, displaying critical information such as scan numbers, types, and statuses. Additionally, it provides control options to stop individual scans, stop the entire queue, resume, and reset the queue, making it a powerful tool for managing scan operations in the BEC environment.
 
 ## Key Features:
 - **Real-Time Queue Monitoring**: Displays the current state of the BEC scan queue, with automatic updates as the queue changes.
@@ -39,6 +39,8 @@ Once the widget is added, it will automatically display the current scan queue
 
 ````{tab} API
 ```{eval-rst} 
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.BECQueue.rst
+.. autoclass:: bec_widgets.cli.client.BECQueue
+   :members:
+   :show-inheritance:
 ```
 ````

docs/user/widgets/scan_control/scan_control.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The [`Scan Control`](/api_reference/_autosummary/bec_widgets.cli.client.ScanControl) widget provides a graphical user interface (GUI) to manage various scan operations in a BEC environment. It is designed to interact with the BEC server, enabling users to start and stop scans. The widget automatically creates the necessary input form based on the scan's signature and gui_config, making it highly adaptable to different scanning processes.
+The `ScanControl` widget provides a graphical user interface (GUI) to manage various scan operations in a BEC environment. It is designed to interact with the BEC server, enabling users to start and stop scans. The widget automatically creates the necessary input form based on the scan's signature and gui_config, making it highly adaptable to different scanning processes.
 
 ## Key Features:
 - **Automatic Interface Generation**: Automatically generates a control interface based on scan signatures and `gui_config`.
@@ -59,6 +59,8 @@ scan_control = dock_area.new().new(gui.available_widgets.ScanControl)
 
 ````{tab} API
 ```{eval-rst} 
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.ScanControl.rst
+.. autoclass:: bec_widgets.cli.client.ScanControl
+   :members:
+   :show-inheritance:
 ```
 ````

docs/user/widgets/scatter_waveform/scatter_waveform.md

@@ -34,6 +34,8 @@ The ScatterWaveform widget only plots the data points if both x and y axis motor
 
 ````{tab} API
 ```{eval-rst}  
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.ScatterWaveform.rst
+.. autoclass:: bec_widgets.cli.client.ScatterWaveform
+   :members:
+   :show-inheritance:
 ```
 ````

docs/user/widgets/signal_input/signal_input.md

@@ -104,14 +104,6 @@ The following Qt properties are also included:
 
 ````
 
-````{tab} API - ComboBox
-```{eval-rst} 
-.. include:: /api_reference/_autosummary/bec_widgets.control.device_input.signal_combobox.SignalComboBox.rst
-```
-````
 
-````{tab} API - LineEdit
-```{eval-rst}
-.. include:: /api_reference/_autosummary/bec_widgets.control.device_input.signal_line_edit.SignalLineEdit.rst
-```
-````
+
+

docs/user/widgets/signal_label/signal_label.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The [`SignalLabel`](/api_reference/_autosummary/bec_widgets.cli.client.SignalLabel) displays the value of a signal from a device, with optional customization for labels, units, decimal formatting, and signal selection. It is designed for use in BEC (Beamline Experiment Control) GUIs to monitor values which beamline operators might want to keep an eye on, e.g. sample position, flux, hutch state...
+The `SignalLabel` displays the value of a signal from a device, with optional customization for labels, units, decimal formatting, and signal selection. It is designed for use in BEC (Beamline Experiment Control) GUIs to monitor values which beamline operators might want to keep an eye on, e.g. sample position, flux, hutch state...
 
 ## Key Features:
 - Display: Shows the current value of a device signal.
@@ -88,7 +88,9 @@ The various properties can also be set when the SignalLabel widget is added to a
 
 ````{tab} API
 ```{eval-rst} 
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.TextBox.rst
+.. autoclass:: bec_widgets.cli.client.TextBox
+   :members:
+   :show-inheritance:
 ```
 ````
 

docs/user/widgets/spinner/spinner.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The [`SpinnerWidget`](/api_reference/_autosummary/bec_widgets.utility.spinner.spinner.SpinnerWidget) is a simple and versatile widget designed to indicate loading or movement within an application. It is commonly used to show that a device is in motion or that an operation is ongoing. The `SpinnerWidget` can be easily integrated into your GUI application either through direct code instantiation or by using `BEC Designer`.
+The `SpinnerWidget` is a simple and versatile widget designed to indicate loading or movement within an application. It is commonly used to show that a device is in motion or that an operation is ongoing. The `SpinnerWidget` can be easily integrated into your GUI application either through direct code instantiation or by using `BEC Designer`.
 
 ## Key Features:
 - **Loading Indicator**: Provides a visual indication of ongoing operations or device movement.

docs/user/widgets/text_box/text_box.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The [`Text Box Widget`](/api_reference/_autosummary/bec_widgets.cli.client.TextBox) is a versatile widget that allows users to display text within the BEC GUI. It supports both plain text and HTML, making it useful for displaying simple messages or more complex formatted content. This widget is particularly suited for integrating textual content directly into the user interface, whether as a standalone message box or as part of a larger application interface.
+The {py:class}`~bec_widgets.cli.client.TextBox` is a versatile widget that allows users to display text within the BEC GUI. It supports both plain text and HTML, making it useful for displaying simple messages or more complex formatted content. This widget is particularly suited for integrating textual content directly into the user interface, whether as a standalone message box or as part of a larger application interface.
 
 ## Key Features:
 - **Text Display**: Display either plain text or HTML content, with automatic detection of the format.
@@ -45,7 +45,9 @@ text_box.set_html_text("<h1>Welcome to BEC Widgets</h1><p>This is an example of
 
 ````{tab} API
 ```{eval-rst} 
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.TextBox.rst
+.. autoclass:: bec_widgets.cli.client.TextBox
+   :members:
+   :show-inheritance:
 ```
 ````
 

docs/user/widgets/toggle/toggle.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The [`Toggle Switch`](/api_reference/_autosummary/bec_widgets.cli.client.ToggleSwitch) widget provides a simple, customizable toggle switch that can be used to represent binary states (e.g., on/off, true/false) within a GUI. This widget is designed to be used directly in code or added through `BEC Designer`, making it versatile for various applications where a user-friendly switch is needed.
+The {py:class}`~bec_widgets.cli.client.ToggleSwitch` widget provides a simple, customizable toggle switch that can be used to represent binary states (e.g., on/off, true/false) within a GUI. This widget is designed to be used directly in code or added through `BEC Designer`, making it versatile for various applications where a user-friendly switch is needed.
 
 ## Key Features:
 - **Binary State Representation**: Represents a simple on/off state with a smooth toggle animation.

docs/user/widgets/waveform/waveform_widget.md

@@ -101,6 +101,8 @@ print(dap_bpm3a.dap_params)
 
 ````{tab} API
 ```{eval-rst}  
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.Waveform.rst
+.. autoclass:: bec_widgets.cli.client.Waveform
+   :members:
+   :show-inheritance:
 ```
 ````

docs/user/widgets/website/website.md

@@ -4,7 +4,7 @@
 
 ````{tab} Overview
 
-The [`Website Widget`](/api_reference/_autosummary/bec_widgets.cli.client.WebsiteWidget) is a versatile tool that allows users to display websites directly within the BEC GUI. This widget is useful for embedding documentation, dashboards, or any web-based tools within the application interface. It is designed to be integrated within a [`BECDockArea`](user.widgets.bec_dock_area) or used as an individual component in your application through `BEC Designer`.
+The {py:class}`~bec_widgets.cli.client.WebsiteWidget` is a versatile tool that allows users to display websites directly within the BEC GUI. This widget is useful for embedding documentation, dashboards, or any web-based tools within the application interface. It is designed to be integrated within a [`BECDockArea`](user.widgets.bec_dock_area) or used as an individual component in your application through `BEC Designer`.
 
 ## Key Features:
 - **URL Display**: Set and display any website URL within the widget.
@@ -66,6 +66,8 @@ print(f"The current URL is: {current_url}")
 
 ````{tab} API
 ```{eval-rst} 
-.. include:: /api_reference/_autosummary/bec_widgets.cli.client.WebsiteWidget.rst
+.. autoclass:: bec_widgets.cli.client.WebsiteWidget
+   :members:
+   :show-inheritance:
 ```
 ````

pyproject.toml

@@ -4,17 +4,17 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec_widgets"
-version = "2.38.0"
+version = "2.42.0"
 description = "BEC Widgets"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Programming Language :: Python :: 3",
     "Topic :: Scientific/Engineering",
 ]
 dependencies = [
-    "bec_ipython_client~=3.52", # needed for jupyter console
-    "bec_lib~=3.52",
+    "bec_ipython_client~=3.70",  # needed for jupyter console
+    "bec_lib~=3.70",
     "bec_qthemes~=0.7, >=0.7",
     "black~=25.0",              # needed for bw-generate-cli
     "isort~=5.13, >=5.13.2",    # needed for bw-generate-cli
@@ -24,6 +24,7 @@ dependencies = [
     "qtconsole~=5.5, >=5.5.1",  # needed for jupyter console
     "qtpy~=2.4",
     "qtmonaco~=0.5",
+    "thefuzz~=0.22",
 ]
 
 
@@ -41,7 +42,7 @@ dev = [
     "pytest-cov~=6.1.1",
     "watchdog~=6.0",
     "pre_commit~=4.2",
-    "thefuzz~=0.22",
+
 ]
 
 [project.urls]

tests/conftest.py

@@ -1,33 +1,7 @@
 import pytest
 import qtpy.QtCore
-from pytestqt.exceptions import TimeoutError as QtBotTimeoutError
-from qtpy.QtCore import QTimer
-
-
-class TestableQTimer(QTimer):
-    _instances: list[tuple[QTimer, str]] = []
-    _current_test_name: str = ""
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        TestableQTimer._instances.append((self, TestableQTimer._current_test_name))
-
-    @classmethod
-    def check_all_stopped(cls, qtbot):
-        def _is_done_or_deleted(t: QTimer):
-            try:
-                return not t.isActive()
-            except RuntimeError as e:
-                return "already deleted" in e.args[0]
-
-        try:
-            qtbot.waitUntil(lambda: all(_is_done_or_deleted(timer) for timer, _ in cls._instances))
-        except QtBotTimeoutError as exc:
-            active_timers = list(filter(lambda t: t[0].isActive(), cls._instances))
-            (t.stop() for t, _ in cls._instances)
-            raise TimeoutError(f"Failed to stop all timers: {active_timers}") from exc
-        cls._instances = []
 
+from bec_widgets.tests.utils import TestableQTimer
 
 # To support 'from qtpy.QtCore import QTimer' syntax we just replace this completely for the test session
 # see: https://docs.python.org/3/library/unittest.mock.html#where-to-patch

tests/end-2-end/test_plotting_framework_e2e.py

@@ -6,7 +6,7 @@ from bec_lib.endpoints import MessageEndpoints
 
 from bec_widgets.cli.client import Image, MotorMap, MultiWaveform, ScatterWaveform, Waveform
 from bec_widgets.cli.rpc.rpc_base import RPCReference
-from bec_widgets.tests.utils import check_remote_data_size
+from bec_widgets.tests.fake_devices import check_remote_data_size
 
 
 def test_rpc_waveform1d_custom_curve(qtbot, connected_client_gui_obj):
@@ -286,3 +286,85 @@ def test_waveform_passing_device(qtbot, bec_client_lib, connected_client_gui_obj
     # check plotted data
     x_data, y_data = c1.get_data()
     assert np.array_equal(y_data, last_scan_data.devices.samx.samx_setpoint.read().get("value"))
+
+
+@pytest.mark.timeout(120)
+@pytest.mark.parametrize(
+    "history_selector", ["scan_id", "scan_number"]
+)  # ensure unique curves per run
+def test_rpc_waveform_history_curve(
+    qtbot, bec_client_lib, connected_client_gui_obj, history_selector
+):
+    """
+    E2E test for the new history curve feature:
+    - Run 3 scans
+    - For each scan, fetch history curve data using either scan_id OR scan_number (parametrized)
+    - Compare waveform data with BEC client scan data
+    Note: Parameterization prevents adding the same logical curve twice (which would collide on label).
+    """
+    gui = connected_client_gui_obj
+    dock = gui.bec
+    client = bec_client_lib
+    dev = client.device_manager.devices
+    scans = client.scans
+    queue = client.queue
+
+    wf = dock.new("wf_dock").new("Waveform")
+
+    # Collect references for validation
+    scan_meta = []  # list of dicts with scan_id, scan_number, data
+
+    # Run 3 scans and collect their metadata and data
+    for i in range(3):
+        status = scans.line_scan(dev.samx, -5 + i, 5 + i, steps=10, exp_time=0.01, relative=False)
+        status.wait()
+
+        # Wait until the history entry appears and corresponds to this scan
+        def _wait_for_scan_in_history():
+            if len(client.history) == 0:
+                return False
+            return client.history[-1].metadata.bec.get("scan_id", None) == status.scan.scan_id
+
+        qtbot.waitUntil(_wait_for_scan_in_history, timeout=10000)
+
+        hist_item = client.history[-1]
+        item = queue.scan_storage.storage[-1]
+        data = item.live_data if hasattr(item, "live_data") else item.data
+        scan_meta.append(
+            {
+                "scan_id": hist_item.metadata.bec.get("scan_id"),
+                "scan_number": hist_item.metadata.bec.get("scan_number"),
+                "data": data,
+            }
+        )
+
+    # For each scan, fetch history curve by the chosen selector and compare to client data
+    for meta in scan_meta:
+        sel_value = meta[history_selector]
+        scan_data = meta["data"]
+
+        # Add curve from history using the chosen selector; single curve per scan to avoid duplicates
+        kwargs = {history_selector: sel_value}
+        curve = wf.plot(x_name="samx", y_name="bpm4i", **kwargs)
+
+        num_elements = 10
+
+        # Wait until curve has the expected number of points
+        def _curve_ready():
+            try:
+                x, y = curve.get_data()
+            except Exception:
+                return False
+            return x is not None and len(x) == num_elements and len(y) == num_elements
+
+        qtbot.waitUntil(_curve_ready, timeout=10000)
+
+        # Get plotted data
+        x_vals, y_vals = curve.get_data()
+
+        # Compare against BEC client scan data
+        np.testing.assert_equal(x_vals, np.array(scan_data["samx"]["samx"].val))
+        np.testing.assert_equal(y_vals, np.array(scan_data["bpm4i"]["bpm4i"].val))
+
+        # Clean up
+        curve.remove()

tests/end-2-end/user_interaction/test_user_interaction_e2e.py

@@ -371,6 +371,13 @@ def test_widgets_e2e_image(qtbot, connected_client_gui_obj, random_generator_fro
     )  # Get last image from Redis monitor 2D endpoint
     assert np.allclose(img.get_data(), last_img)
 
+    # Now add a device with a preview signal
+    img = widget.image(["eiger", "preview"])
+    s = scans.line_scan(dev.samx, -3, 3, steps=50, exp_time=0.01, relative=False)
+    s.wait()
+
+    qtbot.waitUntil(_wait_for_scan_in_history, timeout=7000)
+
     # Test removing the widget, or leaving it open for the next test
     maybe_remove_dock_area(qtbot, gui=gui, random_int_gen=random_generator_from_seed)
 
@@ -577,6 +584,13 @@ def test_widgets_e2e_ring_progress_bar(qtbot, connected_client_gui_obj, random_g
     dock: client.BECDock
     widget: client.RingProgressBar
 
+    widget.set_number_of_bars(3)
+    widget.rings[0].set_update("manual")
+    widget.rings[0].set_value(30)
+    widget.rings[0].set_min_max_values(0, 100)
+    widget.rings[1].set_update("scan")
+    widget.rings[2].set_update("device", device="samx")
+
     # Test rpc calls
     dev = bec.device_manager.devices
     scans = bec.scans

tests/unit_tests/conftest.py

@@ -5,12 +5,10 @@ import h5py
 import numpy as np
 import pytest
 from bec_lib import messages
-from pytestqt.exceptions import TimeoutError as QtBotTimeoutError
-from qtpy.QtWidgets import QApplication
+from bec_lib.messages import _StoredDataInfo
+from qtpy.QtWidgets import QMessageBox
 
-from bec_widgets.cli.rpc.rpc_register import RPCRegister
-from bec_widgets.utils import bec_dispatcher as bec_dispatcher_module
-from bec_widgets.utils import error_popups
+from bec_widgets.tests import utils as test_utils
 
 
 @pytest.hookimpl(tryfirst=True, hookwrapper=True)
@@ -24,49 +22,30 @@ def pytest_runtest_makereport(item, call):
 
 @pytest.fixture(autouse=True)
 def qapplication(qtbot, request, testable_qtimer_class):  # pylint: disable=unused-argument
-    yield
-
-    # if the test failed, we don't want to check for open widgets as
-    # it simply pollutes the output
-    if request.node.stash._storage.get("failed"):
-        print("Test failed, skipping cleanup checks")
-        return
-    bec_dispatcher = bec_dispatcher_module.BECDispatcher()
-    bec_dispatcher.stop_cli_server()
-
-    testable_qtimer_class.check_all_stopped(qtbot)
-    qapp = QApplication.instance()
-    qapp.processEvents()
-    if hasattr(qapp, "os_listener") and qapp.os_listener:
-        qapp.removeEventFilter(qapp.os_listener)
-    try:
-        qtbot.waitUntil(lambda: qapp.topLevelWidgets() == [])
-    except QtBotTimeoutError as exc:
-        raise TimeoutError(f"Failed to close all widgets: {qapp.topLevelWidgets()}") from exc
+    yield from test_utils.qapplication_fixture(qtbot, request, testable_qtimer_class)
 
 
 @pytest.fixture(autouse=True)
 def rpc_register():
-    yield RPCRegister()
-    RPCRegister.reset_singleton()
+    yield from test_utils.rpc_register_fixture()
 
 
 @pytest.fixture(autouse=True)
 def bec_dispatcher(threads_check):  # pylint: disable=unused-argument
-    bec_dispatcher = bec_dispatcher_module.BECDispatcher()
-    yield bec_dispatcher
-    bec_dispatcher.disconnect_all()
-    # clean BEC client
-    bec_dispatcher.client.shutdown()
-    # stop the cli server
-    bec_dispatcher.stop_cli_server()
-    # reinitialize singleton for next test
-    bec_dispatcher_module.BECDispatcher.reset_singleton()
+    yield from test_utils.bec_dispatcher_fixture(threads_check)
 
 
 @pytest.fixture(autouse=True)
 def clean_singleton():
-    error_popups._popup_utility_instance = None
+    yield from test_utils.clean_singleton_fixture()
+
+
+@pytest.fixture(autouse=True)
+def suppress_message_box(monkeypatch):
+    """
+    Auto-suppress any QMessageBox.exec_ calls by returning Ok immediately.
+    """
+    monkeypatch.setattr(QMessageBox, "exec_", lambda *args, **kwargs: QMessageBox.Ok)
 
 
 def create_widget(qtbot, widget, *args, **kwargs):
@@ -115,9 +94,25 @@ def create_history_file(file_path, data: dict, metadata: dict) -> messages.ScanH
                     elif isinstance(sub_value, dict):
                         for sub_sub_key, sub_sub_value in sub_value.items():
                             sub_sub_group = metadata_bec[key].create_group(sub_key)
+                            # Handle _StoredDataInfo objects
+                            if isinstance(sub_sub_value, _StoredDataInfo):
+                                # Store the numeric shape
+                                sub_sub_group.create_dataset("shape", data=sub_sub_value.shape)
+                                # Store the dtype as a UTF-8 string
+                                dt = sub_sub_value.dtype or ""
+                                sub_sub_group.create_dataset(
+                                    "dtype", data=dt, dtype=h5py.string_dtype(encoding="utf-8")
+                                )
+                                continue
                             if isinstance(sub_sub_value, list):
-                                sub_sub_value = json.dumps(sub_sub_value)
-                            sub_sub_group.create_dataset(sub_sub_key, data=sub_sub_value)
+                                json_val = json.dumps(sub_sub_value)
+                                sub_sub_group.create_dataset(sub_sub_key, data=json_val)
+                            elif isinstance(sub_sub_value, dict):
+                                for k2, v2 in sub_sub_value.items():
+                                    val = json.dumps(v2) if isinstance(v2, list) else v2
+                                    sub_sub_group.create_dataset(k2, data=val)
+                            else:
+                                sub_sub_group.create_dataset(sub_sub_key, data=sub_sub_value)
                     else:
                         metadata_bec[key].create_dataset(sub_key, data=sub_value)
             else:
@@ -144,6 +139,8 @@ def create_history_file(file_path, data: dict, metadata: dict) -> messages.ScanH
         end_time=time.time(),
         num_points=metadata["num_points"],
         request_inputs=metadata["request_inputs"],
+        stored_data_info=metadata.get("stored_data_info"),
+        metadata={"scan_report_devices": metadata.get("scan_report_devices")},
     )
     return msg
 
@@ -194,3 +191,102 @@ def grid_scan_history_msg(tmpdir):
 
     file_path = str(tmpdir.join("scan_1.h5"))
     return create_history_file(file_path, data, metadata)
+
+
+@pytest.fixture
+def scan_history_factory(tmpdir):
+    """
+    Factory to create scan history messages with custom parameters.
+    Usage:
+        msg1 = scan_history_factory(scan_id="id1", scan_number=1, num_points=10)
+        msg2 = scan_history_factory(scan_id="id2", scan_number=2, scan_name="grid_scan", num_points=16)
+    """
+
+    def _factory(
+        scan_id: str = "test_scan",
+        scan_number: int = 1,
+        dataset_number: int = 1,
+        scan_name: str = "line_scan",
+        scan_type: str = "step",
+        num_points: int = 10,
+        x_range: tuple = (-5, 5),
+        y_range: tuple = (-5, 5),
+    ):
+        # Generate positions based on scan type
+        if scan_name == "grid_scan":
+            grid_size = int(np.sqrt(num_points))
+            x_grid, y_grid = np.meshgrid(
+                np.linspace(x_range[0], x_range[1], grid_size),
+                np.linspace(y_range[0], y_range[1], grid_size),
+            )
+            x_flat = x_grid.T.ravel()
+            y_flat = y_grid.T.ravel()
+        else:
+            x_flat = np.linspace(x_range[0], x_range[1], num_points)
+            y_flat = np.linspace(y_range[0], y_range[1], num_points)
+        positions = np.vstack((x_flat, y_flat)).T
+        num_pts = len(positions)
+        # Create dummy data
+        data = {
+            "baseline": {"bpm1a": {"bpm1a": {"value": [1], "timestamp": [100]}}},
+            "monitored": {
+                "bpm4i": {
+                    "bpm4i": {
+                        "value": np.random.rand(num_points),
+                        "timestamp": np.random.rand(num_points),
+                    }
+                },
+                "bpm3a": {
+                    "bpm3a": {
+                        "value": np.random.rand(num_points),
+                        "timestamp": np.random.rand(num_points),
+                    }
+                },
+                "samx": {"samx": {"value": x_flat, "timestamp": np.arange(num_pts)}},
+                "samy": {"samy": {"value": y_flat, "timestamp": np.arange(num_pts)}},
+            },
+            "async": {
+                "async_device": {
+                    "async_device": {
+                        "value": np.random.rand(num_pts * 10),
+                        "timestamp": np.random.rand(num_pts * 10),
+                    }
+                }
+            },
+        }
+        metadata = {
+            "scan_id": scan_id,
+            "scan_name": scan_name,
+            "scan_type": scan_type,
+            "exit_status": "closed",
+            "scan_number": scan_number,
+            "dataset_number": dataset_number,
+            "request_inputs": {
+                "arg_bundle": [
+                    "samx",
+                    x_range[0],
+                    x_range[1],
+                    num_pts,
+                    "samy",
+                    y_range[0],
+                    y_range[1],
+                    num_pts,
+                ],
+                "kwargs": {"relative": True},
+            },
+            "positions": positions.tolist(),
+            "num_points": num_pts,
+            "stored_data_info": {
+                "samx": {"samx": _StoredDataInfo(shape=(num_points,), dtype="float64")},
+                "samy": {"samy": _StoredDataInfo(shape=(num_points,), dtype="float64")},
+                "bpm4i": {"bpm4i": _StoredDataInfo(shape=(10,), dtype="float64")},
+                "async_device": {
+                    "async_device": _StoredDataInfo(shape=(num_points * 10,), dtype="float64")
+                },
+            },
+            "scan_report_devices": [b"samx"],
+        }
+        file_path = str(tmpdir.join(f"{scan_id}.h5"))
+        return create_history_file(file_path, data, metadata)
+
+    return _factory

tests/unit_tests/test_abort_button.py

@@ -2,10 +2,9 @@
 
 import pytest
 
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.control.buttons.button_abort.button_abort import AbortButton
 
-from .client_mocks import mocked_client
-
 
 @pytest.fixture
 def abort_button(qtbot, mocked_client):

tests/unit_tests/test_axis_settings.py

@@ -1,9 +1,9 @@
 import pytest
 from qtpy.QtWidgets import QDoubleSpinBox, QLineEdit
 
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.plots.plot_base import PlotBase
 from bec_widgets.widgets.plots.setting_menus.axis_settings import AxisSettings
-from tests.unit_tests.client_mocks import mocked_client
 from tests.unit_tests.conftest import create_widget
 
 

tests/unit_tests/test_bec_connector.py

@@ -5,11 +5,10 @@ import pytest
 from qtpy.QtCore import QObject
 from qtpy.QtWidgets import QApplication
 
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.utils import BECConnector
 from bec_widgets.utils.error_popups import SafeSlot as Slot
 
-from .client_mocks import mocked_client
-
 
 class BECConnectorQObject(BECConnector, QObject): ...
 

tests/unit_tests/test_bec_dock.py

@@ -5,9 +5,9 @@ from unittest import mock
 import pytest
 from bec_lib.endpoints import MessageEndpoints
 
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.containers.dock import BECDockArea
 
-from .client_mocks import mocked_client
 from .test_bec_queue import bec_queue_msg_full
 
 

tests/unit_tests/test_bec_queue.py

@@ -1,10 +1,9 @@
 import pytest
 from bec_lib import messages
 
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.services.bec_queue.bec_queue import BECQueue
 
-from .client_mocks import mocked_client
-
 
 @pytest.fixture
 def bec_queue_msg_full():

tests/unit_tests/test_bec_status_box.py

@@ -4,13 +4,12 @@ from unittest import mock
 import pytest
 from bec_lib.messages import BECStatus, ServiceMetricMessage, StatusMessage
 
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.services.bec_status_box.bec_status_box import (
     BECServiceInfoContainer,
     BECStatusBox,
 )
 
-from .client_mocks import mocked_client
-
 
 @pytest.fixture
 def service_status_fixture():

tests/unit_tests/test_client_plugin_widgets.py

@@ -28,8 +28,7 @@ def test_plugins_dont_clobber_client_globals(bec_logger: MagicMock):
     bec_logger.logger.warning.assert_called_with(
         "Plugin widget Widgets from namespace(Widgets=<class 'tests.unit_tests.test_client_plugin_widgets._TestGlobalPlugin'>) conflicts with a built-in class!"
     )
-    if sys.version_info >= (3, 11):  # No EnumType in python3.10
-        assert isinstance(client.Widgets, enum.EnumType)
+    assert isinstance(client.Widgets, enum.EnumType)
 
 
 class _TestDuplicatePlugin(RPCBase): ...

tests/unit_tests/test_color_utils.py

@@ -4,11 +4,11 @@ from pydantic import ValidationError
 from qtpy.QtGui import QColor
 from qtpy.QtWidgets import QVBoxLayout, QWidget
 
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.utils import Colors, ConnectionConfig
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.colors import apply_theme
 from bec_widgets.widgets.plots.waveform.curve import CurveConfig
-from tests.unit_tests.client_mocks import mocked_client
 from tests.unit_tests.conftest import create_widget
 
 

tests/unit_tests/test_crosshair.py

@@ -4,8 +4,12 @@ import pytest
 from qtpy.QtCore import QPointF, Qt
 from qtpy.QtGui import QTransform
 
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.utils import Crosshair
 from bec_widgets.widgets.plots.image.image_item import ImageItem
+from bec_widgets.widgets.plots.waveform.waveform import Waveform
+
+from .conftest import create_widget
 
 # pylint: disable = redefined-outer-name
 
@@ -363,3 +367,27 @@ def test_get_transformed_position_with_scale(plot_widget_with_crosshair):
     # Check that the results match expectations
     assert row == expected_row
     assert col == expected_col
+
+
+def test_ignore_invisible_curves_on_move(qtbot, mocked_client):
+    wf = create_widget(qtbot, Waveform, client=mocked_client)
+    c0 = wf.plot(x=[1, 2, 3], y=[1, 4, 9], name="Curve_0")
+    c1 = wf.plot(x=[1, 2, 3], y=[2, 5, 10], name="Curve_1")
+    wf.hook_crosshair()
+
+    # # Simulate a mouse move at (2,5)
+    pos_in_view = QPointF(2, 5)
+    pos_in_scene = wf.plot_item.vb.mapViewToScene(pos_in_view)
+    event_mock = [pos_in_scene]
+
+    # 1) Both curves visible: expect markers for both
+    wf.crosshair.clear_markers()
+    wf.crosshair.mouse_moved(event_mock)
+    assert set(wf.crosshair.marker_moved_1d.keys()) == {"Curve_0", "Curve_1"}
+
+    # 2) Hide Curve B and repeat: only Curve_0 should remain
+    c1.setVisible(False)
+    wf.crosshair.clear_markers()
+    wf.crosshair.mouse_moved(event_mock)
+    qtbot.wait(200)
+    assert set(wf.crosshair.marker_moved_1d.keys()) == {"Curve_0"}

tests/unit_tests/test_curve_settings.py

@@ -2,12 +2,17 @@ import json
 from unittest.mock import MagicMock, patch
 
 import pytest
+from bec_lib.scan_history import ScanHistory
+from qtpy.QtGui import QValidator
 from qtpy.QtWidgets import QComboBox, QVBoxLayout
 
+from bec_widgets.tests.client_mocks import dap_plugin_message, mocked_client, mocked_client_with_dap
 from bec_widgets.widgets.plots.waveform.settings.curve_settings.curve_setting import CurveSetting
-from bec_widgets.widgets.plots.waveform.settings.curve_settings.curve_tree import CurveTree
+from bec_widgets.widgets.plots.waveform.settings.curve_settings.curve_tree import (
+    CurveTree,
+    ScanIndexValidator,
+)
 from bec_widgets.widgets.plots.waveform.waveform import Waveform
-from tests.unit_tests.client_mocks import dap_plugin_message, mocked_client, mocked_client_with_dap
 from tests.unit_tests.conftest import create_widget
 
 ##################################################
@@ -155,7 +160,7 @@ def test_curve_tree_init(curve_tree_fixture):
     curve_tree, wf = curve_tree_fixture
     assert curve_tree.waveform == wf
     assert curve_tree.color_palette == "plasma"
-    assert curve_tree.tree.columnCount() == 7
+    assert curve_tree.tree.columnCount() == 8
 
     assert curve_tree.toolbar.components.exists("add")
     assert curve_tree.toolbar.components.exists("expand")
@@ -374,3 +379,54 @@ def test_export_data_dap(curve_tree_fixture):
     assert exported["signal"]["entry"] == "bpm4i"
     assert exported["signal"]["dap"] == "GaussianModel"
     assert exported["label"] == "bpm4i-bpm4i-GaussianModel"
+
+
+def test_scan_index_validator_behavior():
+    """
+    Test ScanIndexValidator allows empty, 'live', partial 'live', valid scan numbers,
+    and rejects invalid or disallowed inputs under the new allowed-set API.
+    """
+    validator = ScanIndexValidator(allowed_scans={1, 2, 3})
+
+    def state(txt):
+        s, _, _ = validator.validate(txt, 0)
+        return s
+
+    assert state("") == QValidator.State.Acceptable
+    assert state("live") == QValidator.State.Acceptable
+    assert state("l") == QValidator.State.Intermediate
+    assert state("liv") == QValidator.State.Intermediate
+    assert state("1") == QValidator.State.Acceptable
+    assert state("3") == QValidator.State.Acceptable
+    assert state("4") == QValidator.State.Invalid
+    assert state("0") == QValidator.State.Invalid
+    assert state("abc") == QValidator.State.Invalid
+
+
+def test_export_data_history_curve(curve_tree_fixture, scan_history_factory):
+    """
+    Test that export_data for a history curve row correctly serializes scan_number
+    and resets scan_id when a numeric scan is selected.
+    """
+    curve_tree, wf = curve_tree_fixture
+    # Inject two history scans into the waveform client
+    msgs = [
+        scan_history_factory(scan_id="hid1", scan_number=1),
+        scan_history_factory(scan_id="hid2", scan_number=2),
+    ]
+    wf.client.history = ScanHistory(wf.client, False)
+    for m in msgs:
+        wf.client.history._scan_data[m.scan_id] = m
+        wf.client.history._scan_ids.append(m.scan_id)
+        wf.client.history._scan_numbers.append(m.scan_number)
+    wf.client.queue.scan_storage.current_scan = None
+
+    # Create a device row and select scan index "2"
+    device_row = curve_tree.add_new_curve(name="bpm4i", entry="bpm4i")
+    device_row.scan_index_combo.setCurrentText("2")
+
+    exported = device_row.export_data()
+    assert exported["source"] == "history"
+    assert exported["scan_number"] == 2
+    assert exported["scan_id"] is None
+    assert exported["label"] == "bpm4i-bpm4i-scan-2"

tests/unit_tests/test_dap_combobox.py

@@ -1,8 +1,8 @@
 import pytest
 
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.dap.dap_combo_box.dap_combo_box import DapComboBox
 
-from .client_mocks import mocked_client
 from .conftest import create_widget
 
 

tests/unit_tests/test_dark_mode_button.py

@@ -4,12 +4,11 @@ import pytest
 from qtpy.QtCore import Qt
 from qtpy.QtWidgets import QApplication
 
+# pylint: disable=unused-import
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.utils.colors import set_theme
 from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
 
-# pylint: disable=unused-import
-from .client_mocks import mocked_client
-
 # pylint: disable=redefined-outer-name
 
 

tests/unit_tests/test_device_browser.py

@@ -6,6 +6,7 @@ from bec_lib.device import Device
 from qtpy.QtCore import QPoint, Qt
 from qtpy.QtWidgets import QTabWidget
 
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.services.device_browser.device_browser import DeviceBrowser
 from bec_widgets.widgets.services.device_browser.device_item.device_config_form import (
     DeviceConfigForm,
@@ -14,8 +15,6 @@ from bec_widgets.widgets.services.device_browser.device_item.device_signal_displ
     SignalDisplay,
 )
 
-from .client_mocks import mocked_client
-
 if TYPE_CHECKING:  # pragma: no cover
     from qtpy.QtWidgets import QListWidgetItem
 

tests/unit_tests/test_device_config_form_dialog.py

@@ -137,6 +137,7 @@ def test_update_cycle(update_dialog, qtbot):
                 "description": None,
                 "readOnly": False,
                 "softwareTrigger": False,
+                "onFailure": "retry",
                 "deviceTags": set(),
                 "userParameter": {},
                 "name": "test_device",

tests/unit_tests/test_device_input_base.py

@@ -4,13 +4,13 @@ import pytest
 from bec_lib.device import ReadoutPriority
 from qtpy.QtWidgets import QWidget
 
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.control.device_input.base_classes.device_input_base import (
     BECDeviceFilter,
     DeviceInputBase,
     DeviceInputConfig,
 )
 
-from .client_mocks import mocked_client
 from .conftest import create_widget
 
 

tests/unit_tests/test_device_input_widgets.py

@@ -1,14 +1,13 @@
 import pytest
 from bec_lib.device import ReadoutPriority
 
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.control.device_input.base_classes.device_input_base import BECDeviceFilter
 from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
 from bec_widgets.widgets.control.device_input.device_line_edit.device_line_edit import (
     DeviceLineEdit,
 )
 
-from .client_mocks import mocked_client
-
 
 @pytest.fixture
 def device_input_combobox(qtbot, mocked_client):

tests/unit_tests/test_device_signal_input.py

@@ -4,7 +4,7 @@ import pytest
 from bec_lib.device import Signal
 from qtpy.QtWidgets import QWidget
 
-from bec_widgets.tests.utils import FakeDevice
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.utils.ophyd_kind_util import Kind
 from bec_widgets.widgets.control.device_input.base_classes.device_input_base import BECDeviceFilter
 from bec_widgets.widgets.control.device_input.base_classes.device_signal_input_base import (
@@ -16,7 +16,6 @@ from bec_widgets.widgets.control.device_input.signal_line_edit.signal_line_edit
     SignalLineEdit,
 )
 
-from .client_mocks import mocked_client
 from .conftest import create_widget
 
 

tests/unit_tests/test_filter_io.py

@@ -1,12 +1,12 @@
 import pytest
 
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.utils.filter_io import FilterIO
 from bec_widgets.widgets.control.device_input.device_line_edit.device_line_edit import (
     DeviceLineEdit,
 )
 from bec_widgets.widgets.dap.dap_combo_box.dap_combo_box import DapComboBox
 
-from .client_mocks import mocked_client
 from .conftest import create_widget
 
 

tests/unit_tests/test_generated_form_items.py

@@ -9,7 +9,6 @@ from bec_widgets.utils.forms_from_types.items import FormItemSpec, ListFormItem
 from bec_widgets.utils.widget_io import WidgetIO
 
 
-@pytest.mark.skipif(sys.version_info < (3, 11), reason="Generic types don't support this in 3.10")
 @pytest.mark.parametrize(
     ["input", "validity"],
     [

tests/unit_tests/test_heatmap_widget.py

@@ -5,12 +5,9 @@ import pytest
 from bec_lib import messages
 from bec_lib.scan_history import ScanHistory
 
-from bec_widgets.widgets.plots.heatmap.heatmap import Heatmap, HeatmapConfig, HeatmapDeviceSignal
-
 # pytest: disable=unused-import
-from tests.unit_tests.client_mocks import mocked_client
-
-from .client_mocks import create_dummy_scan_item
+from bec_widgets.tests.client_mocks import create_dummy_scan_item, mocked_client
+from bec_widgets.widgets.plots.heatmap.heatmap import Heatmap, HeatmapConfig, HeatmapDeviceSignal
 
 
 @pytest.fixture

tests/unit_tests/test_image_roi_tree.py

@@ -4,10 +4,10 @@ import numpy as np
 import pytest
 from qtpy.QtCore import QPointF, Qt
 
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.plots.image.image import Image
 from bec_widgets.widgets.plots.image.setting_widgets.image_roi_tree import ROIPropertyTree
 from bec_widgets.widgets.plots.roi.image_roi import CircularROI, RectangularROI
-from tests.unit_tests.client_mocks import mocked_client
 from tests.unit_tests.conftest import create_widget
 
 
@@ -29,6 +29,14 @@ def roi_tree(qtbot, image_widget):
     yield tree
 
 
+@pytest.fixture
+def compact_roi_tree(qtbot, image_widget):
+    tree = create_widget(
+        qtbot, ROIPropertyTree, image_widget=image_widget, compact=True, compact_color="#00BCD4"
+    )
+    yield tree
+
+
 def test_initialization(roi_tree, image_widget):
     """Test that the widget initializes correctly with the right components."""
     # Check the widget has the right structure
@@ -431,3 +439,120 @@ def test_cleanup_disconnect_signals(roi_tree, image_widget):
     # Verify that the tree item was not updated
     assert item.text(roi_tree.COL_ROI) == initial_name
     assert item.child(2).text(roi_tree.COL_PROPS) == initial_coord
+
+
+def test_compact_initialization_minimal_toolbar(compact_roi_tree):
+    assert compact_roi_tree.compact is True
+    assert compact_roi_tree.tree is None
+
+    # Draw actions exist
+    assert compact_roi_tree.toolbar.components.get_action("roi_rectangle")
+    assert compact_roi_tree.toolbar.components.get_action("roi_circle")
+    assert compact_roi_tree.toolbar.components.get_action("roi_ellipse")
+
+    # Full-mode actions are absent
+    import pytest
+
+    with pytest.raises(KeyError):
+        compact_roi_tree.toolbar.components.get_action("expand_toggle")
+    with pytest.raises(KeyError):
+        compact_roi_tree.toolbar.components.get_action("lock_unlock_all")
+    with pytest.raises(KeyError):
+        compact_roi_tree.toolbar.components.get_action("roi_tree_cmap")
+
+    assert not hasattr(compact_roi_tree, "lock_all_action")
+
+
+def test_compact_single_roi_enforced_programmatic(compact_roi_tree, image_widget):
+    # Add first ROI
+    roi1 = image_widget.add_roi(kind="rect", name="r1")
+    assert len(image_widget.roi_controller.rois) == 1
+    assert roi1.line_color == "#00BCD4"
+
+    # Add second ROI; the first should be removed automatically
+    roi2 = image_widget.add_roi(kind="circle", name="c1")
+    rois = image_widget.roi_controller.rois
+    assert len(rois) == 1
+    assert rois[0] is roi2
+
+    from bec_widgets.widgets.plots.roi.image_roi import CircularROI
+
+    assert isinstance(rois[0], CircularROI)
+    assert rois[0].line_color == "#00BCD4"
+
+
+def test_compact_add_roi_from_toolbar_single_enforced(qtbot, compact_roi_tree, image_widget):
+    # Ensure view is ready
+    plot_item = image_widget.plot_item
+    view = plot_item.vb.scene().views()[0]
+    qtbot.waitExposed(view)
+
+    # Activate rectangle drawing
+    rect_action = compact_roi_tree.toolbar.components.get_action("roi_rectangle").action
+    rect_action.setChecked(True)
+
+    # Draw rectangle
+    start_pos = QPointF(10, 10)
+    end_pos = QPointF(50, 40)
+    start_scene = plot_item.vb.mapViewToScene(start_pos)
+    end_scene = plot_item.vb.mapViewToScene(end_pos)
+    start_widget = view.mapFromScene(start_scene)
+    end_widget = view.mapFromScene(end_scene)
+    qtbot.mousePress(view.viewport(), Qt.LeftButton, pos=start_widget)
+    qtbot.mouseMove(view.viewport(), pos=end_widget)
+    qtbot.mouseRelease(view.viewport(), Qt.LeftButton, pos=end_widget)
+    qtbot.wait(100)
+
+    rois = image_widget.roi_controller.rois
+    from bec_widgets.widgets.plots.roi.image_roi import CircularROI, RectangularROI
+
+    assert len(rois) == 1
+    assert isinstance(rois[0], RectangularROI)
+    assert rois[0].line_color == "#00BCD4"
+
+    # Now draw a circle; rectangle should be removed automatically
+    rect_action.setChecked(False)
+    circle_action = compact_roi_tree.toolbar.components.get_action("roi_circle").action
+    circle_action.setChecked(True)
+
+    start_pos = QPointF(20, 20)
+    end_pos = QPointF(40, 40)
+    start_scene = plot_item.vb.mapViewToScene(start_pos)
+    end_scene = plot_item.vb.mapViewToScene(end_pos)
+    start_widget = view.mapFromScene(start_scene)
+    end_widget = view.mapFromScene(end_scene)
+    qtbot.mousePress(view.viewport(), Qt.LeftButton, pos=start_widget)
+    qtbot.mouseMove(view.viewport(), pos=end_widget)
+    qtbot.mouseRelease(view.viewport(), Qt.LeftButton, pos=end_widget)
+    qtbot.wait(100)
+
+    rois = image_widget.roi_controller.rois
+    assert len(rois) == 1
+    assert isinstance(rois[0], CircularROI)
+    assert rois[0].line_color == "#00BCD4"
+
+
+def test_compact_draw_mode_toggle(compact_roi_tree):
+    # Initially no draw mode
+    assert compact_roi_tree._roi_draw_mode is None
+
+    rect_action = compact_roi_tree.toolbar.components.get_action("roi_rectangle").action
+    circle_action = compact_roi_tree.toolbar.components.get_action("roi_circle").action
+
+    # Toggle rect on
+    rect_action.toggle()
+    assert compact_roi_tree._roi_draw_mode == "rect"
+    assert rect_action.isChecked()
+    assert not circle_action.isChecked()
+
+    # Toggle circle on; rect should toggle off
+    circle_action.toggle()
+    assert compact_roi_tree._roi_draw_mode == "circle"
+    assert circle_action.isChecked()
+    assert not rect_action.isChecked()
+
+    # Toggle circle off → none
+    circle_action.toggle()
+    assert compact_roi_tree._roi_draw_mode is None
+    assert not rect_action.isChecked()
+    assert not circle_action.isChecked()

tests/unit_tests/test_image_rois.py

@@ -5,6 +5,7 @@ from typing import Literal
 import numpy as np
 import pytest
 
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.plots.image.image import Image
 from bec_widgets.widgets.plots.roi.image_roi import (
     CircularROI,
@@ -12,7 +13,6 @@ from bec_widgets.widgets.plots.roi.image_roi import (
     RectangularROI,
     ROIController,
 )
-from tests.unit_tests.client_mocks import mocked_client
 from tests.unit_tests.conftest import create_widget
 
 
@@ -81,7 +81,7 @@ def test_data_extraction_matches_coordinates(bec_image_widget_with_roi):
 
     # For rectangular ROI: pixel bounding box equals coordinate bbox
     if isinstance(roi, RectangularROI):
-        (x0, y0), (_, _), (_, _), (x1, y1) = roi.get_coordinates(typed=False)
+        (x0, y0), (_, _), (_, _), (x1, y1), *_ = roi.get_coordinates(typed=False)
         # ensure ints inside image shape
         x0, y0, x1, y1 = map(int, (x0, y0, x1, y1))
         expected = widget.main_image.image[y0:y1, x0:x1]

tests/unit_tests/test_image_view_next_gen.py

@@ -3,8 +3,8 @@ import pyqtgraph as pg
 import pytest
 from qtpy.QtCore import QPointF
 
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.plots.image.image import Image
-from tests.unit_tests.client_mocks import mocked_client
 from tests.unit_tests.conftest import create_widget
 
 ##################################################

tests/unit_tests/test_launch_window.py

@@ -8,11 +8,10 @@ from qtpy.QtGui import QFontMetrics
 
 import bec_widgets
 from bec_widgets.applications.launch_window import LaunchWindow
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.containers.auto_update.auto_updates import AutoUpdates
 from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
 
-from .client_mocks import mocked_client
-
 base_path = os.path.dirname(bec_widgets.__file__)
 
 

tests/unit_tests/test_lmfit_dialog.py

@@ -3,9 +3,9 @@ from unittest import mock
 import numpy as np
 import pytest
 
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.dap.lmfit_dialog.lmfit_dialog import LMFitDialog
 
-from .client_mocks import mocked_client
 from .conftest import create_widget
 
 

tests/unit_tests/test_logpanel.py

@@ -8,18 +8,12 @@ from unittest.mock import MagicMock, patch
 
 import pytest
 from bec_lib.messages import LogMessage
-from bec_lib.redis_connector import StreamMessage
 from qtpy.QtCore import QDateTime
 
-from bec_widgets.widgets.utility.logpanel._util import (
-    log_time,
-    replace_escapes,
-    simple_color_format,
-)
+from bec_widgets.tests.client_mocks import mocked_client
+from bec_widgets.widgets.utility.logpanel._util import replace_escapes, simple_color_format
 from bec_widgets.widgets.utility.logpanel.logpanel import DEFAULT_LOG_COLORS, LogPanel
 
-from .client_mocks import mocked_client
-
 TEST_TABLE_STRING = "2025-01-15 15:57:18 | bec_server.scan_server.scan_queue | [INFO] | \n \x1b[3m              primary queue / ScanQueueStatus.RUNNING              \x1b[0m\n┏━━━━━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━┳━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━┓\n┃\x1b[1m \x1b[0m\x1b[1m queue_id  \x1b[0m\x1b[1m \x1b[0m┃\x1b[1m \x1b[0m\x1b[1mscan_id\x1b[0m\x1b[1m \x1b[0m┃\x1b[1m \x1b[0m\x1b[1mis_scan\x1b[0m\x1b[1m \x1b[0m┃\x1b[1m \x1b[0m\x1b[1mtype\x1b[0m\x1b[1m \x1b[0m┃\x1b[1m \x1b[0m\x1b[1mscan_numb…\x1b[0m\x1b[1m \x1b[0m┃\x1b[1m \x1b[0m\x1b[1mIQ status\x1b[0m\x1b[1m \x1b[0m┃\n┡━━━━━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━╇━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━┩\n│ bbe50c82-6… │  None   │  False  │  mv  │    None    │  PENDING  │\n└─────────────┴─────────┴─────────┴──────┴────────────┴───────────┘\n\n"
 
 TEST_LOG_MESSAGES = [

tests/unit_tests/test_main_widnow.py

@@ -5,6 +5,7 @@ from qtpy.QtCore import QEvent, QPoint, QPointF
 from qtpy.QtGui import QEnterEvent
 from qtpy.QtWidgets import QApplication, QFrame, QLabel
 
+from bec_widgets.tests.client_mocks import mocked_client
 from bec_widgets.widgets.containers.main_window.addons.hover_widget import (
     HoverWidget,
     WidgetTooltip,
@@ -13,7 +14,6 @@ from bec_widgets.widgets.containers.main_window.addons.scroll_label import Scrol
 from bec_widgets.widgets.containers.main_window.addons.web_links import BECWebLinksMixin
 from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
 
-from .client_mocks import mocked_client
 from .conftest import create_widget