fix: make main() function working, to be able to test out of Qt Designer

Inheriting from QTreeWidget causes havoc with display (see #245),
also it is important to parent items OR to give them a label (weird)
otherwise it also has display glitches.

Most of the time, composition has to be preferred over inheritance ;
inheritance is a question of behaviour - is the behaviour the same ?
Here, a widget is really not a BECConnector, but uses a BECConnector
(at least this is my understanding). Because a Widget and BECConnector
do not behave the same. It is easier, lighter to deal with single
inheritance.

The singleton usage is superfluous, since the underlying client is already
a singleton. Multiple BECConnector objects can be created, there won't
be more connections.

BECServiceStatusMixin has been removed in favor of the widget's own timer,
since it was causing "QObject::killTimer: Timers cannot be stopped from
another thread" errors (at least on my computer).

Also removes "redundant items check" ; where do those would come from?

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,41 +0,0 @@
-name: Bug report
-description: File a bug report.
-title: "[BUG]: "
-labels: ["bug"]
-
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Bug report:
-  - type: textarea
-    id: description
-    attributes:
-      label: Provide a brief description of the bug.
-  - type: textarea
-    id: expected
-    attributes:
-      label: Describe what you expected to happen and what actually happened.
-  - type: textarea
-    id: reproduction
-    attributes:
-      label: Outline the steps that lead to the bug's occurrence. Be specific and provide a clear sequence of actions.
-  - type: input
-    id: version
-    attributes:
-      label: bec_widgets version
-      description: which version of BEC widgets was running?
-  - type: input
-    id: bec-version
-    attributes:
-      label: bec core version
-      description: which version of BEC core was running?
-  - type: textarea
-    id: extra
-    attributes:
-      label: Any extra info / data? e.g. log output...
-  - type: input
-    id: issues
-    attributes:
-      label: Related issues
-      description: please tag any related issues

.github/actions/bw_install/action.yml

@@ -1,64 +0,0 @@
-name: "BEC Widgets Install"
-description: "Install BEC Widgets and related os dependencies"
-inputs:
-  BEC_WIDGETS_BRANCH: # id of input
-    required: false
-    default: "main"
-    description: "Branch of BEC Widgets to install"
-  BEC_CORE_BRANCH: # id of input
-    required: false
-    default: "main"
-    description: "Branch of BEC Core to install"
-  OPHYD_DEVICES_BRANCH: # id of input
-    required: false
-    default: "main"
-    description: "Branch of Ophyd Devices to install"
-  PYTHON_VERSION: # id of input
-    required: false
-    default: "3.11"
-    description: "Python version to use"
-
-runs:
-  using: "composite"
-  steps:
-    - name: Setup Python
-      uses: actions/setup-python@v5
-      with:
-        python-version: ${{ inputs.PYTHON_VERSION }}
-
-    - name: Checkout BEC Core
-      uses: actions/checkout@v4
-      with:
-        repository: bec-project/bec
-        ref: ${{ inputs.BEC_CORE_BRANCH }}
-        path: ./bec
-
-    - name: Checkout Ophyd Devices
-      uses: actions/checkout@v4
-      with:
-        repository: bec-project/ophyd_devices
-        ref: ${{ inputs.OPHYD_DEVICES_BRANCH }}
-        path: ./ophyd_devices
-
-    - name: Checkout BEC Widgets
-      uses: actions/checkout@v4
-      with:
-        repository: bec-project/bec_widgets
-        ref: ${{ inputs.BEC_WIDGETS_BRANCH }}
-        path: ./bec_widgets
-
-    - name: Install dependencies
-      shell: bash
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y libgl1 libegl1 x11-utils libxkbcommon-x11-0 libdbus-1-3 xvfb
-        sudo apt-get -y install libnss3 libxdamage1 libasound2t64 libatomic1 libxcursor1
-
-    - name: Install Python dependencies
-      shell: bash
-      run: |
-        pip install uv
-        uv pip install --system -e ./ophyd_devices
-        uv pip install --system -e ./bec/bec_lib[dev]
-        uv pip install --system -e ./bec/bec_ipython_client
-        uv pip install --system -e ./bec_widgets[dev,pyside6]

.github/scripts/pr_issue_sync/pr_issue_sync.py

@@ -1,342 +0,0 @@
-import functools
-import os
-from typing import Literal
-
-import requests
-from github import Github
-from pydantic import BaseModel
-
-
-class GHConfig(BaseModel):
-    token: str
-    organization: str
-    repository: str
-    project_number: int
-    graphql_url: str
-    rest_url: str
-    headers: dict
-
-
-class ProjectItemHandler:
-    """
-    A class to handle GitHub project items.
-    """
-
-    def __init__(self, gh_config: GHConfig):
-        self.gh_config = gh_config
-        self.gh = Github(gh_config.token)
-        self.repo = self.gh.get_repo(f"{gh_config.organization}/{gh_config.repository}")
-        self.project_node_id = self.get_project_node_id()
-
-    def set_issue_status(
-        self,
-        status: Literal[
-            "Selected for Development",
-            "Weekly Backlog",
-            "In Development",
-            "Ready For Review",
-            "On Hold",
-            "Done",
-        ],
-        issue_number: int | None = None,
-        issue_node_id: str | None = None,
-    ):
-        """
-        Set the status field of a GitHub issue in the project.
-
-        Args:
-            status (str): The status to set. Must be one of the predefined statuses.
-            issue_number (int, optional): The issue number. If not provided, issue_node_id must be provided.
-            issue_node_id (str, optional): The issue node ID. If not provided, issue_number must be provided.
-        """
-        if not issue_number and not issue_node_id:
-            raise ValueError("Either issue_number or issue_node_id must be provided.")
-        if issue_number and issue_node_id:
-            raise ValueError("Only one of issue_number or issue_node_id must be provided.")
-        if issue_number is not None:
-            issue = self.repo.get_issue(issue_number)
-            issue_id = self.get_issue_info(issue.node_id)[0]["id"]
-        else:
-            issue_id = issue_node_id
-        field_id, option_id = self.get_status_field_id(field_name=status)
-        self.set_field_option(issue_id, field_id, option_id)
-
-    def run_graphql(self, query: str, variables: dict) -> dict:
-        """
-        Execute a GraphQL query against the GitHub API.
-
-        Args:
-            query (str): The GraphQL query to execute.
-            variables (dict): The variables to pass to the query.
-
-        Returns:
-            dict: The response from the GitHub API.
-        """
-        response = requests.post(
-            self.gh_config.graphql_url,
-            json={"query": query, "variables": variables},
-            headers=self.gh_config.headers,
-            timeout=10,
-        )
-        if response.status_code != 200:
-            raise Exception(
-                f"Query failed with status code {response.status_code}: {response.text}"
-            )
-        return response.json()
-
-    def get_project_node_id(self):
-        """
-        Retrieve the project node ID from the GitHub API.
-        """
-        query = """
-      query($owner: String!, $number: Int!) {
-        organization(login: $owner) {
-          projectV2(number: $number) {
-            id
-          }
-        }
-      }
-      """
-        variables = {"owner": self.gh_config.organization, "number": self.gh_config.project_number}
-        resp = self.run_graphql(query, variables)
-        return resp["data"]["organization"]["projectV2"]["id"]
-
-    def get_issue_info(self, issue_node_id: str):
-        """
-        Get the project-related information for a given issue node ID.
-
-        Args:
-            issue_node_id (str): The node ID of the issue. Please note that this is not the issue number and typically starts with "I".
-
-        Returns:
-            list[dict]: A list of project items associated with the issue.
-        """
-        query = """
-        query($issueId: ID!) {
-          node(id: $issueId) {
-            ... on Issue {
-              projectItems(first: 10) {
-                nodes {
-                  project {
-                    id
-                    title
-                  }
-                  id
-                  fieldValues(first: 20) {
-                    nodes {
-                      ... on ProjectV2ItemFieldSingleSelectValue {
-                        name
-                        field {
-                          ... on ProjectV2SingleSelectField {
-                            name
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-        """
-        variables = {"issueId": issue_node_id}
-        resp = self.run_graphql(query, variables)
-        return resp["data"]["node"]["projectItems"]["nodes"]
-
-    def get_status_field_id(
-        self,
-        field_name: Literal[
-            "Selected for Development",
-            "Weekly Backlog",
-            "In Development",
-            "Ready For Review",
-            "On Hold",
-            "Done",
-        ],
-    ) -> tuple[str, str]:
-        """
-        Get the status field ID and option ID for the given field name in the project.
-
-        Args:
-            field_name (str): The name of the field to retrieve.
-                Must be one of the predefined statuses.
-
-        Returns:
-            tuple[str, str]: A tuple containing the field ID and option ID.
-        """
-        field_id = None
-        option_id = None
-        project_fields = self.get_project_fields()
-        for field in project_fields:
-            if field["name"] != "Status":
-                continue
-            field_id = field["id"]
-            for option in field["options"]:
-                if option["name"] == field_name:
-                    option_id = option["id"]
-                    break
-        if not field_id or not option_id:
-            raise ValueError(f"Field '{field_name}' not found in project fields.")
-
-        return field_id, option_id
-
-    def set_field_option(self, item_id, field_id, option_id):
-        """
-        Set the option of a project item for a single-select field.
-
-        Args:
-            item_id (str): The ID of the project item to update.
-            field_id (str): The ID of the field to update.
-            option_id (str): The ID of the option to set.
-        """
-
-        mutation = """
-        mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
-          updateProjectV2ItemFieldValue(
-            input: {
-              projectId: $projectId
-              itemId: $itemId
-              fieldId: $fieldId
-              value: { singleSelectOptionId: $optionId }
-            }
-          ) {
-            projectV2Item {
-              id
-            }
-          }
-        }
-        """
-        variables = {
-            "projectId": self.project_node_id,
-            "itemId": item_id,
-            "fieldId": field_id,
-            "optionId": option_id,
-        }
-        return self.run_graphql(mutation, variables)
-
-    @functools.lru_cache(maxsize=1)
-    def get_project_fields(self) -> list[dict]:
-        """
-        Get the available fields in the project.
-        This method caches the result to avoid multiple API calls.
-
-        Returns:
-            list[dict]: A list of fields in the project.
-        """
-
-        query = """
-    query($projectId: ID!) {
-      node(id: $projectId) {
-        ... on ProjectV2 {
-          fields(first: 50) {
-            nodes {
-              ... on ProjectV2SingleSelectField {
-                id
-                name
-                options {
-                  id
-                  name
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    """
-        variables = {"projectId": self.project_node_id}
-        resp = self.run_graphql(query, variables)
-        return list(filter(bool, resp["data"]["node"]["fields"]["nodes"]))
-
-    def get_pull_request_linked_issues(self, pr_number: int) -> list[dict]:
-        """
-        Get the linked issues of a pull request.
-
-        Args:
-            pr_number (int): The pull request number.
-
-        Returns:
-            list[dict]: A list of linked issues.
-        """
-        query = """
-    query($number: Int!, $owner: String!, $repo: String!) {
-      repository(owner: $owner, name: $repo) {
-        pullRequest(number: $number) {
-          id
-          closingIssuesReferences(first: 50) {
-            edges {
-              node {
-                id
-                body
-                number
-                title
-              }
-            }
-          }
-        }
-      }
-    }
-    """
-        variables = {
-            "number": pr_number,
-            "owner": self.gh_config.organization,
-            "repo": self.gh_config.repository,
-        }
-        resp = self.run_graphql(query, variables)
-        edges = resp["data"]["repository"]["pullRequest"]["closingIssuesReferences"]["edges"]
-        return [edge["node"] for edge in edges if edge.get("node")]
-
-
-def main():
-    # GitHub settings
-    token = os.getenv("TOKEN")
-    org = os.getenv("ORG")
-    repo = os.getenv("REPO")
-    project_number = os.getenv("PROJECT_NUMBER")
-    pr_number = os.getenv("PR_NUMBER")
-
-    if not token:
-        raise ValueError("GitHub token is not set. Please set the TOKEN environment variable.")
-    if not org:
-        raise ValueError("GitHub organization is not set. Please set the ORG environment variable.")
-    if not repo:
-        raise ValueError("GitHub repository is not set. Please set the REPO environment variable.")
-    if not project_number:
-        raise ValueError(
-            "GitHub project number is not set. Please set the PROJECT_NUMBER environment variable."
-        )
-    if not pr_number:
-        raise ValueError(
-            "Pull request number is not set. Please set the PR_NUMBER environment variable."
-        )
-
-    project_number = int(project_number)
-    pr_number = int(pr_number)
-
-    gh_config = GHConfig(
-        token=token,
-        organization=org,
-        repository=repo,
-        project_number=project_number,
-        graphql_url="https://api.github.com/graphql",
-        rest_url=f"https://api.github.com/repos/{org}/{repo}/issues",
-        headers={"Authorization": f"Bearer {token}", "Accept": "application/vnd.github+json"},
-    )
-    project_item_handler = ProjectItemHandler(gh_config=gh_config)
-
-    # Get PR info
-    pr = project_item_handler.repo.get_pull(pr_number)
-
-    # Get the linked issues of the pull request
-    linked_issues = project_item_handler.get_pull_request_linked_issues(pr_number=pr_number)
-    print(f"Linked issues: {linked_issues}")
-
-    target_status = "In Development" if pr.draft else "Ready For Review"
-    print(f"Target status: {target_status}")
-    for issue in linked_issues:
-        project_item_handler.set_issue_status(issue_number=issue["number"], status=target_status)
-
-
-if __name__ == "__main__":
-    main()

.github/scripts/pr_issue_sync/requirements.txt

@@ -1,2 +0,0 @@
-pydantic
-pygithub

.github/workflows/check_pr.yml

@@ -1,28 +0,0 @@
-name: Check PR status for branch
-on:
-  workflow_call:
-    outputs:
-      branch-pr:
-        description: The PR number if the branch is in one
-        value: ${{ jobs.pr.outputs.branch-pr }}
-
-jobs:
-  pr:
-    runs-on: "ubuntu-latest"
-    outputs:
-      branch-pr: ${{ steps.script.outputs.result }}
-    steps:
-      - uses: actions/github-script@v7
-        id: script
-        if: github.event_name == 'push' && github.event.ref_type != 'tag'
-        with:
-          script: |
-            const prs = await github.rest.pulls.list({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              head: context.repo.owner + ':${{ github.ref_name }}'
-            })
-            if (prs.data.length) {
-              console.log(`::notice ::Skipping CI on branch push as it is already run in PR #${prs.data[0]["number"]}`)
-              return prs.data[0]["number"]
-            }

.github/workflows/child_repos.yml

@@ -1,64 +0,0 @@
-name: Run Pytest with Coverage
-on: 
-  workflow_call:
-    inputs:
-      BEC_CORE_BRANCH:
-        description: 'Branch for BEC Core'
-        required: false
-        default: 'main'
-        type: string
-      OPHYD_DEVICES_BRANCH:
-        description: 'Branch for Ophyd Devices'
-        required: false
-        default: 'main'
-        type: string
-      BEC_WIDGETS_BRANCH:
-        description: 'Branch for BEC Widgets'
-        required: false
-        default: 'main'
-        type: string
-
-
-jobs:
-  bec:
-    name: BEC Unit Tests
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        shell: bash -el {0}
-
-    steps:
-      - name: Checkout BEC
-        uses: actions/checkout@v4
-        with:
-          repository: bec-project/bec
-          ref: ${{ inputs.BEC_CORE_BRANCH }}
-
-      - name: Install BEC and dependencies
-        uses: ./.github/actions/bec_install
-        with:
-          BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH }}
-          OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH }}
-          PYTHON_VERSION: '3.11'
-      - name: Run Pytest
-        run: |
-          cd ./bec
-          pip install pytest pytest-random-order
-          pytest -v --maxfail=2 --junitxml=report.xml --random-order ./bec_server/tests ./bec_ipython_client/tests/client_tests ./bec_lib/tests
-  bec-e2e-test:
-    name: BEC End2End Tests
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout BEC
-        uses: actions/checkout@v4
-        with:
-          repository: bec-project/bec
-          ref: ${{ inputs.BEC_CORE_BRANCH }}
-
-      - name: Run E2E Tests
-        uses: ./.github/actions/bec_e2e_install
-        with:
-          BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH }}
-          OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH }}
-          BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH }}
-          PYTHON_VERSION: '3.11'

.github/workflows/ci.yml

@@ -1,80 +0,0 @@
-name: Full CI
-on: 
-  push:
-  pull_request:
-  workflow_dispatch:
-    inputs:
-      BEC_WIDGETS_BRANCH:
-        description: 'Branch of BEC Widgets to install'
-        required: false
-        type: string
-      BEC_CORE_BRANCH:
-        description: 'Branch of BEC Core to install'
-        required: false
-        type: string
-      OPHYD_DEVICES_BRANCH:
-        description: 'Branch of Ophyd Devices to install'
-        required: false
-        type: string
-
-permissions:
-  pull-requests: write
-
-jobs:
-  check_pr_status:
-    uses: ./.github/workflows/check_pr.yml
-
-  formatter:
-    needs: check_pr_status
-    if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: ./.github/workflows/formatter.yml
-
-  unit-test:
-    needs: [check_pr_status, formatter]
-    if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: ./.github/workflows/pytest.yml
-    with:
-      BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH || github.head_ref }}
-      BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH || 'main' }}
-      OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH || 'main' }}
-    secrets:
-      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
-
-  unit-test-matrix:
-    needs: [check_pr_status, formatter]
-    if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: ./.github/workflows/pytest-matrix.yml
-    with:
-      BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH || github.head_ref || github.sha}}
-      BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH || 'main' }}
-      OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH || 'main' }}
-
-  generate-cli-test:
-    needs: [check_pr_status, formatter]
-    if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: ./.github/workflows/generate-cli-check.yml
-
-  end2end-test:
-    needs: [check_pr_status, formatter]
-    if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: ./.github/workflows/end2end-conda.yml
-
-  child-repos:
-    needs: [check_pr_status, formatter]
-    if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: ./.github/workflows/child_repos.yml
-    with:
-      BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH || 'main' }}
-      OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH || 'main'}} 
-      BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH || github.head_ref || github.sha }}
-  
-  plugin_repos:
-    needs: [check_pr_status, formatter]
-    if: needs.check_pr_status.outputs.branch-pr == ''
-    uses: bec-project/bec/.github/workflows/plugin_repos.yml@main
-    with:
-      BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH || 'main' }}
-      BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH || github.head_ref || github.sha }}
-
-    secrets:
-      GH_READ_TOKEN: ${{ secrets.GH_READ_TOKEN }}

.github/workflows/end2end-conda.yml

@@ -1,58 +0,0 @@
-name: Run Pytest with Coverage
-on: [workflow_call]
-
-jobs:
-  pytest:
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        shell: bash -el {0}
-
-    env:
-      CHILD_PIPELINE_BRANCH: main  # Set the branch you want for ophyd_devices
-      BEC_CORE_BRANCH: main        # Set the branch you want for bec
-      OPHYD_DEVICES_BRANCH: main   # Set the branch you want for ophyd_devices
-      PLUGIN_REPO_BRANCH: main     # Set the branch you want for the plugin repo
-      PROJECT_PATH: ${{ github.repository }}
-      QTWEBENGINE_DISABLE_SANDBOX: 1
-      QT_QPA_PLATFORM: "offscreen"
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Conda
-        uses: conda-incubator/setup-miniconda@v3
-        with:
-            auto-update-conda: true
-            auto-activate-base: true
-            python-version: '3.11'
-
-      - name: Install dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libgl1 libegl1 x11-utils libxkbcommon-x11-0 libdbus-1-3 xvfb
-          sudo apt-get -y install libnss3 libxdamage1 libasound2t64 libatomic1 libxcursor1
-
-      - name: Conda install and run pytest
-        run: |
-          echo -e "\033[35;1m Using branch $BEC_CORE_BRANCH of BEC CORE \033[0;m";
-          git clone --branch $BEC_CORE_BRANCH https://github.com/bec-project/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://github.com/bec-project/ophyd_devices.git
-          export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
-          echo -e "\033[35;1m Using branch $PLUGIN_REPO_BRANCH of bec_testing_plugin \033[0;m";
-          git clone --branch $PLUGIN_REPO_BRANCH https://github.com/bec-project/bec_testing_plugin.git
-          cd ./bec
-          conda create -q -n test-environment python=3.11
-          source ./bin/install_bec_dev.sh -t
-          cd ../
-          pip install -e ./ophyd_devices -e .[dev,pyside6] -e ./bec_testing_plugin
-          pytest -v --files-path ./ --start-servers --random-order  ./tests/end-2-end
-
-      - name: Upload logs if job fails
-        if: failure()
-        uses: actions/upload-artifact@v4
-        with:
-          name: pytest-logs
-          path: ./logs/*.log
-          retention-days: 7

.github/workflows/formatter.yml

@@ -1,66 +0,0 @@
-name: Formatter and Pylint jobs
-on: [workflow_call]
-jobs:
-
-  Formatter:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check out repository code
-        uses: actions/checkout@v4
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.13' 
-
-      - name: Run black and isort
-        run: |
-          pip install uv
-          uv pip install --system black isort
-          uv pip install --system -e .[dev]
-          black --check --diff --color .
-          isort --check --diff ./
-      
-      - name: Check for disallowed imports from PySide
-        run: '! grep -re "from PySide6\." bec_widgets/ tests/ | grep  -v -e "PySide6.QtDesigner" -e "PySide6.scripts"'
-
-  Pylint:
-    runs-on: ubuntu-latest
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.13'
-
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install pylint pylint-exit anybadge
-
-      - name: Run Pylint
-        run: |
-          mkdir -p ./pylint
-          set +e
-          pylint ./${{ github.event.repository.name }} --output-format=text > ./pylint/pylint.log
-          pylint-exit $?
-          set -e
-
-      - name: Extract Pylint Score
-        id: score
-        run: |
-          SCORE=$(sed -n 's/^Your code has been rated at \([-0-9.]*\)\/.*/\1/p' ./pylint/pylint.log)
-          echo "score=$SCORE" >> $GITHUB_OUTPUT
-
-      - name: Create Badge
-        run: |
-          anybadge --label=Pylint --file=./pylint/pylint.svg --value="${{ steps.score.outputs.score }}" 2=red 4=orange 8=yellow 10=green
-
-      - name: Upload Artifacts
-        uses: actions/upload-artifact@v4
-        with:
-          name: pylint-artifacts
-          path: |
-            # ./pylint/pylint.log # not sure why this isn't working
-            ./pylint/pylint.svg

.github/workflows/generate-cli-check.yml

@@ -1,49 +0,0 @@
-name: Run bw-generate-cli
-on: [workflow_call]
-
-jobs:
-  pytest:
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        shell: bash -el {0}
-
-    env:
-      CHILD_PIPELINE_BRANCH: main  # Set the branch you want for ophyd_devices
-      BEC_CORE_BRANCH: main        # Set the branch you want for bec
-      OPHYD_DEVICES_BRANCH: main   # Set the branch you want for ophyd_devices
-      PROJECT_PATH: ${{ github.repository }}
-      QTWEBENGINE_DISABLE_SANDBOX: 1
-      QT_QPA_PLATFORM: "offscreen"
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-
-      - name: Install os dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libgl1 libegl1 x11-utils libxkbcommon-x11-0 libdbus-1-3 xvfb
-          sudo apt-get -y install libnss3 libxdamage1 libasound2t64 libatomic1 libxcursor1
-
-      - name: Clone and install dependencies
-        run: |
-            echo -e "\033[35;1m Using branch $BEC_CORE_BRANCH of BEC CORE \033[0;m";
-            git clone --branch $BEC_CORE_BRANCH https://github.com/bec-project/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://github.com/bec-project/ophyd_devices.git
-            export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
-            pip install -e ./ophyd_devices
-            pip install -e ./bec/bec_lib[dev]
-            pip install -e ./bec/bec_ipython_client
-            pip install -e .[dev,pyside6]
-
-      - name: Run bw-generate-cli
-        run: |
-            bw-generate-cli --target bec_widgets 
-            git diff --exit-code
-            

.github/workflows/pytest-matrix.yml

@@ -1,59 +0,0 @@
-name: Run Pytest with different Python versions
-on: 
-  workflow_call:
-    inputs:
-      pr_number:
-        description: 'Pull request number'
-        required: false
-        type: number
-      BEC_CORE_BRANCH:
-        description: 'Branch of BEC Core to install'
-        required: false
-        default: 'main'
-        type: string
-      OPHYD_DEVICES_BRANCH:
-        description: 'Branch of Ophyd Devices to install'
-        required: false
-        default: 'main'
-        type: string
-      BEC_WIDGETS_BRANCH:
-        description: 'Branch of BEC Widgets to install'
-        required: false
-        default: 'main'
-        type: string
-
-jobs:
-  pytest-matrix:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: ["3.11", "3.12", "3.13"]
-
-    env:
-      BEC_WIDGETS_BRANCH: main  # Set the branch you want for bec_widgets
-      BEC_CORE_BRANCH: main        # Set the branch you want for bec
-      OPHYD_DEVICES_BRANCH: main   # Set the branch you want for ophyd_devices
-      PROJECT_PATH: ${{ github.repository }}
-      QTWEBENGINE_DISABLE_SANDBOX: 1
-      QT_QPA_PLATFORM: "offscreen"
-
-    steps:
-
-      - name: Checkout BEC Widgets
-        uses: actions/checkout@v4
-        with:
-          repository: bec-project/bec_widgets
-          ref: ${{ inputs.BEC_WIDGETS_BRANCH }}
-
-      - name: Install BEC Widgets and dependencies
-        uses: ./.github/actions/bw_install
-        with:
-          BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH }}
-          BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH }}
-          OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH }}
-          PYTHON_VERSION: ${{ matrix.python-version }}
-
-      - name: Run Pytest
-        run: |
-          pip install pytest pytest-random-order
-          pytest -v --junitxml=report.xml --random-order ./tests/unit_tests

.github/workflows/pytest.yml

@@ -1,72 +0,0 @@
-name: Run Pytest with Coverage
-on: 
-  workflow_call:
-    inputs:
-      pr_number:
-        description: 'Pull request number'
-        required: false
-        type: number
-      BEC_CORE_BRANCH:
-        description: 'Branch of BEC Core to install'
-        required: false
-        default: 'main'
-        type: string
-      OPHYD_DEVICES_BRANCH:
-        description: 'Branch of Ophyd Devices to install'
-        required: false
-        default: 'main'
-        type: string
-      BEC_WIDGETS_BRANCH:
-        description: 'Branch of BEC Widgets to install'
-        required: false
-        default: 'main'
-        type: string
-    secrets:
-      CODECOV_TOKEN:
-        required: true
-
-
-
-permissions:
-  pull-requests: write
-
-jobs:
-  pytest:
-    runs-on: ubuntu-latest
-
-    env:
-      QTWEBENGINE_DISABLE_SANDBOX: 1
-      QT_QPA_PLATFORM: "offscreen"
-
-    steps:
-      - name: Checkout BEC Widgets
-        uses: actions/checkout@v4
-        with:
-          repository: bec-project/bec_widgets
-          ref: ${{ inputs.BEC_WIDGETS_BRANCH }}
-
-      - name: Install BEC Widgets and dependencies
-        uses: ./.github/actions/bw_install
-        with:
-          BEC_WIDGETS_BRANCH: ${{ inputs.BEC_WIDGETS_BRANCH }}
-          BEC_CORE_BRANCH: ${{ inputs.BEC_CORE_BRANCH }}
-          OPHYD_DEVICES_BRANCH: ${{ inputs.OPHYD_DEVICES_BRANCH }}
-          PYTHON_VERSION: 3.11
-
-      - name: Run Pytest with Coverage
-        id: coverage
-        run: pytest --random-order --cov=bec_widgets --cov-config=pyproject.toml --cov-branch --cov-report=xml --no-cov-on-fail tests/unit_tests/
-
-      - name: Upload test artifacts
-        uses: actions/upload-artifact@v4
-        if: failure()
-        with:
-          name: image-references
-          path: bec_widgets/tests/reference_failures/
-          if-no-files-found: ignore
-
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v5
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          slug: bec-project/bec_widgets

.github/workflows/semantic_release.yml

@@ -1,103 +0,0 @@
-name: Continuous Delivery
-
-on:
-  push:
-    branches:
-      - main
-
-# default: least privileged permissions across all jobs
-permissions:
-  contents: read
-
-
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    concurrency:
-      group: ${{ github.workflow }}-release-${{ github.ref_name }}
-      cancel-in-progress: false
-
-    env:
-      CHILD_PIPELINE_BRANCH: main  # Set the branch you want for ophyd_devices
-      BEC_CORE_BRANCH: main        # Set the branch you want for bec
-      OPHYD_DEVICES_BRANCH: main   # Set the branch you want for ophyd_devices
-      PROJECT_PATH: ${{ github.repository }}
-      QTWEBENGINE_DISABLE_SANDBOX: 1
-      QT_QPA_PLATFORM: "offscreen"
-
-    permissions:
-      contents: write
-
-    steps:
-      # Note: We checkout the repository at the branch that triggered the workflow
-      # with the entire history to ensure to match PSR's release branch detection
-      # and history evaluation.
-      # However, we forcefully reset the branch to the workflow sha because it is
-      # possible that the branch was updated while the workflow was running. This
-      # prevents accidentally releasing un-evaluated changes.
-      - name: Setup | Checkout Repository on Release Branch
-        uses: actions/checkout@v4
-        with:
-          ref: ${{ github.ref_name }}
-          fetch-depth: 0
-          ssh-key: ${{ secrets.CI_DEPLOY_SSH_KEY }}
-          ssh-known-hosts: ${{ secrets.CI_DEPLOY_SSH_KNOWN_HOSTS }}
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.11'
-
-      - name: Setup | Force release branch to be at workflow sha
-        run: |
-          git reset --hard ${{ github.sha }}
-      - name: Evaluate | Verify upstream has NOT changed
-        # Last chance to abort before causing an error as another PR/push was applied to
-        # the upstream branch while this workflow was running. This is important
-        # because we are committing a version change (--commit). You may omit this step
-        # if you have 'commit: false' in your configuration.
-        #
-        # You may consider moving this to a repo script and call it from this step instead
-        # of writing it in-line.
-        shell: bash
-        run: |
-          set +o pipefail
-
-          UPSTREAM_BRANCH_NAME="$(git status -sb | head -n 1 | cut -d' ' -f2 | grep -E '\.{3}' | cut -d'.' -f4)"
-          printf '%s\n' "Upstream branch name: $UPSTREAM_BRANCH_NAME"
-
-          set -o pipefail
-
-          if [ -z "$UPSTREAM_BRANCH_NAME" ]; then
-              printf >&2 '%s\n' "::error::Unable to determine upstream branch name!"
-              exit 1
-          fi
-
-          git fetch "${UPSTREAM_BRANCH_NAME%%/*}"
-
-          if ! UPSTREAM_SHA="$(git rev-parse "$UPSTREAM_BRANCH_NAME")"; then
-              printf >&2 '%s\n' "::error::Unable to determine upstream branch sha!"
-              exit 1
-          fi
-
-          HEAD_SHA="$(git rev-parse HEAD)"
-
-          if [ "$HEAD_SHA" != "$UPSTREAM_SHA" ]; then
-              printf >&2 '%s\n' "[HEAD SHA] $HEAD_SHA != $UPSTREAM_SHA [UPSTREAM SHA]"
-              printf >&2 '%s\n' "::error::Upstream has changed, aborting release..."
-              exit 1
-          fi
-
-          printf '%s\n' "Verified upstream branch has not changed, continuing with release..."
-
-      - name: Semantic Version Release
-        id: release
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: |
-          pip install python-semantic-release==9.* wheel build twine
-          semantic-release -vv version
-          if [ ! -d dist ]; then echo No release will be made; exit 0; fi
-          twine upload dist/* -u __token__ -p ${{ secrets.CI_PYPI_TOKEN }} --skip-existing
-          semantic-release publish

.github/workflows/stale-issues.yml

@@ -1,19 +0,0 @@
-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:
-          stale-issue-message: 'This issue is stale because it has been open 60 days with no activity. Remove stale label or comment or this will be closed in 7 days.'
-          stale-pr-message: 'This PR is stale because it has been open 60 days with no activity. Remove stale label or comment or this will be closed in 7 days.'
-          days-before-stale: 60
-          days-before-close: 7

.github/workflows/sync-issues-pr.yml

@@ -1,40 +0,0 @@
-name: Sync PR to Project
-
-on:
-  pull_request:
-    types: [opened, edited, ready_for_review, converted_to_draft, reopened, synchronize]
-
-jobs:
-  sync-project:
-    runs-on: ubuntu-latest
-
-    permissions:
-      issues: write
-      pull-requests: read
-      contents: read
-
-    env:
-        PROJECT_NUMBER: 3 # BEC Project
-        ORG: 'bec-project'
-        REPO: 'bec_widgets'
-        TOKEN: ${{ secrets.ADD_ISSUE_TO_PROJECT }}
-        PR_NUMBER: ${{ github.event.pull_request.number }}
-
-    steps:
-      - name: Set up python environment
-        uses: actions/setup-python@v4
-        with:
-          python-version: 3.11
-
-      - name: Checkout repo
-        uses: actions/checkout@v4
-        with:
-          repository: ${{ github.repository }}
-          ref: ${{ github.event.pull_request.head.ref }}
-
-      - name: Install dependencies
-        run: |
-          pip install -r ./.github/scripts/pr_issue_sync/requirements.txt
-      - name: Sync PR to Project
-        run: |
-          python ./.github/scripts/pr_issue_sync/pr_issue_sync.py

.gitignore

@@ -64,9 +64,6 @@ coverage.xml
 .pytest_cache/
 cover/
 
-# Output from end2end testing
-tests/reference_failures/
-
 # Translations
 *.mo
 *.pot

.gitlab-ci.yml

@@ -0,0 +1,257 @@
+# 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: "main"
+  OPHYD_DEVICES_BRANCH: "main"
+  CHILD_PIPELINE_BRANCH: $CI_DEFAULT_BRANCH
+
+workflow:
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "schedule"
+    - if: $CI_PIPELINE_SOURCE == "web"
+    - if: $CI_PIPELINE_SOURCE == "pipeline"
+    - if: $CI_PIPELINE_SOURCE == "parent_pipeline"
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+    - if: $CI_COMMIT_BRANCH && $CI_OPEN_MERGE_REQUESTS
+      when: never
+    - if: $CI_COMMIT_BRANCH
+
+include:
+  - template: Security/Secret-Detection.gitlab-ci.yml
+  - project: "bec/awi_utils"
+    file: "/templates/check-packages-job.yml"
+    inputs:
+      stage: test
+      path: "."
+      pytest_args: "-v --random-order tests/"
+      exclude_packages: ""
+
+# different stages in the pipeline
+stages:
+  - Formatter
+  - test
+  - AdditionalTests
+  - End2End
+  - Deploy
+
+.install-qt-webengine-deps: &install-qt-webengine-deps
+  - apt-get -y install libnss3 libxdamage1 libasound2 libatomic1 libxcursor1
+  - export QTWEBENGINE_DISABLE_SANDBOX=1
+
+.clone-repos: &clone-repos
+  - git clone --branch $BEC_CORE_BRANCH https://gitlab.psi.ch/bec/bec.git
+  - git clone --branch $OPHYD_DEVICES_BRANCH https://gitlab.psi.ch/bec/ophyd_devices.git
+  - export OHPYD_DEVICES_PATH=$PWD/ophyd_devices
+
+.install-os-packages: &install-os-packages
+  - apt-get update
+  - apt-get install -y libgl1-mesa-glx libegl1-mesa x11-utils libxkbcommon-x11-0 libdbus-1-3
+  - *install-qt-webengine-deps
+
+before_script:
+  - if [[ "$CI_PROJECT_PATH" != "bec/bec_widgets" ]]; then
+    echo -e "\033[35;1m Using branch $CHILD_PIPELINE_BRANCH of BEC Widgets \033[0;m";
+    test -d bec_widgets || git clone --branch $CHILD_PIPELINE_BRANCH https://gitlab.psi.ch/bec/bec_widgets.git; cd bec_widgets;
+    fi
+
+formatter:
+  stage: Formatter
+  needs: []
+  script:
+    - pip install black isort
+    - isort --check --diff ./
+    - black --check --diff --color ./
+  rules:
+    - if: $CI_PROJECT_PATH == "bec/bec_widgets"
+
+pylint:
+  stage: Formatter
+  needs: []
+  before_script:
+    - pip install pylint pylint-exit anybadge
+    - pip install -e .[dev,pyqt6]
+  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
+    - pip install -e ./bec/bec_lib[dev]
+    - pip install -e ./bec/bec_ipython_client
+    - pip install -e .[dev,pyqt6]
+    - coverage run --source=./bec_widgets -m pytest -v --junitxml=report.xml --random-order --full-trace ./tests/unit_tests
+    - 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
+
+test-matrix:
+  parallel:
+    matrix:
+      - PYTHON_VERSION:
+          - "3.10"
+          - "3.11"
+          - "3.12"
+        QT_PCKG:
+          - "pyside6"
+          - "pyqt5"
+          - "pyqt6"
+
+  stage: AdditionalTests
+  needs: []
+  variables:
+    QT_QPA_PLATFORM: "offscreen"
+    PYTHON_VERSION: ""
+    QT_PCKG: ""
+  image: $CI_DEPENDENCY_PROXY_GROUP_IMAGE_PREFIX/python:$PYTHON_VERSION
+  script:
+    - *clone-repos
+    - *install-os-packages
+    - pip install -e ./bec/bec_lib[dev]
+    - pip install -e ./bec/bec_ipython_client
+    - pip install -e .[dev,$QT_PCKG]
+    - pytest -v --junitxml=report.xml --random-order ./tests/unit_tests
+  allow_failure: true
+
+end-2-end-conda:
+  stage: End2End
+  needs: []
+  image: continuumio/miniconda3
+  allow_failure: false
+  variables:
+    QT_QPA_PLATFORM: "offscreen"
+  script:
+    - *clone-repos
+    - *install-os-packages
+    - conda config --prepend channels conda-forge
+    - conda config --set channel_priority strict
+    - conda config --set always_yes yes --set changeps1 no
+    - conda create -q -n test-environment python=3.11
+    - conda init bash
+    - source ~/.bashrc
+    - conda activate test-environment
+
+    - cd ./bec
+    - source ./bin/install_bec_dev.sh -t
+
+    - pip install -e ./bec_lib[dev]
+    - pip install -e ./bec_ipython_client[dev]
+    - cd ../
+    - pip install -e .[dev,pyqt6]
+    - cd ./tests/end-2-end
+    - pytest -v --start-servers --flush-redis --random-order
+
+  artifacts:
+    when: on_failure
+    paths:
+      - ./logs/*.log
+    expire_in: 1 week
+
+  rules:
+    - if: '$CI_PIPELINE_SOURCE == "schedule"'
+    - if: '$CI_PIPELINE_SOURCE == "web"'
+    - if: '$CI_PIPELINE_SOURCE == "pipeline"'
+    - if: '$CI_PIPELINE_SOURCE == "parent_pipeline"'
+    - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "main"'
+    - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "production"'
+
+semver:
+  stage: Deploy
+  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/

.gitlab/issue_templates/bug_report_template.md

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

.gitlab/issue_templates/documentation_update_template.md

@@ -1,13 +1,3 @@
----
-name: Documentation update request
-about: Suggest an update to the docs
-title: '[DOCS]: '
-type: documentation
-label: documentation
-assignees: ''
-
----
-
 ## Documentation Section
 
 [Specify the section or page of the documentation that needs updating]

.gitlab/issue_templates/feature_request_template.md

@@ -1,13 +1,3 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: '[FEAT]: '
-type: feature
-label: feature
-assignees: ''
-
----
-
 ## Feature Summary
 
 [Provide a brief and clear summary of the new feature you are requesting]
@@ -47,3 +37,4 @@ assignees: ''
 ## Additional Information
 
 [Provide any additional information that might be relevant to the feature request, such as user feedback, market trends, or similar features in other products]
+

.gitlab/merge_request_templates/default.md

@@ -1,24 +1,19 @@
 ## Description
 
-[Provide a brief description of the changes introduced by this pull request.]
+[Provide a brief description of the changes introduced by this merge request.]
 
 ## Related Issues
 
-[Cite any related issues or feature requests that are addressed or resolved by this pull request. Link the associated issue, for example, with `fixes #123` or `closes #123`.]
+[Cite any related issues or feature requests that are addressed or resolved by this merge request. Use the gitlab syntax for linking issues, for example, `fixes #123` or `closes #123`.]
 
 ## Type of Change
 
 - Change 1
 - Change 2
 
-## How to test
-
-- Run unit tests
-- Open [widget] in designer and play around with the properties
-
 ## Potential side effects
 
-[Describe any potential side effects or risks of merging this PR.]
+[Describe any potential side effects or risks of merging this MR.]
 
 ## Screenshots / GIFs (if applicable)
 

.pylintrc

@@ -3,7 +3,7 @@
 # A comma-separated list of package or module names from where C extensions may
 # be loaded. Extensions are loading into the active Python interpreter and may
 # run arbitrary code.
-extension-pkg-allow-list=PyQt6, PySide6, pyqtgraph
+extension-pkg-allow-list=PyQt5, pyqtgraph
 
 # A comma-separated list of package or module names from where C extensions may
 # be loaded. Extensions are loading into the active Python interpreter and may
@@ -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.11
+py-version=3.10
 
 # When enabled, pylint would attempt to guess common misconfiguration and emit
 # user-friendly hints instead of false-positive error messages.

.readthedocs.yaml

@@ -7,13 +7,13 @@ version: 2
 
 # Set the version of Python and other tools you might need
 build:
-  os: ubuntu-22.04
+  os: ubuntu-20.04
   tools:
-    python: "3.11"
+    python: "3.10"
 
 # Build documentation in the docs/ directory with Sphinx
 sphinx:
-  configuration: docs/conf.py
+   configuration: docs/conf.py
 
 # If using Sphinx, optionally build your docs in additional formats such as PDF
 # formats:
@@ -21,7 +21,5 @@ sphinx:
 
 # Optionally declare the Python requirements required to build your docs
 python:
-  install:
-    - requirements: docs/requirements.txt
-    - method: pip
-      path: .[dev]
+   install:
+   - requirements: docs/requirements.txt

LICENSE

@@ -1,6 +1,6 @@
 BSD 3-Clause License
 
-Copyright (c) 2025, Paul Scherrer Institute
+Copyright (c) 2023, bec
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

README.md

@@ -1,28 +1,12 @@
 # BEC Widgets
 
-
-[![CI](https://github.com/bec-project/bec_widgets/actions/workflows/ci.yml/badge.svg)](https://github.com/bec-project/bec_widgets/actions/workflows/ci.yml)
-[![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.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)
-
-
-**⚠️ Important Notice:**
-
-🚨 **PyQt6 is no longer supported** due to incompatibilities with Qt Designer. Please use **PySide6** instead. 🚨
-
 BEC Widgets is a GUI framework designed for interaction with [BEC (Beamline Experiment Control)](https://gitlab.psi.ch/bec/bec).
-
 ## Installation
 
 Use the package manager [pip](https://pip.pypa.io/en/stable/) to install BEC Widgets:
 
 ```bash
-pip install bec_widgets[pyside6]
+pip install bec_widgets PyQt6
 ```
 
 For development purposes, you can clone the repository and install the package locally in editable mode:
@@ -30,12 +14,22 @@ For development purposes, you can clone the repository and install the package l
 ```bash
 git clone https://gitlab.psi.ch/bec/bec-widgets
 cd bec_widgets
-pip install -e .[dev,pyside6]
+pip install -e .[dev,pyqt6]
 ```
 
-BEC Widgets now **only supports PySide6**. Users must manually install PySide6 as no default Qt distribution is
-specified.
+BEC Widgets currently supports both PyQt5 and PyQt6, however, no default distribution is specified. As a result, users must install one of the supported
+Python Qt distributions manually.
 
+To select a specific Python Qt distribution, install the package with an additional tag:
+
+```bash
+pip install bec_widgets[pyqt6]
+```
+or 
+
+```bash
+pip install bec_widgets[pyqt5]
+```
 ## Documentation
 
 Documentation of BEC Widgets can be found [here](https://bec-widgets.readthedocs.io/en/latest/). The documentation of the BEC can be found [here](https://bec.readthedocs.io/en/latest/).
@@ -45,7 +39,7 @@ Documentation of BEC Widgets can be found [here](https://bec-widgets.readthedocs
 All commits should use the Angular commit scheme:
 
 > #### <a name="commit-header"></a>Angular Commit Message Header
->
+> 
 > ```
 > <type>(<scope>): <short summary>
 >   │       │             │
@@ -59,13 +53,13 @@ All commits should use the Angular commit scheme:
 >   │
 >   └─⫸ Commit Type: build|ci|docs|feat|fix|perf|refactor|test
 > ```
->
+> 
 > The `<type>` and `<summary>` fields are mandatory, the `(<scope>)` field is optional.
 
 > ##### Type
->
+> 
 > Must be one of the following:
->
+> 
 > * **build**: Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)
 > * **ci**: Changes to our CI configuration files and scripts (examples: CircleCi, SauceLabs)
 > * **docs**: Documentation only changes
@@ -77,5 +71,4 @@ All commits should use the Angular commit scheme:
 
 ## License
 
-[BSD-3-Clause](https://choosealicense.com/licenses/bsd-3-clause/)
-
+[BSD-3-Clause](https://choosealicense.com/licenses/bsd-3-clause/)

bec_widgets/__init__.py

@@ -1,20 +0,0 @@
-import os
-import sys
-
-import PySide6QtAds as QtAds
-
-from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
-
-if sys.platform.startswith("linux"):
-    qt_platform = os.environ.get("QT_QPA_PLATFORM", "")
-    if qt_platform != "offscreen":
-        os.environ["QT_QPA_PLATFORM"] = "xcb"
-
-# Default QtAds configuration
-QtAds.CDockManager.setConfigFlag(QtAds.CDockManager.eConfigFlag.FocusHighlighting, True)
-QtAds.CDockManager.setConfigFlag(
-    QtAds.CDockManager.eConfigFlag.RetainTabSizeWhenCloseButtonHidden, True
-)
-
-__all__ = ["BECWidget", "SafeSlot", "SafeProperty"]

bec_widgets/applications/bw_launch.py

@@ -1,23 +0,0 @@
-from __future__ import annotations
-
-from bec_widgets.widgets.containers.auto_update.auto_updates import AutoUpdates
-from bec_widgets.widgets.containers.dock.dock_area import BECDockArea
-
-
-def dock_area(object_name: str | None = None) -> BECDockArea:
-    _dock_area = BECDockArea(object_name=object_name, root_widget=True)
-    return _dock_area
-
-
-def auto_update_dock_area(object_name: str | None = None) -> AutoUpdates:
-    """
-    Create a dock area with auto update enabled.
-
-    Args:
-        object_name(str): The name of the dock area.
-
-    Returns:
-        BECDockArea: The created dock area.
-    """
-    _auto_update = AutoUpdates(object_name=object_name)
-    return _auto_update

bec_widgets/applications/launch_window.py

@@ -1,590 +0,0 @@
-from __future__ import annotations
-
-import os
-import xml.etree.ElementTree as ET
-from typing import TYPE_CHECKING, Callable
-
-from bec_lib.logger import bec_logger
-from qtpy.QtCore import Qt, Signal  # type: ignore
-from qtpy.QtGui import QFontMetrics, QPainter, QPainterPath, QPixmap
-from qtpy.QtWidgets import (
-    QApplication,
-    QComboBox,
-    QFileDialog,
-    QHBoxLayout,
-    QLabel,
-    QPushButton,
-    QSizePolicy,
-    QSpacerItem,
-    QWidget,
-)
-
-import bec_widgets
-from bec_widgets.cli.rpc.rpc_register import RPCRegister
-from bec_widgets.utils.bec_plugin_helper import get_all_plugin_widgets
-from bec_widgets.utils.container_utils import WidgetContainerUtils
-from bec_widgets.utils.error_popups import SafeSlot
-from bec_widgets.utils.name_utils import pascal_to_snake
-from bec_widgets.utils.plugin_utils import get_plugin_auto_updates
-from bec_widgets.utils.round_frame import RoundedFrame
-from bec_widgets.utils.toolbars.toolbar import ModularToolBar
-from bec_widgets.utils.ui_loader import UILoader
-from bec_widgets.widgets.containers.auto_update.auto_updates import AutoUpdates
-from bec_widgets.widgets.containers.dock.dock_area import BECDockArea
-from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow, BECMainWindowNoRPC
-from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
-
-if TYPE_CHECKING:  # pragma: no cover
-    from qtpy.QtCore import QObject
-
-    from bec_widgets.utils.bec_widget import BECWidget
-
-logger = bec_logger.logger
-MODULE_PATH = os.path.dirname(bec_widgets.__file__)
-
-
-class LaunchTile(RoundedFrame):
-    DEFAULT_SIZE = (250, 300)
-    open_signal = Signal()
-
-    def __init__(
-        self,
-        parent: QObject | None = None,
-        icon_path: str | None = None,
-        top_label: str | None = None,
-        main_label: str | None = None,
-        description: str | None = None,
-        show_selector: bool = False,
-        tile_size: tuple[int, int] | None = None,
-    ):
-        super().__init__(parent=parent, orientation="vertical")
-
-        # Provide a per‑instance TILE_SIZE so the class can compute layout
-        if tile_size is None:
-            tile_size = self.DEFAULT_SIZE
-        self.tile_size = tile_size
-
-        self.icon_label = QLabel(parent=self)
-        self.icon_label.setFixedSize(100, 100)
-        self.icon_label.setScaledContents(True)
-        pixmap = QPixmap(icon_path)
-        if not pixmap.isNull():
-            size = 100
-            circular_pixmap = QPixmap(size, size)
-            circular_pixmap.fill(Qt.transparent)
-
-            painter = QPainter(circular_pixmap)
-            painter.setRenderHints(QPainter.Antialiasing, True)
-            path = QPainterPath()
-            path.addEllipse(0, 0, size, size)
-            painter.setClipPath(path)
-            pixmap = pixmap.scaled(size, size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
-            painter.drawPixmap(0, 0, pixmap)
-            painter.end()
-
-            self.icon_label.setPixmap(circular_pixmap)
-        self.layout.addWidget(self.icon_label, alignment=Qt.AlignCenter)
-
-        # Top label
-        self.top_label = QLabel(top_label.upper())
-        font_top = self.top_label.font()
-        font_top.setPointSize(10)
-        self.top_label.setFont(font_top)
-        self.layout.addWidget(self.top_label, alignment=Qt.AlignCenter)
-
-        # Main label
-        self.main_label = QLabel(main_label)
-
-        # Desired default appearance
-        font_main = self.main_label.font()
-        font_main.setPointSize(14)
-        font_main.setBold(True)
-        self.main_label.setFont(font_main)
-        self.main_label.setAlignment(Qt.AlignCenter)
-
-        # Shrink font if the default would wrap on this platform / DPI
-        content_width = (
-            self.tile_size[0]
-            - self.layout.contentsMargins().left()
-            - self.layout.contentsMargins().right()
-        )
-        self._fit_label_to_width(self.main_label, content_width)
-
-        # Give every tile the same reserved height for the title so the
-        # description labels start at an identical y‑offset.
-        self.main_label.setFixedHeight(QFontMetrics(self.main_label.font()).height() + 2)
-
-        self.layout.addWidget(self.main_label)
-
-        self.spacer_top = QSpacerItem(0, 10, QSizePolicy.Fixed, QSizePolicy.Fixed)
-        self.layout.addItem(self.spacer_top)
-
-        # Description
-        self.description_label = QLabel(description)
-        self.description_label.setWordWrap(True)
-        self.description_label.setAlignment(Qt.AlignCenter)
-        self.layout.addWidget(self.description_label)
-
-        # Selector
-        if show_selector:
-            self.selector = QComboBox(self)
-            self.layout.addWidget(self.selector)
-        else:
-            self.selector = None
-
-        self.spacer_bottom = QSpacerItem(0, 0, QSizePolicy.Fixed, QSizePolicy.Expanding)
-        self.layout.addItem(self.spacer_bottom)
-
-        # Action button
-        self.action_button = QPushButton("Open")
-        self.action_button.setStyleSheet(
-            """
-        QPushButton {
-            background-color: #007AFF;
-            border: none;
-            padding: 8px 16px;
-            color: white;
-            border-radius: 6px;
-            font-weight: bold;
-        }
-        QPushButton:hover {
-            background-color: #005BB5;
-        }
-        """
-        )
-        self.layout.addWidget(self.action_button, alignment=Qt.AlignCenter)
-
-    def _fit_label_to_width(self, label: QLabel, max_width: int, min_pt: int = 10):
-        """
-        Fit the label text to the specified maximum width by adjusting the font size.
-
-        Args:
-            label(QLabel): The label to adjust.
-            max_width(int): The maximum width the label can occupy.
-            min_pt(int): The minimum font point size to use.
-        """
-        font = label.font()
-        for pt in range(font.pointSize(), min_pt - 1, -1):
-            font.setPointSize(pt)
-            metrics = QFontMetrics(font)
-            if metrics.horizontalAdvance(label.text()) <= max_width:
-                label.setFont(font)
-                label.setWordWrap(False)
-                return
-        # If nothing fits, fall back to eliding
-        metrics = QFontMetrics(font)
-        label.setFont(font)
-        label.setWordWrap(False)
-        label.setText(metrics.elidedText(label.text(), Qt.ElideRight, max_width))
-
-
-class LaunchWindow(BECMainWindow):
-    RPC = True
-    TILE_SIZE = (250, 300)
-    USER_ACCESS = ["show_launcher", "hide_launcher"]
-
-    def __init__(
-        self, parent=None, gui_id: str = None, window_title="BEC Launcher", *args, **kwargs
-    ):
-        super().__init__(parent=parent, gui_id=gui_id, window_title=window_title, **kwargs)
-
-        self.app = QApplication.instance()
-        self.tiles: dict[str, LaunchTile] = {}
-        # Track the smallest main‑label font size chosen so far
-        self._min_main_label_pt: int | None = None
-
-        # Toolbar
-        self.dark_mode_button = DarkModeButton(parent=self, toolbar=True)
-        self.toolbar = ModularToolBar(parent=self)
-        self.addToolBar(Qt.TopToolBarArea, self.toolbar)
-        self.spacer = QWidget(self)
-        self.spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-        self.toolbar.addWidget(self.spacer)
-        self.toolbar.addWidget(self.dark_mode_button)
-
-        # Main Widget
-        self.central_widget = QWidget(self)
-        self.central_widget.layout = QHBoxLayout(self.central_widget)
-        self.setCentralWidget(self.central_widget)
-
-        self.register_tile(
-            name="dock_area",
-            icon_path=os.path.join(MODULE_PATH, "assets", "app_icons", "bec_widgets_icon.png"),
-            top_label="Get started",
-            main_label="BEC Dock Area",
-            description="Highly flexible and customizable dock area application with modular widgets.",
-            action_button=lambda: self.launch("dock_area"),
-            show_selector=False,
-        )
-
-        self.available_auto_updates: dict[str, type[AutoUpdates]] = (
-            self._update_available_auto_updates()
-        )
-        self.register_tile(
-            name="auto_update",
-            icon_path=os.path.join(MODULE_PATH, "assets", "app_icons", "auto_update.png"),
-            top_label="Get automated",
-            main_label="BEC Auto Update Dock Area",
-            description="Dock area with auto update functionality for BEC widgets plotting.",
-            action_button=self._open_auto_update,
-            show_selector=True,
-            selector_items=list(self.available_auto_updates.keys()) + ["Default"],
-        )
-
-        self.register_tile(
-            name="custom_ui_file",
-            icon_path=os.path.join(MODULE_PATH, "assets", "app_icons", "ui_loader_tile.png"),
-            top_label="Get customized",
-            main_label="Launch Custom UI File",
-            description="GUI application with custom UI file.",
-            action_button=self._open_custom_ui_file,
-            show_selector=False,
-        )
-
-        # plugin widgets
-        self.available_widgets: dict[str, type[BECWidget]] = get_all_plugin_widgets().as_dict()
-        if self.available_widgets:
-            plugin_repo_name = next(iter(self.available_widgets.values())).__module__.split(".")[0]
-            plugin_repo_name = plugin_repo_name.removesuffix("_bec").upper()
-            self.register_tile(
-                name="widget",
-                icon_path=os.path.join(
-                    MODULE_PATH, "assets", "app_icons", "widget_launch_tile.png"
-                ),
-                top_label="Get quickly started",
-                main_label=f"Launch a {plugin_repo_name} Widget",
-                description=f"GUI application with one widget from the {plugin_repo_name} repository.",
-                action_button=self._open_widget,
-                show_selector=True,
-                selector_items=list(self.available_widgets.keys()),
-            )
-
-        self._update_theme()
-
-        self.register = RPCRegister()
-        self.register.callbacks.append(self._turn_off_the_lights)
-        self.register.broadcast()
-
-    def register_tile(
-        self,
-        name: str,
-        icon_path: str | None = None,
-        top_label: str | None = None,
-        main_label: str | None = None,
-        description: str | None = None,
-        action_button: Callable | None = None,
-        show_selector: bool = False,
-        selector_items: list[str] | None = None,
-    ):
-        """
-        Register a tile in the launcher window.
-
-        Args:
-            name(str): The name of the tile.
-            icon_path(str): The path to the icon.
-            top_label(str): The top label of the tile.
-            main_label(str): The main label of the tile.
-            description(str): The description of the tile.
-            action_button(callable): The action to be performed when the button is clicked.
-            show_selector(bool): Whether to show a selector or not.
-            selector_items(list[str]): The items to be shown in the selector.
-        """
-
-        tile = LaunchTile(
-            icon_path=icon_path,
-            top_label=top_label,
-            main_label=main_label,
-            description=description,
-            show_selector=show_selector,
-            tile_size=self.TILE_SIZE,
-        )
-        tile.setFixedWidth(self.TILE_SIZE[0])
-        tile.setMinimumHeight(self.TILE_SIZE[1])
-        tile.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.MinimumExpanding)
-        if action_button:
-            tile.action_button.clicked.connect(action_button)
-        if show_selector and selector_items:
-            tile.selector.addItems(selector_items)
-        self.central_widget.layout.addWidget(tile)
-
-        # keep all tiles' main labels at a unified point size
-        current_pt = tile.main_label.font().pointSize()
-        if self._min_main_label_pt is None or current_pt < self._min_main_label_pt:
-            # New global minimum – shrink every existing tile to this size
-            self._min_main_label_pt = current_pt
-            for t in self.tiles.values():
-                f = t.main_label.font()
-                f.setPointSize(self._min_main_label_pt)
-                t.main_label.setFont(f)
-                t.main_label.setFixedHeight(QFontMetrics(f).height() + 2)
-        elif current_pt > self._min_main_label_pt:
-            # Tile is larger than global minimum – shrink it to match
-            f = tile.main_label.font()
-            f.setPointSize(self._min_main_label_pt)
-            tile.main_label.setFont(f)
-            tile.main_label.setFixedHeight(QFontMetrics(f).height() + 2)
-
-        self.tiles[name] = tile
-
-    def launch(
-        self,
-        launch_script: str,
-        name: str | None = None,
-        geometry: tuple[int, int, int, int] | None = None,
-        **kwargs,
-    ) -> QWidget | None:
-        """Launch the specified script. If the launch script creates a QWidget, it will be
-        embedded in a BECMainWindow. If the launch script creates a BECMainWindow, it will be shown
-        as a separate window.
-
-        Args:
-            launch_script(str): The name of the script to be launched.
-            name(str): The name of the dock area.
-            geometry(tuple): The geometry parameters to be passed to the dock area.
-        Returns:
-            QWidget: The created dock area.
-        """
-        from bec_widgets.applications import bw_launch
-
-        with RPCRegister.delayed_broadcast() as rpc_register:
-            existing_dock_areas = rpc_register.get_names_of_rpc_by_class_type(BECDockArea)
-            if name is not None:
-                if name in existing_dock_areas:
-                    raise ValueError(
-                        f"Name {name} must be unique for dock areas, but already exists: {existing_dock_areas}."
-                    )
-                WidgetContainerUtils.raise_for_invalid_name(name)
-
-            else:
-                name = "dock_area"
-                name = WidgetContainerUtils.generate_unique_name(name, existing_dock_areas)
-
-            if launch_script is None:
-                launch_script = "dock_area"
-            if not isinstance(launch_script, str):
-                raise ValueError(f"Launch script must be a string, but got {type(launch_script)}.")
-
-            if launch_script == "custom_ui_file":
-                ui_file = kwargs.pop("ui_file", None)
-                if not ui_file:
-                    return None
-                return self._launch_custom_ui_file(ui_file)
-
-            if launch_script == "auto_update":
-                auto_update = kwargs.pop("auto_update", None)
-                return self._launch_auto_update(auto_update)
-
-            if launch_script == "widget":
-                widget = kwargs.pop("widget", None)
-                if widget is None:
-                    raise ValueError("Widget name must be provided.")
-                return self._launch_widget(widget)
-
-            launch = getattr(bw_launch, launch_script, None)
-            if launch is None:
-                raise ValueError(f"Launch script {launch_script} not found.")
-
-            result_widget = launch(name)
-            result_widget.resize(result_widget.minimumSizeHint())
-            # TODO Should we simply use the specified name as title here?
-            result_widget.window().setWindowTitle(f"BEC - {name}")
-            logger.info(f"Created new dock area: {name}")
-
-            if geometry is not None:
-                result_widget.setGeometry(*geometry)
-            if isinstance(result_widget, BECMainWindow):
-                result_widget.show()
-            else:
-                window = BECMainWindowNoRPC()
-                window.setCentralWidget(result_widget)
-                window.setWindowTitle(f"BEC - {result_widget.objectName()}")
-                window.show()
-            return result_widget
-
-    def _launch_custom_ui_file(self, ui_file: str | None) -> BECMainWindow:
-        """
-        Load a custom .ui file. If the top-level widget is a MainWindow subclass,
-        instantiate it directly; otherwise, embed it in a UILaunchWindow.
-        """
-        if ui_file is None:
-            raise ValueError("UI file must be provided for custom UI file launch.")
-        filename = os.path.basename(ui_file).split(".")[0]
-
-        WidgetContainerUtils.raise_for_invalid_name(filename)
-
-        # Parse the UI to detect top-level widget class
-        tree = ET.parse(ui_file)
-        root = tree.getroot()
-        # Check if the top-level widget is a QMainWindow
-        widget = root.find("widget")
-        if widget is None:
-            raise ValueError("No widget found in the UI file.")
-
-        # Load the UI into a widget
-        loader = UILoader(None)
-        loaded = loader.loader(ui_file)
-
-        # Display the UI in a BECMainWindow
-        if isinstance(loaded, BECMainWindow):
-            window = loaded
-            window.object_name = filename
-        else:
-            window = BECMainWindow(object_name=filename)
-            window.setCentralWidget(loaded)
-
-        QApplication.processEvents()
-        window.setWindowTitle(f"BEC - {filename}")
-        window.show()
-        logger.info(f"Launched custom UI: {filename}, type: {type(window).__name__}")
-        return window
-
-    def _launch_auto_update(self, auto_update: str) -> AutoUpdates:
-        if auto_update in self.available_auto_updates:
-            auto_update_cls = self.available_auto_updates[auto_update]
-            window = auto_update_cls()
-        else:
-
-            auto_update = "auto_updates"
-            window = AutoUpdates()
-
-        window.resize(window.minimumSizeHint())
-        QApplication.processEvents()
-        window.setWindowTitle(f"BEC - {window.objectName()}")
-        window.show()
-        return window
-
-    def _launch_widget(self, widget: type[BECWidget]) -> QWidget:
-        name = pascal_to_snake(widget.__name__)
-
-        WidgetContainerUtils.raise_for_invalid_name(name)
-
-        window = BECMainWindowNoRPC()
-
-        widget_instance = widget(root_widget=True, object_name=name)
-        assert isinstance(widget_instance, QWidget)
-        QApplication.processEvents()
-
-        window.setCentralWidget(widget_instance)
-        window.resize(window.minimumSizeHint())
-        window.setWindowTitle(f"BEC - {widget_instance.objectName()}")
-        window.show()
-        return window
-
-    def apply_theme(self, theme: str):
-        """
-        Change the theme of the application.
-        """
-        for tile in self.tiles.values():
-            tile.apply_theme(theme)
-
-        super().apply_theme(theme)
-
-    def _open_auto_update(self):
-        """
-        Open the auto update window.
-        """
-        if self.tiles["auto_update"].selector is None:
-            auto_update = None
-        else:
-            auto_update = self.tiles["auto_update"].selector.currentText()
-            if auto_update == "Default":
-                auto_update = None
-        return self.launch("auto_update", auto_update=auto_update)
-
-    def _open_widget(self):
-        """
-        Open a widget from the available widgets.
-        """
-        if self.tiles["widget"].selector is None:
-            return
-        widget = self.tiles["widget"].selector.currentText()
-        if widget not in self.available_widgets:
-            raise ValueError(f"Widget {widget} not found in available widgets.")
-        return self.launch("widget", widget=self.available_widgets[widget])
-
-    @SafeSlot(popup_error=True)
-    def _open_custom_ui_file(self):
-        """
-        Open a file dialog to select a custom UI file and launch it.
-        """
-        ui_file, _ = QFileDialog.getOpenFileName(
-            self, "Select UI File", "", "UI Files (*.ui);;All Files (*)"
-        )
-        self.launch("custom_ui_file", ui_file=ui_file)
-
-    @staticmethod
-    def _update_available_auto_updates() -> dict[str, type[AutoUpdates]]:
-        """
-        Load all available auto updates from the plugin repository.
-        """
-        try:
-            auto_updates = get_plugin_auto_updates()
-            logger.info(f"Available auto updates: {auto_updates.keys()}")
-        except Exception as exc:
-            logger.error(f"Failed to load auto updates: {exc}")
-            return {}
-        return auto_updates
-
-    def show_launcher(self):
-        """
-        Show the launcher window.
-        """
-        self.show()
-
-    def hide_launcher(self):
-        """
-        Hide the launcher window.
-        """
-        self.hide()
-
-    def showEvent(self, event):
-        super().showEvent(event)
-        self.setFixedSize(self.size())
-
-    def _launcher_is_last_widget(self, connections: dict) -> bool:
-        """
-        Check if the launcher is the last widget in the application.
-        """
-
-        remaining_connections = [
-            connection for connection in connections.values() if connection.parent_id != self.gui_id
-        ]
-        return len(remaining_connections) <= 4
-
-    def _turn_off_the_lights(self, connections: dict):
-        """
-        If there is only one connection remaining, it is the launcher, so we show it.
-        Once the launcher is closed as the last window, we quit the application.
-        """
-        if self._launcher_is_last_widget(connections):
-            self.show()
-            self.activateWindow()
-            self.raise_()
-            if self.app:
-                self.app.setQuitOnLastWindowClosed(True)  # type: ignore
-            return
-
-        self.hide()
-        if self.app:
-            self.app.setQuitOnLastWindowClosed(False)  # type: ignore
-
-    def closeEvent(self, event):
-        """
-        Close the launcher window.
-        """
-        connections = self.register.list_all_connections()
-        if self._launcher_is_last_widget(connections):
-            event.accept()
-            return
-
-        event.ignore()
-        self.hide()
-
-
-if __name__ == "__main__":
-    import sys
-
-    app = QApplication(sys.argv)
-    launcher = LaunchWindow()
-    launcher.show()
-    sys.exit(app.exec())

bec_widgets/applications/main_app.py

@@ -1,189 +0,0 @@
-from qtpy.QtWidgets import QApplication, QHBoxLayout, QStackedWidget, QWidget
-
-from bec_widgets.applications.navigation_centre.reveal_animator import ANIMATION_DURATION
-from bec_widgets.applications.navigation_centre.side_bar import SideBar
-from bec_widgets.applications.navigation_centre.side_bar_components import NavigationItem
-from bec_widgets.applications.views.view import ViewBase, WaveformViewInline, WaveformViewPopup
-from bec_widgets.utils.colors import apply_theme
-from bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area import AdvancedDockArea
-from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
-
-
-class BECMainApp(BECMainWindow):
-
-    def __init__(
-        self,
-        parent=None,
-        *args,
-        anim_duration: int = ANIMATION_DURATION,
-        show_examples: bool = False,
-        **kwargs,
-    ):
-        super().__init__(parent=parent, *args, **kwargs)
-        self._show_examples = bool(show_examples)
-
-        # --- Compose central UI (sidebar + stack)
-        self.sidebar = SideBar(parent=self, anim_duration=anim_duration)
-        self.stack = QStackedWidget(self)
-
-        container = QWidget(self)
-        layout = QHBoxLayout(container)
-        layout.setContentsMargins(0, 0, 0, 0)
-        layout.setSpacing(0)
-        layout.addWidget(self.sidebar, 0)
-        layout.addWidget(self.stack, 1)
-        self.setCentralWidget(container)
-
-        # Mapping for view switching
-        self._view_index: dict[str, int] = {}
-        self._current_view_id: str | None = None
-        self.sidebar.view_selected.connect(self._on_view_selected)
-
-        self._add_views()
-
-    def _add_views(self):
-        self.add_section("BEC Applications", "bec_apps")
-        self.ads = AdvancedDockArea(self)
-
-        self.add_view(
-            icon="widgets", title="Dock Area", id="dock_area", widget=self.ads, mini_text="Docks"
-        )
-
-        if self._show_examples:
-            self.add_section("Examples", "examples")
-            waveform_view_popup = WaveformViewPopup(
-                parent=self, id="waveform_view_popup", title="Waveform Plot"
-            )
-            waveform_view_stack = WaveformViewInline(
-                parent=self, id="waveform_view_stack", title="Waveform Plot"
-            )
-
-            self.add_view(
-                icon="show_chart",
-                title="Waveform With Popup",
-                id="waveform_popup",
-                widget=waveform_view_popup,
-                mini_text="Popup",
-            )
-            self.add_view(
-                icon="show_chart",
-                title="Waveform InLine Stack",
-                id="waveform_stack",
-                widget=waveform_view_stack,
-                mini_text="Stack",
-            )
-
-        self.set_current("dock_area")
-        self.sidebar.add_dark_mode_item()
-
-    # --- Public API ------------------------------------------------------
-    def add_section(self, title: str, id: str, position: int | None = None):
-        return self.sidebar.add_section(title, id, position)
-
-    def add_separator(self):
-        return self.sidebar.add_separator()
-
-    def add_dark_mode_item(self, id: str = "dark_mode", position: int | None = None):
-        return self.sidebar.add_dark_mode_item(id=id, position=position)
-
-    def add_view(
-        self,
-        *,
-        icon: str,
-        title: str,
-        id: str,
-        widget: QWidget,
-        mini_text: str | None = None,
-        position: int | None = None,
-        from_top: bool = True,
-        toggleable: bool = True,
-        exclusive: bool = True,
-    ) -> NavigationItem:
-        """
-        Register a view in the stack and create a matching nav item in the sidebar.
-
-        Args:
-            icon(str): Icon name for the nav item.
-            title(str): Title for the nav item.
-            id(str): Unique ID for the view/item.
-            widget(QWidget): The widget to add to the stack.
-            mini_text(str, optional): Short text for the nav item when sidebar is collapsed.
-            position(int, optional): Position to insert the nav item.
-            from_top(bool, optional): Whether to count position from the top or bottom.
-            toggleable(bool, optional): Whether the nav item is toggleable.
-            exclusive(bool, optional): Whether the nav item is exclusive.
-
-        Returns:
-            NavigationItem: The created navigation item.
-
-
-        """
-        item = self.sidebar.add_item(
-            icon=icon,
-            title=title,
-            id=id,
-            mini_text=mini_text,
-            position=position,
-            from_top=from_top,
-            toggleable=toggleable,
-            exclusive=exclusive,
-        )
-        # Wrap plain widgets into a ViewBase so enter/exit hooks are available
-        if isinstance(widget, ViewBase):
-            view_widget = widget
-        else:
-            view_widget = ViewBase(content=widget, parent=self, id=id, title=title)
-
-        idx = self.stack.addWidget(view_widget)
-        self._view_index[id] = idx
-        return item
-
-    def set_current(self, id: str) -> None:
-        if id in self._view_index:
-            self.sidebar.activate_item(id)
-
-    # Internal: route sidebar selection to the stack
-    def _on_view_selected(self, vid: str) -> None:
-        # Determine current view
-        current_index = self.stack.currentIndex()
-        current_view = (
-            self.stack.widget(current_index) if 0 <= current_index < self.stack.count() else None
-        )
-
-        # Ask current view whether we may leave
-        if current_view is not None and hasattr(current_view, "on_exit"):
-            may_leave = current_view.on_exit()
-            if may_leave is False:
-                # Veto: restore previous highlight without re-emitting selection
-                if self._current_view_id is not None:
-                    self.sidebar.activate_item(self._current_view_id, emit_signal=False)
-                return
-
-        # Proceed with switch
-        idx = self._view_index.get(vid)
-        if idx is None or not (0 <= idx < self.stack.count()):
-            return
-        self.stack.setCurrentIndex(idx)
-        new_view = self.stack.widget(idx)
-        self._current_view_id = vid
-        if hasattr(new_view, "on_enter"):
-            new_view.on_enter()
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import argparse
-    import sys
-
-    parser = argparse.ArgumentParser(description="BEC Main Application")
-    parser.add_argument(
-        "--examples", action="store_true", help="Show the Examples section with waveform demo views"
-    )
-    # Let Qt consume the remaining args
-    args, qt_args = parser.parse_known_args(sys.argv[1:])
-
-    app = QApplication([sys.argv[0], *qt_args])
-    apply_theme("dark")
-    w = BECMainApp(show_examples=args.examples)
-    w.show()
-
-    sys.exit(app.exec())

bec_widgets/applications/navigation_centre/reveal_animator.py

@@ -1,114 +0,0 @@
-from __future__ import annotations
-
-from qtpy.QtCore import QEasingCurve, QParallelAnimationGroup, QPropertyAnimation
-from qtpy.QtWidgets import QGraphicsOpacityEffect, QWidget
-
-ANIMATION_DURATION = 500  # ms
-
-
-class RevealAnimator:
-    """Animate reveal/hide for a single widget using opacity + max W/H.
-
-    This keeps the widget always visible to avoid jitter from setVisible().
-    Collapsed state: opacity=0, maxW=0, maxH=0.
-    Expanded state: opacity=1, maxW=sizeHint.width(), maxH=sizeHint.height().
-    """
-
-    def __init__(
-        self,
-        widget: QWidget,
-        duration: int = ANIMATION_DURATION,
-        easing: QEasingCurve.Type = QEasingCurve.InOutCubic,
-        initially_revealed: bool = False,
-        *,
-        animate_opacity: bool = True,
-        animate_width: bool = True,
-        animate_height: bool = True,
-    ):
-        self.widget = widget
-        self.animate_opacity = animate_opacity
-        self.animate_width = animate_width
-        self.animate_height = animate_height
-        # Opacity effect
-        self.fx = QGraphicsOpacityEffect(widget)
-        widget.setGraphicsEffect(self.fx)
-        # Animations
-        self.opacity_anim = (
-            QPropertyAnimation(self.fx, b"opacity") if self.animate_opacity else None
-        )
-        self.width_anim = (
-            QPropertyAnimation(widget, b"maximumWidth") if self.animate_width else None
-        )
-        self.height_anim = (
-            QPropertyAnimation(widget, b"maximumHeight") if self.animate_height else None
-        )
-        for anim in (self.opacity_anim, self.width_anim, self.height_anim):
-            if anim is not None:
-                anim.setDuration(duration)
-                anim.setEasingCurve(easing)
-        # Initialize to requested state
-        self.set_immediate(initially_revealed)
-
-    def _natural_sizes(self) -> tuple[int, int]:
-        sh = self.widget.sizeHint()
-        w = max(sh.width(), 1)
-        h = max(sh.height(), 1)
-        return w, h
-
-    def set_immediate(self, revealed: bool):
-        """
-        Immediately set the widget to the target revealed/collapsed state.
-
-        Args:
-            revealed(bool): True to reveal, False to collapse.
-        """
-        w, h = self._natural_sizes()
-        if self.animate_opacity:
-            self.fx.setOpacity(1.0 if revealed else 0.0)
-        if self.animate_width:
-            self.widget.setMaximumWidth(w if revealed else 0)
-        if self.animate_height:
-            self.widget.setMaximumHeight(h if revealed else 0)
-
-    def setup(self, reveal: bool):
-        """
-        Prepare animations to transition to the target revealed/collapsed state.
-
-        Args:
-            reveal(bool): True to reveal, False to collapse.
-        """
-        # Prepare animations from current state to target
-        target_w, target_h = self._natural_sizes()
-        if self.opacity_anim is not None:
-            self.opacity_anim.setStartValue(self.fx.opacity())
-            self.opacity_anim.setEndValue(1.0 if reveal else 0.0)
-        if self.width_anim is not None:
-            self.width_anim.setStartValue(self.widget.maximumWidth())
-            self.width_anim.setEndValue(target_w if reveal else 0)
-        if self.height_anim is not None:
-            self.height_anim.setStartValue(self.widget.maximumHeight())
-            self.height_anim.setEndValue(target_h if reveal else 0)
-
-    def add_to_group(self, group: QParallelAnimationGroup):
-        """
-        Add the prepared animations to the given animation group.
-
-        Args:
-            group(QParallelAnimationGroup): The animation group to add to.
-        """
-        if self.opacity_anim is not None:
-            group.addAnimation(self.opacity_anim)
-        if self.width_anim is not None:
-            group.addAnimation(self.width_anim)
-        if self.height_anim is not None:
-            group.addAnimation(self.height_anim)
-
-    def animations(self):
-        """
-        Get a list of all animations (non-None) for adding to a group.
-        """
-        return [
-            anim
-            for anim in (self.opacity_anim, self.height_anim, self.width_anim)
-            if anim is not None
-        ]

bec_widgets/applications/navigation_centre/side_bar.py

@@ -1,357 +0,0 @@
-from __future__ import annotations
-
-from bec_qthemes import material_icon
-from qtpy import QtWidgets
-from qtpy.QtCore import QEasingCurve, QParallelAnimationGroup, QPropertyAnimation, Qt, Signal
-from qtpy.QtWidgets import (
-    QGraphicsOpacityEffect,
-    QHBoxLayout,
-    QLabel,
-    QScrollArea,
-    QToolButton,
-    QVBoxLayout,
-    QWidget,
-)
-
-from bec_widgets import SafeProperty, SafeSlot
-from bec_widgets.applications.navigation_centre.reveal_animator import ANIMATION_DURATION
-from bec_widgets.applications.navigation_centre.side_bar_components import (
-    DarkModeNavItem,
-    NavigationItem,
-    SectionHeader,
-    SideBarSeparator,
-)
-
-
-class SideBar(QScrollArea):
-    view_selected = Signal(str)
-    toggled = Signal(bool)
-
-    def __init__(
-        self,
-        parent=None,
-        title: str = "Control Panel",
-        collapsed_width: int = 56,
-        expanded_width: int = 250,
-        anim_duration: int = ANIMATION_DURATION,
-    ):
-        super().__init__(parent=parent)
-        self.setObjectName("SideBar")
-
-        # private attributes
-        self._is_expanded = False
-        self._collapsed_width = collapsed_width
-        self._expanded_width = expanded_width
-        self._anim_duration = anim_duration
-
-        # containers
-        self.components = {}
-        self._item_opts: dict[str, dict] = {}
-
-        # Scroll area properties
-        self.setWidgetResizable(True)
-        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
-        self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
-        self.setFrameShape(QtWidgets.QFrame.NoFrame)
-        self.setFixedWidth(self._collapsed_width)
-
-        # Content widget holding buttons for switching views
-        self.content = QWidget(self)
-        self.content_layout = QVBoxLayout(self.content)
-        self.content_layout.setContentsMargins(0, 0, 0, 0)
-        self.content_layout.setSpacing(4)
-        self.setWidget(self.content)
-
-        # Track active navigation item
-        self._active_id = None
-
-        # Top row with title and toggle button
-        self.toggle_row = QWidget(self)
-        self.toggle_row_layout = QHBoxLayout(self.toggle_row)
-
-        self.title_label = QLabel(title, self)
-        self.title_label.setObjectName("TopTitle")
-        self.title_label.setStyleSheet("font-weight: 600;")
-        self.title_fx = QGraphicsOpacityEffect(self.title_label)
-        self.title_label.setGraphicsEffect(self.title_fx)
-        self.title_fx.setOpacity(0.0)
-        self.title_label.setVisible(False)  # TODO dirty trick to avoid layout shift
-
-        self.toggle = QToolButton(self)
-        self.toggle.setCheckable(False)
-        self.toggle.setIcon(material_icon("keyboard_arrow_right", convert_to_pixmap=False))
-        self.toggle.clicked.connect(self.on_expand)
-
-        self.toggle_row_layout.addWidget(self.title_label, 1, Qt.AlignLeft | Qt.AlignVCenter)
-        self.toggle_row_layout.addWidget(self.toggle, 1, Qt.AlignHCenter | Qt.AlignVCenter)
-
-        # To push the content up always
-        self._bottom_spacer = QtWidgets.QSpacerItem(
-            0, 0, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding
-        )
-
-        # Add core widgets to layout
-        self.content_layout.addWidget(self.toggle_row)
-        self.content_layout.addItem(self._bottom_spacer)
-
-        # Animations
-        self.width_anim = QPropertyAnimation(self, b"bar_width")
-        self.width_anim.setDuration(self._anim_duration)
-        self.width_anim.setEasingCurve(QEasingCurve.InOutCubic)
-
-        self.title_anim = QPropertyAnimation(self.title_fx, b"opacity")
-        self.title_anim.setDuration(self._anim_duration)
-        self.title_anim.setEasingCurve(QEasingCurve.InOutCubic)
-
-        self.group = QParallelAnimationGroup(self)
-        self.group.addAnimation(self.width_anim)
-        self.group.addAnimation(self.title_anim)
-        self.group.finished.connect(self._on_anim_finished)
-
-        app = QtWidgets.QApplication.instance()
-        if app is not None and hasattr(app, "theme") and hasattr(app.theme, "theme_changed"):
-            app.theme.theme_changed.connect(self._on_theme_changed)
-
-    @SafeProperty(int)
-    def bar_width(self) -> int:
-        """
-        Get the current width of the side bar.
-
-        Returns:
-            int: The current width of the side bar.
-        """
-        return self.width()
-
-    @bar_width.setter
-    def bar_width(self, width: int):
-        """
-        Set the width of the side bar.
-
-        Args:
-            width(int): The new width of the side bar.
-        """
-        self.setFixedWidth(width)
-
-    @SafeProperty(bool)
-    def is_expanded(self) -> bool:
-        """
-        Check if the side bar is expanded.
-
-        Returns:
-            bool: True if the side bar is expanded, False otherwise.
-        """
-        return self._is_expanded
-
-    @SafeSlot()
-    @SafeSlot(bool)
-    def on_expand(self):
-        """
-        Toggle the expansion state of the side bar.
-        """
-        self._is_expanded = not self._is_expanded
-        self.toggle.setIcon(
-            material_icon(
-                "keyboard_arrow_left" if self._is_expanded else "keyboard_arrow_right",
-                convert_to_pixmap=False,
-            )
-        )
-
-        if self._is_expanded:
-            self.toggle_row_layout.setAlignment(self.toggle, Qt.AlignRight | Qt.AlignVCenter)
-
-        self.group.stop()
-        # Setting limits for animations of the side bar
-        self.width_anim.setStartValue(self.width())
-        self.width_anim.setEndValue(
-            self._expanded_width if self._is_expanded else self._collapsed_width
-        )
-        self.title_anim.setStartValue(self.title_fx.opacity())
-        self.title_anim.setEndValue(1.0 if self._is_expanded else 0.0)
-
-        # Setting limits for animations of the components
-        for comp in self.components.values():
-            if hasattr(comp, "setup_animations"):
-                comp.setup_animations(self._is_expanded)
-
-        self.group.start()
-        if self._is_expanded:
-            # TODO do not like this trick, but it is what it is for now
-            self.title_label.setVisible(self._is_expanded)
-            for comp in self.components.values():
-                if hasattr(comp, "set_visible"):
-                    comp.set_visible(self._is_expanded)
-        self.toggled.emit(self._is_expanded)
-
-    @SafeSlot()
-    def _on_anim_finished(self):
-        if not self._is_expanded:
-            self.toggle_row_layout.setAlignment(self.toggle, Qt.AlignHCenter | Qt.AlignVCenter)
-            # TODO do not like this trick, but it is what it is for now
-            self.title_label.setVisible(self._is_expanded)
-            for comp in self.components.values():
-                if hasattr(comp, "set_visible"):
-                    comp.set_visible(self._is_expanded)
-
-    @SafeSlot(str)
-    def _on_theme_changed(self, theme_name: str):
-        # Refresh toggle arrow icon so it picks up the new theme
-        self.toggle.setIcon(
-            material_icon(
-                "keyboard_arrow_left" if self._is_expanded else "keyboard_arrow_right",
-                convert_to_pixmap=False,
-            )
-        )
-        # Refresh each component that supports it
-        for comp in self.components.values():
-            if hasattr(comp, "refresh_theme"):
-                comp.refresh_theme()
-            else:
-                comp.style().unpolish(comp)
-                comp.style().polish(comp)
-                comp.update()
-        self.style().unpolish(self)
-        self.style().polish(self)
-        self.update()
-
-    def add_section(self, title: str, id: str, position: int | None = None) -> SectionHeader:
-        """
-        Add a section header to the side bar.
-
-        Args:
-            title(str): The title of the section.
-            id(str): Unique ID for the section.
-            position(int, optional): Position to insert the section header.
-
-        Returns:
-            SectionHeader: The created section header.
-
-        """
-        header = SectionHeader(self, title, anim_duration=self._anim_duration)
-        position = position if position is not None else self.content_layout.count() - 1
-        self.content_layout.insertWidget(position, header)
-        for anim in header.animations:
-            self.group.addAnimation(anim)
-        self.components[id] = header
-        return header
-
-    def add_separator(
-        self, *, from_top: bool = True, position: int | None = None
-    ) -> SideBarSeparator:
-        """
-        Add a separator line to the side bar. Separators are treated like regular
-        items; you can place multiple separators anywhere using `from_top` and `position`.
-        """
-        line = SideBarSeparator(self)
-        line.setStyleSheet("margin:12px;")
-        self._insert_nav_item(line, from_top=from_top, position=position)
-        return line
-
-    def add_item(
-        self,
-        icon: str,
-        title: str,
-        id: str,
-        mini_text: str | None = None,
-        position: int | None = None,
-        *,
-        from_top: bool = True,
-        toggleable: bool = True,
-        exclusive: bool = True,
-    ) -> NavigationItem:
-        """
-        Add a navigation item to the side bar.
-
-        Args:
-            icon(str): Icon name for the nav item.
-            title(str): Title for the nav item.
-            id(str): Unique ID for the nav item.
-            mini_text(str, optional): Short text for the nav item when sidebar is collapsed.
-            position(int, optional): Position to insert the nav item.
-            from_top(bool, optional): Whether to count position from the top or bottom.
-            toggleable(bool, optional): Whether the nav item is toggleable.
-            exclusive(bool, optional): Whether the nav item is exclusive.
-
-        Returns:
-            NavigationItem: The created navigation item.
-        """
-        item = NavigationItem(
-            parent=self,
-            title=title,
-            icon_name=icon,
-            mini_text=mini_text,
-            toggleable=toggleable,
-            exclusive=exclusive,
-            anim_duration=self._anim_duration,
-        )
-        self._insert_nav_item(item, from_top=from_top, position=position)
-        for anim in item.build_animations():
-            self.group.addAnimation(anim)
-        self.components[id] = item
-        # Connect activation to activation logic, passing id unchanged
-        item.activated.connect(lambda id=id: self.activate_item(id))
-        return item
-
-    def activate_item(self, target_id: str, *, emit_signal: bool = True):
-        target = self.components.get(target_id)
-        if target is None:
-            return
-        # Non-toggleable acts like an action: do not change any toggled states
-        if hasattr(target, "toggleable") and not target.toggleable:
-            self._active_id = target_id
-            if emit_signal:
-                self.view_selected.emit(target_id)
-            return
-
-        is_exclusive = getattr(target, "exclusive", True)
-        if is_exclusive:
-            # Radio-like behavior among exclusive items only
-            for comp_id, comp in self.components.items():
-                if not isinstance(comp, NavigationItem):
-                    continue
-                if comp is target:
-                    comp.set_active(True)
-                else:
-                    # Only untoggle other items that are also exclusive
-                    if getattr(comp, "exclusive", True):
-                        comp.set_active(False)
-                    # Leave non-exclusive items as they are
-        else:
-            # Non-exclusive toggles independently
-            target.set_active(not target.is_active())
-
-        self._active_id = target_id
-        if emit_signal:
-            self.view_selected.emit(target_id)
-
-    def add_dark_mode_item(
-        self, id: str = "dark_mode", position: int | None = None
-    ) -> DarkModeNavItem:
-        """
-        Add a dark mode toggle item to the side bar.
-
-        Args:
-            id(str): Unique ID for the dark mode item.
-            position(int, optional): Position to insert the dark mode item.
-
-        Returns:
-            DarkModeNavItem: The created dark mode navigation item.
-        """
-        item = DarkModeNavItem(parent=self, id=id, anim_duration=self._anim_duration)
-        # compute bottom insertion point (same semantics as from_top=False)
-        self._insert_nav_item(item, from_top=False, position=position)
-        for anim in item.build_animations():
-            self.group.addAnimation(anim)
-        self.components[id] = item
-        item.activated.connect(lambda id=id: self.activate_item(id))
-        return item
-
-    def _insert_nav_item(
-        self, item: QWidget, *, from_top: bool = True, position: int | None = None
-    ):
-        if from_top:
-            base_index = self.content_layout.indexOf(self._bottom_spacer)
-            pos = base_index if position is None else min(base_index, position)
-        else:
-            base = self.content_layout.indexOf(self._bottom_spacer) + 1
-            pos = base if position is None else base + max(0, position)
-        self.content_layout.insertWidget(pos, item)

bec_widgets/applications/navigation_centre/side_bar_components.py

@@ -1,372 +0,0 @@
-from __future__ import annotations
-
-from bec_qthemes import material_icon
-from qtpy import QtCore
-from qtpy.QtCore import QEasingCurve, QPropertyAnimation, Qt
-from qtpy.QtWidgets import (
-    QApplication,
-    QFrame,
-    QHBoxLayout,
-    QLabel,
-    QSizePolicy,
-    QToolButton,
-    QVBoxLayout,
-    QWidget,
-)
-
-from bec_widgets import SafeProperty
-from bec_widgets.applications.navigation_centre.reveal_animator import (
-    ANIMATION_DURATION,
-    RevealAnimator,
-)
-
-
-def get_on_primary():
-    app = QApplication.instance()
-    if app is not None and hasattr(app, "theme"):
-        return app.theme.color("ON_PRIMARY")
-    return "#FFFFFF"
-
-
-def get_fg():
-    app = QApplication.instance()
-    if app is not None and hasattr(app, "theme"):
-        return app.theme.color("FG")
-    return "#FFFFFF"
-
-
-class SideBarSeparator(QFrame):
-    """A horizontal line separator for use in SideBar."""
-
-    def __init__(self, parent=None):
-        super().__init__(parent)
-        self.setObjectName("SideBarSeparator")
-        self.setFrameShape(QFrame.NoFrame)
-        self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
-        self.setFixedHeight(2)
-        self.setProperty("variant", "separator")
-
-
-class SectionHeader(QWidget):
-    """A section header with a label and a horizontal line below."""
-
-    def __init__(self, parent=None, text: str = None, anim_duration: int = ANIMATION_DURATION):
-        super().__init__(parent)
-        self.setObjectName("SectionHeader")
-
-        self.lbl = QLabel(text, self)
-        self.lbl.setObjectName("SectionHeaderLabel")
-        self.lbl.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
-        self._reveal = RevealAnimator(self.lbl, duration=anim_duration, initially_revealed=False)
-
-        self.line = SideBarSeparator(self)
-
-        lay = QVBoxLayout(self)
-        # keep your margins/spacing preferences here if needed
-        lay.setContentsMargins(12, 0, 12, 0)
-        lay.setSpacing(6)
-        lay.addWidget(self.lbl)
-        lay.addWidget(self.line)
-
-        self.animations = self.build_animations()
-
-    def build_animations(self) -> list[QPropertyAnimation]:
-        """
-        Build and return animations for expanding/collapsing the sidebar.
-
-        Returns:
-            list[QPropertyAnimation]: List of animations.
-        """
-        return self._reveal.animations()
-
-    def setup_animations(self, expanded: bool):
-        """
-        Setup animations for expanding/collapsing the sidebar.
-
-        Args:
-            expanded(bool): True if the sidebar is expanded, False if collapsed.
-        """
-        self._reveal.setup(expanded)
-
-
-class NavigationItem(QWidget):
-    """A nav tile with an icon + labels and an optional expandable body.
-    Provides animations for collapsed/expanded sidebar states via
-    build_animations()/setup_animations(), similar to SectionHeader.
-    """
-
-    activated = QtCore.Signal()
-
-    def __init__(
-        self,
-        parent=None,
-        *,
-        title: str,
-        icon_name: str,
-        mini_text: str | None = None,
-        toggleable: bool = True,
-        exclusive: bool = True,
-        anim_duration: int = ANIMATION_DURATION,
-    ):
-        super().__init__(parent=parent)
-        self.setObjectName("NavigationItem")
-
-        # Private attributes
-        self._title = title
-        self._icon_name = icon_name
-        self._mini_text = mini_text or title
-        self._toggleable = toggleable
-        self._toggled = False
-        self._exclusive = exclusive
-
-        # Main Icon
-        self.icon_btn = QToolButton(self)
-        self.icon_btn.setIcon(material_icon(self._icon_name, filled=False, convert_to_pixmap=False))
-        self.icon_btn.setAutoRaise(True)
-        self._icon_size_collapsed = QtCore.QSize(20, 20)
-        self._icon_size_expanded = QtCore.QSize(26, 26)
-        self.icon_btn.setIconSize(self._icon_size_collapsed)
-        # Remove QToolButton hover/pressed background/outline
-        self.icon_btn.setStyleSheet(
-            """
-            QToolButton:hover { background: transparent; border: none; }
-            QToolButton:pressed { background: transparent; border: none; }
-            """
-        )
-
-        # Mini label below icon
-        self.mini_lbl = QLabel(self._mini_text, self)
-        self.mini_lbl.setObjectName("NavMiniLabel")
-        self.mini_lbl.setAlignment(Qt.AlignCenter)
-        self.mini_lbl.setStyleSheet("font-size: 10px;")
-        self.reveal_mini_lbl = RevealAnimator(
-            widget=self.mini_lbl,
-            initially_revealed=True,
-            animate_width=False,
-            duration=anim_duration,
-        )
-
-        # Container for icon + mini label
-        self.mini_icon = QWidget(self)
-        mini_lay = QVBoxLayout(self.mini_icon)
-        mini_lay.setContentsMargins(0, 2, 0, 2)
-        mini_lay.setSpacing(2)
-        mini_lay.addWidget(self.icon_btn, 0, Qt.AlignCenter)
-        mini_lay.addWidget(self.mini_lbl, 0, Qt.AlignCenter)
-
-        # Title label
-        self.title_lbl = QLabel(self._title, self)
-        self.title_lbl.setObjectName("NavTitleLabel")
-        self.title_lbl.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
-        self.title_lbl.setStyleSheet("font-size: 13px;")
-        self.reveal_title_lbl = RevealAnimator(
-            widget=self.title_lbl,
-            initially_revealed=False,
-            animate_height=False,
-            duration=anim_duration,
-        )
-        self.title_lbl.setVisible(False)  # TODO dirty trick to avoid layout shift
-
-        lay = QHBoxLayout(self)
-        lay.setContentsMargins(12, 2, 12, 2)
-        lay.setSpacing(6)
-        lay.addWidget(self.mini_icon, 0, Qt.AlignHCenter | Qt.AlignTop)
-        lay.addWidget(self.title_lbl, 1, Qt.AlignLeft | Qt.AlignVCenter)
-
-        self.icon_size_anim = QPropertyAnimation(self.icon_btn, b"iconSize")
-        self.icon_size_anim.setDuration(anim_duration)
-        self.icon_size_anim.setEasingCurve(QEasingCurve.InOutCubic)
-
-        # Connect icon button to emit activation
-        self.icon_btn.clicked.connect(self._emit_activated)
-        self.setMouseTracking(True)
-        self.setAttribute(Qt.WA_StyledBackground, True)
-
-    def is_active(self) -> bool:
-        """Return whether the item is currently active/selected."""
-        return self.property("toggled") is True
-
-    def build_animations(self) -> list[QPropertyAnimation]:
-        """
-        Build and return animations for expanding/collapsing the sidebar.
-
-        Returns:
-            list[QPropertyAnimation]: List of animations.
-        """
-        return (
-            self.reveal_title_lbl.animations()
-            + self.reveal_mini_lbl.animations()
-            + [self.icon_size_anim]
-        )
-
-    def setup_animations(self, expanded: bool):
-        """
-        Setup animations for expanding/collapsing the sidebar.
-
-        Args:
-            expanded(bool): True if the sidebar is expanded, False if collapsed.
-        """
-        self.reveal_mini_lbl.setup(not expanded)
-        self.reveal_title_lbl.setup(expanded)
-        self.icon_size_anim.setStartValue(self.icon_btn.iconSize())
-        self.icon_size_anim.setEndValue(
-            self._icon_size_expanded if expanded else self._icon_size_collapsed
-        )
-
-    def set_visible(self, visible: bool):
-        """Set visibility of the title label."""
-        self.title_lbl.setVisible(visible)
-
-    def _emit_activated(self):
-        self.activated.emit()
-
-    def set_active(self, active: bool):
-        """
-        Set the active/selected state of the item.
-
-        Args:
-            active(bool): True to set active, False to deactivate.
-        """
-        self.setProperty("toggled", active)
-        self.toggled = active
-        # ensure style refresh
-        self.style().unpolish(self)
-        self.style().polish(self)
-        self.update()
-
-    def mousePressEvent(self, event):
-        self.activated.emit()
-        super().mousePressEvent(event)
-
-    @SafeProperty(bool)
-    def toggleable(self) -> bool:
-        """
-        Whether the item is toggleable (like a button) or not (like an action).
-
-        Returns:
-            bool: True if toggleable, False otherwise.
-        """
-        return self._toggleable
-
-    @toggleable.setter
-    def toggleable(self, value: bool):
-        """
-        Set whether the item is toggleable (like a button) or not (like an action).
-        Args:
-            value(bool): True to make toggleable, False otherwise.
-        """
-        self._toggleable = bool(value)
-
-    @SafeProperty(bool)
-    def toggled(self) -> bool:
-        """
-        Whether the item is currently toggled/selected.
-
-        Returns:
-            bool: True if toggled, False otherwise.
-        """
-        return self._toggled
-
-    @toggled.setter
-    def toggled(self, value: bool):
-        """
-        Set whether the item is currently toggled/selected.
-
-        Args:
-            value(bool): True to set toggled, False to untoggle.
-        """
-        self._toggled = value
-        if value:
-            new_icon = material_icon(
-                self._icon_name, filled=True, color=get_on_primary(), convert_to_pixmap=False
-            )
-        else:
-            new_icon = material_icon(
-                self._icon_name, filled=False, color=get_fg(), convert_to_pixmap=False
-            )
-        self.icon_btn.setIcon(new_icon)
-        # Re-polish so QSS applies correct colors to icon/labels
-        for w in (self, self.icon_btn, self.title_lbl, self.mini_lbl):
-            w.style().unpolish(w)
-            w.style().polish(w)
-            w.update()
-
-    @SafeProperty(bool)
-    def exclusive(self) -> bool:
-        """
-        Whether the item is exclusive in its toggle group.
-
-        Returns:
-            bool: True if exclusive, False otherwise.
-        """
-        return self._exclusive
-
-    @exclusive.setter
-    def exclusive(self, value: bool):
-        """
-        Set whether the item is exclusive in its toggle group.
-
-        Args:
-            value(bool): True to make exclusive, False otherwise.
-        """
-        self._exclusive = bool(value)
-
-    def refresh_theme(self):
-        # Recompute icon/label colors according to current theme and state
-        # Trigger the toggled setter to rebuild the icon with the correct color
-        self.toggled = self._toggled
-        # Ensure QSS-driven text/icon colors refresh
-        for w in (self, self.icon_btn, self.title_lbl, self.mini_lbl):
-            w.style().unpolish(w)
-            w.style().polish(w)
-            w.update()
-
-
-class DarkModeNavItem(NavigationItem):
-    """Bottom action item that toggles app theme and updates its icon/text."""
-
-    def __init__(
-        self, parent=None, *, id: str = "dark_mode", anim_duration: int = ANIMATION_DURATION
-    ):
-        super().__init__(
-            parent=parent,
-            title="Dark mode",
-            icon_name="dark_mode",
-            mini_text="Dark",
-            toggleable=False,  # action-like, no selection highlight changes
-            exclusive=False,
-            anim_duration=anim_duration,
-        )
-        self._id = id
-        self._sync_from_qapp_theme()
-        self.activated.connect(self.toggle_theme)
-
-    def _qapp_dark_enabled(self) -> bool:
-        qapp = QApplication.instance()
-        return bool(getattr(getattr(qapp, "theme", None), "theme", None) == "dark")
-
-    def _sync_from_qapp_theme(self):
-        is_dark = self._qapp_dark_enabled()
-        # Update labels
-        self.title_lbl.setText("Light mode" if is_dark else "Dark mode")
-        self.mini_lbl.setText("Light" if is_dark else "Dark")
-        # Update icon
-        self.icon_btn.setIcon(
-            material_icon("light_mode" if is_dark else "dark_mode", convert_to_pixmap=False)
-        )
-
-    def refresh_theme(self):
-        self._sync_from_qapp_theme()
-        for w in (self, self.icon_btn, self.title_lbl, self.mini_lbl):
-            w.style().unpolish(w)
-            w.style().polish(w)
-            w.update()
-
-    def toggle_theme(self):
-        """Toggle application theme and update icon/text."""
-        from bec_widgets.utils.colors import apply_theme
-
-        is_dark = self._qapp_dark_enabled()
-
-        apply_theme("light" if is_dark else "dark")
-        self._sync_from_qapp_theme()

bec_widgets/applications/views/view.py

@@ -1,262 +0,0 @@
-from __future__ import annotations
-
-from qtpy.QtCore import QEventLoop
-from qtpy.QtWidgets import (
-    QDialog,
-    QDialogButtonBox,
-    QFormLayout,
-    QHBoxLayout,
-    QLabel,
-    QMessageBox,
-    QPushButton,
-    QStackedLayout,
-    QVBoxLayout,
-    QWidget,
-)
-
-from bec_widgets.utils.error_popups import SafeSlot
-from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import DeviceComboBox
-from bec_widgets.widgets.control.device_input.signal_combobox.signal_combobox import SignalComboBox
-from bec_widgets.widgets.plots.waveform.waveform import Waveform
-
-
-class ViewBase(QWidget):
-    """Wrapper for a content widget used inside the main app's stacked view.
-
-    Subclasses can implement `on_enter` and `on_exit` to run custom logic when the view becomes visible or is about to be hidden.
-
-    Args:
-        content (QWidget): The actual view widget to display.
-        parent (QWidget | None): Parent widget.
-        id (str | None): Optional view id, useful for debugging or introspection.
-        title (str | None): Optional human-readable title.
-    """
-
-    def __init__(
-        self,
-        parent: QWidget | None = None,
-        content: QWidget | None = None,
-        *,
-        id: str | None = None,
-        title: str | None = None,
-    ):
-        super().__init__(parent=parent)
-        self.content: QWidget | None = None
-        self.view_id = id
-        self.view_title = title
-
-        lay = QVBoxLayout(self)
-        lay.setContentsMargins(0, 0, 0, 0)
-        lay.setSpacing(0)
-
-        if content is not None:
-            self.set_content(content)
-
-    def set_content(self, content: QWidget) -> None:
-        """Replace the current content widget with a new one."""
-        if self.content is not None:
-            self.content.setParent(None)
-        self.content = content
-        self.layout().addWidget(content)
-
-    @SafeSlot()
-    def on_enter(self) -> None:
-        """Called after the view becomes current/visible.
-
-        Default implementation does nothing. Override in subclasses.
-        """
-        pass
-
-    @SafeSlot()
-    def on_exit(self) -> bool:
-        """Called before the view is switched away/hidden.
-
-        Return True to allow switching, or False to veto.
-        Default implementation allows switching.
-        """
-        return True
-
-
-####################################################################################################
-# Example views for demonstration/testing purposes
-####################################################################################################
-
-
-# --- Popup UI version ---
-class WaveformViewPopup(ViewBase):  # pragma: no cover
-    def __init__(self, parent=None, *args, **kwargs):
-        super().__init__(parent=parent, *args, **kwargs)
-
-        self.waveform = Waveform(parent=self)
-        self.set_content(self.waveform)
-
-    @SafeSlot()
-    def on_enter(self) -> None:
-        dialog = QDialog(self)
-        dialog.setWindowTitle("Configure Waveform View")
-
-        label = QLabel("Select device and signal for the waveform plot:", parent=dialog)
-
-        # same as in the CurveRow used in waveform
-        self.device_edit = DeviceComboBox(parent=self)
-        self.device_edit.insertItem(0, "")
-        self.device_edit.setEditable(True)
-        self.device_edit.setCurrentIndex(0)
-        self.entry_edit = SignalComboBox(parent=self)
-        self.entry_edit.include_config_signals = False
-        self.entry_edit.insertItem(0, "")
-        self.entry_edit.setEditable(True)
-        self.device_edit.currentTextChanged.connect(self.entry_edit.set_device)
-        self.device_edit.device_reset.connect(self.entry_edit.reset_selection)
-
-        form = QFormLayout()
-        form.addRow(label)
-        form.addRow("Device", self.device_edit)
-        form.addRow("Signal", self.entry_edit)
-
-        buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel, parent=dialog)
-        buttons.accepted.connect(dialog.accept)
-        buttons.rejected.connect(dialog.reject)
-
-        v = QVBoxLayout(dialog)
-        v.addLayout(form)
-        v.addWidget(buttons)
-
-        if dialog.exec_() == QDialog.Accepted:
-            self.waveform.plot(
-                y_name=self.device_edit.currentText(), y_entry=self.entry_edit.currentText()
-            )
-
-    @SafeSlot()
-    def on_exit(self) -> bool:
-        ans = QMessageBox.question(
-            self,
-            "Switch and clear?",
-            "Do you want to switch views and clear the plot?",
-            QMessageBox.Yes | QMessageBox.No,
-            QMessageBox.No,
-        )
-        if ans == QMessageBox.Yes:
-            self.waveform.clear_all()
-            return True
-        return False
-
-
-# --- Inline stacked UI version ---
-class WaveformViewInline(ViewBase):  # pragma: no cover
-    def __init__(self, parent=None, *args, **kwargs):
-        super().__init__(parent=parent, *args, **kwargs)
-
-        # Root layout for this view uses a stacked layout
-        self.stack = QStackedLayout()
-        container = QWidget(self)
-        container.setLayout(self.stack)
-        self.set_content(container)
-
-        # --- Page 0: Settings page (inline form)
-        self.settings_page = QWidget()
-        sp_layout = QVBoxLayout(self.settings_page)
-        sp_layout.setContentsMargins(16, 16, 16, 16)
-        sp_layout.setSpacing(12)
-
-        title = QLabel("Select device and signal for the waveform plot:", parent=self.settings_page)
-        self.device_edit = DeviceComboBox(parent=self.settings_page)
-        self.device_edit.insertItem(0, "")
-        self.device_edit.setEditable(True)
-        self.device_edit.setCurrentIndex(0)
-
-        self.entry_edit = SignalComboBox(parent=self.settings_page)
-        self.entry_edit.include_config_signals = False
-        self.entry_edit.insertItem(0, "")
-        self.entry_edit.setEditable(True)
-        self.device_edit.currentTextChanged.connect(self.entry_edit.set_device)
-        self.device_edit.device_reset.connect(self.entry_edit.reset_selection)
-
-        form = QFormLayout()
-        form.addRow(title)
-        form.addRow("Device", self.device_edit)
-        form.addRow("Signal", self.entry_edit)
-
-        btn_row = QHBoxLayout()
-        ok_btn = QPushButton("OK", parent=self.settings_page)
-        cancel_btn = QPushButton("Cancel", parent=self.settings_page)
-        btn_row.addStretch(1)
-        btn_row.addWidget(cancel_btn)
-        btn_row.addWidget(ok_btn)
-
-        sp_layout.addLayout(form)
-        sp_layout.addLayout(btn_row)
-
-        # --- Page 1: Waveform page
-        self.waveform_page = QWidget()
-        wf_layout = QVBoxLayout(self.waveform_page)
-        wf_layout.setContentsMargins(0, 0, 0, 0)
-        self.waveform = Waveform(parent=self.waveform_page)
-        wf_layout.addWidget(self.waveform)
-
-        # --- Page 2: Exit confirmation page (inline)
-        self.confirm_page = QWidget()
-        cp_layout = QVBoxLayout(self.confirm_page)
-        cp_layout.setContentsMargins(16, 16, 16, 16)
-        cp_layout.setSpacing(12)
-        qlabel = QLabel("Do you want to switch views and clear the plot?", parent=self.confirm_page)
-        cp_buttons = QHBoxLayout()
-        no_btn = QPushButton("No", parent=self.confirm_page)
-        yes_btn = QPushButton("Yes", parent=self.confirm_page)
-        cp_buttons.addStretch(1)
-        cp_buttons.addWidget(no_btn)
-        cp_buttons.addWidget(yes_btn)
-        cp_layout.addWidget(qlabel)
-        cp_layout.addLayout(cp_buttons)
-
-        # Add pages to the stack
-        self.stack.addWidget(self.settings_page)  # index 0
-        self.stack.addWidget(self.waveform_page)  # index 1
-        self.stack.addWidget(self.confirm_page)  # index 2
-
-        # Wire settings buttons
-        ok_btn.clicked.connect(self._apply_settings_and_show_waveform)
-        cancel_btn.clicked.connect(self._show_waveform_without_changes)
-
-        # Prepare result holder for the inline confirmation
-        self._exit_choice_yes = None
-        yes_btn.clicked.connect(lambda: self._exit_reply(True))
-        no_btn.clicked.connect(lambda: self._exit_reply(False))
-
-    @SafeSlot()
-    def on_enter(self) -> None:
-        # Always start on the settings page when entering
-        self.stack.setCurrentIndex(0)
-
-    @SafeSlot()
-    def on_exit(self) -> bool:
-        # Show inline confirmation page and synchronously wait for a choice
-        # -> trick to make the choice blocking, however popup would be cleaner solution
-        self._exit_choice_yes = None
-        self.stack.setCurrentIndex(2)
-        loop = QEventLoop()
-        self._exit_loop = loop
-        loop.exec_()
-
-        if self._exit_choice_yes:
-            self.waveform.clear_all()
-            return True
-        # Revert to waveform view if user cancelled switching
-        self.stack.setCurrentIndex(1)
-        return False
-
-    def _apply_settings_and_show_waveform(self):
-        dev = self.device_edit.currentText()
-        sig = self.entry_edit.currentText()
-        if dev and sig:
-            self.waveform.plot(y_name=dev, y_entry=sig)
-        self.stack.setCurrentIndex(1)
-
-    def _show_waveform_without_changes(self):
-        # Just show waveform page without plotting
-        self.stack.setCurrentIndex(1)
-
-    def _exit_reply(self, yes: bool):
-        self._exit_choice_yes = bool(yes)
-        if hasattr(self, "_exit_loop") and self._exit_loop.isRunning():
-            self._exit_loop.quit()

bec_widgets/cli/__init__.py

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

bec_widgets/cli/auto_updates.py

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

bec_widgets/cli/client_utils.py

@@ -1,60 +1,73 @@
-"""Client utilities for the BEC GUI."""
-
 from __future__ import annotations
 
-import json
+import importlib
+import importlib.metadata as imd
 import os
 import select
 import subprocess
+import sys
 import threading
 import time
-from contextlib import contextmanager
-from threading import Lock
-from typing import TYPE_CHECKING, Literal, TypeAlias, cast
+import uuid
+from functools import wraps
+from typing import TYPE_CHECKING
 
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import bec_logger
-from bec_lib.utils.import_utils import lazy_import, lazy_import_from
-from rich.console import Console
-from rich.table import Table
+from bec_lib.utils.import_utils import isinstance_based_on_class_name, lazy_import, lazy_import_from
+from qtpy.QtCore import QEventLoop, QSocketNotifier, QTimer
 
-from bec_widgets.cli.rpc.rpc_base import RPCBase, RPCReference
-from bec_widgets.utils.serialization import register_serializer_extension
+import bec_widgets.cli.client as client
+from bec_widgets.cli.auto_updates import AutoUpdates
 
-if TYPE_CHECKING:  # pragma: no cover
-    from bec_lib.messages import GUIRegistryStateMessage
+if TYPE_CHECKING:
+    from bec_lib.device import DeviceBase
 
-    import bec_widgets.cli.client as client
-else:
-    GUIRegistryStateMessage = lazy_import_from("bec_lib.messages", "GUIRegistryStateMessage")
-    client = lazy_import("bec_widgets.cli.client")
+    from bec_widgets.cli.client import BECDockArea, BECFigure
 
+from bec_lib.serialization import MsgpackSerialization
+
+messages = lazy_import("bec_lib.messages")
+# from bec_lib.connector import MessageObject
+MessageObject = lazy_import_from("bec_lib.connector", ("MessageObject",))
+BECDispatcher = lazy_import_from("bec_widgets.utils.bec_dispatcher", ("BECDispatcher",))
 
 logger = bec_logger.logger
 
-IGNORE_WIDGETS = ["LaunchWindow"]
 
-RegistryState: TypeAlias = dict[
-    Literal["gui_id", "name", "widget_class", "config", "__rpc__", "container_proxy"],
-    str | bool | dict,
-]
-
-# pylint: disable=redefined-outer-scope
-
-
-def _filter_output(output: str) -> str:
+def rpc_call(func):
     """
-    Filter out the output from the process.
+    A decorator for calling a function on the server.
+
+    Args:
+        func: The function to call.
+
+    Returns:
+        The result of the function call.
     """
-    if "IMKClient" in output:
-        # only relevant on macOS
-        # see https://discussions.apple.com/thread/255761734?sortBy=rank
-        return ""
-    return output
+
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        # we could rely on a strict type check here, but this is more flexible
+        # moreover, it would anyway crash for objects...
+        out = []
+        for arg in args:
+            if hasattr(arg, "name"):
+                arg = arg.name
+            out.append(arg)
+        args = tuple(out)
+        for key, val in kwargs.items():
+            if hasattr(val, "name"):
+                kwargs[key] = val.name
+        if not self.gui_is_alive():
+            raise RuntimeError("GUI is not alive")
+        return self._run_rpc(func.__name__, *args, **kwargs)
+
+    return wrapper
 
 
 def _get_output(process, logger) -> None:
-    log_func = {process.stdout: logger.debug, process.stderr: logger.info}
+    log_func = {process.stdout: logger.debug, process.stderr: logger.error}
     stream_buffer = {process.stdout: [], process.stderr: []}
     try:
         os.set_blocking(process.stdout.fileno(), False)
@@ -66,22 +79,15 @@ def _get_output(process, logger) -> None:
                 if stream in readylist:
                     buf.append(stream.read(4096))
                 output, _, remaining = "".join(buf).rpartition("\n")
-                output = _filter_output(output)
                 if output:
                     log_func[stream](output)
                     buf.clear()
                     buf.append(remaining)
     except Exception as e:
-        logger.error(f"Error reading process output: {str(e)}")
+        print(f"Error reading process output: {str(e)}")
 
 
-def _start_plot_process(
-    gui_id: str,
-    gui_class_id: str,
-    config: dict | str,
-    gui_class: str = "dock_area",
-    logger=None,  # FIXME change gui_class back to "launcher" later
-) -> tuple[subprocess.Popen[str], threading.Thread | None]:
+def _start_plot_process(gui_id, gui_class, config, logger=None) -> None:
     """
     Start the plot in a new process.
 
@@ -90,24 +96,12 @@ def _start_plot_process(
     process will not be captured.
     """
     # pylint: disable=subprocess-run-check
-    command = [
-        "bec-gui-server",
-        "--id",
-        gui_id,
-        "--gui_class",
-        gui_class,
-        "--gui_class_id",
-        gui_class_id,
-        "--hide",
-    ]
+    command = ["bec-gui-server", "--id", gui_id, "--gui_class", gui_class.__name__]
     if config:
-        if isinstance(config, dict):
-            config = json.dumps(config)
-        command.extend(["--config", str(config)])
+        command.extend(["--config", config])
 
     env_dict = os.environ.copy()
     env_dict["PYTHONUNBUFFERED"] = "1"
-
     if logger is None:
         stdout_redirect = subprocess.DEVNULL
         stderr_redirect = subprocess.DEVNULL
@@ -133,414 +127,233 @@ def _start_plot_process(
     return process, process_output_processing_thread
 
 
-class RepeatTimer(threading.Timer):
-    """RepeatTimer class."""
-
-    def run(self):
-        while not self.finished.wait(self.interval):
-            self.function(*self.args, **self.kwargs)
-
-
-# pylint: disable=protected-access
-@contextmanager
-def wait_for_server(client: BECGuiClient):
-    """Context manager to wait for the server to start."""
-    timeout = client._startup_timeout
-    if not timeout:
-        if client._gui_is_alive():
-            # there is hope, let's wait a bit
-            timeout = 1
-        else:
-            raise RuntimeError("GUI is not alive")
-    try:
-        if client._gui_started_event.wait(timeout=timeout):
-            if client._gui_started_timer is not None:
-                # cancel the timer, we are done
-                client._gui_started_timer.cancel()
-                client._gui_started_timer.join()
-        else:
-            raise TimeoutError("Could not connect to GUI server")
-    finally:
-        # after initial waiting period, do not wait so much any more
-        # (only relevant if GUI didn't start)
-        client._startup_timeout = 0
-    yield
-
-
-class WidgetNameSpace:
-    def __repr__(self):
-        console = Console()
-        table = Table(title="Available widgets for BEC CLI usage")
-        table.add_column("Widget Name", justify="left", style="magenta")
-        table.add_column("Description", justify="left")
-        for attr, value in self.__dict__.items():
-            docs = value.__doc__
-            docs = docs if docs else "No description available"
-            table.add_row(attr, docs)
-        console.print(table)
-        return ""
-
-
-class AvailableWidgetsNamespace:
-    """Namespace for available widgets in the BEC GUI."""
-
-    def __init__(self):
-        for widget in client.Widgets:
-            name = widget.value
-            if name in IGNORE_WIDGETS:
-                continue
-            setattr(self, name, name)
-
-    def __repr__(self):
-        console = Console()
-        table = Table(title="Available widgets for BEC CLI usage")
-        table.add_column("Widget Name", justify="left", style="magenta")
-        table.add_column("Description", justify="left")
-        for attr_name, _ in self.__dict__.items():
-            docs = getattr(client, attr_name).__doc__
-            docs = docs if docs else "No description available"
-            table.add_row(attr_name, docs if len(docs.strip()) > 0 else "No description available")
-        console.print(table)
-        return ""
-
-
-class BECGuiClient(RPCBase):
-    """BEC GUI client class. Container for GUI applications within Python."""
-
+class BECGuiClientMixin:
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
-        self._lock = Lock()
-        self._anchor_widget = "launcher"
-        self._killed = False
-        self._top_level: dict[str, RPCReference] = {}
-        self._startup_timeout = 0
-        self._gui_started_timer = None
-        self._gui_started_event = threading.Event()
         self._process = None
         self._process_output_processing_thread = None
-        self._server_registry: dict[str, RegistryState] = {}
-        self._ipython_registry: dict[str, RPCReference] = {}
-        self.available_widgets = AvailableWidgetsNamespace()
-        register_serializer_extension()
+        self.auto_updates = self._get_update_script()
+        self._target_endpoint = MessageEndpoints.scan_status()
+        self._selected_device = None
 
-    ####################
-    #### Client API ####
-    ####################
+    def _get_update_script(self) -> AutoUpdates | None:
+        eps = imd.entry_points(group="bec.widgets.auto_updates")
+        for ep in eps:
+            if ep.name == "plugin_widgets_update":
+                try:
+                    spec = importlib.util.find_spec(ep.module)
+                    # if the module is not found, we skip it
+                    if spec is None:
+                        continue
+                    return ep.load()(gui=self)
+                except Exception as e:
+                    print(f"Error loading auto update script from plugin: {str(e)}")
+        return None
 
     @property
-    def launcher(self) -> RPCBase:
-        """The launcher object."""
-        return RPCBase(gui_id=f"{self._gui_id}:launcher", parent=self, object_name="launcher")
+    def selected_device(self):
+        """
+        Selected device for the plot.
+        """
+        return self._selected_device
 
-    def connect_to_gui_server(self, gui_id: str) -> None:
-        """Connect to a GUI server"""
-        # Unregister the old callback
-        self._client.connector.unregister(
-            MessageEndpoints.gui_registry_state(self._gui_id), cb=self._handle_registry_update
-        )
-        self._gui_id = gui_id
+    @selected_device.setter
+    def selected_device(self, device: str | DeviceBase):
+        if isinstance_based_on_class_name(device, "bec_lib.device.DeviceBase"):
+            self._selected_device = device.name
+        elif isinstance(device, str):
+            self._selected_device = device
+        else:
+            raise ValueError("Device must be a string or a device object")
 
-        # reset the namespace
-        self._update_dynamic_namespace({})
-        self._server_registry = {}
-        self._top_level = {}
-        self._ipython_registry = {}
-
-        # Register the new callback
+    def _start_update_script(self) -> None:
         self._client.connector.register(
-            MessageEndpoints.gui_registry_state(self._gui_id),
-            cb=self._handle_registry_update,
-            parent=self,
-            from_start=True,
+            self._target_endpoint, cb=self._handle_msg_update, parent=self
         )
 
-    @property
-    def windows(self) -> dict:
-        """Dictionary with dock areas in the GUI."""
-        return {widget.object_name: widget for widget in self._top_level.values()}
+    @staticmethod
+    def _handle_msg_update(msg: MessageObject, parent: BECGuiClientMixin) -> None:
+        if parent.auto_updates is not None:
+            # pylint: disable=protected-access
+            parent._update_script_msg_parser(msg.value)
 
-    @property
-    def window_list(self) -> list:
-        """List with dock areas in the GUI."""
-        return list(self._top_level.values())
+    def _update_script_msg_parser(self, msg: messages.BECMessage) -> None:
+        if isinstance(msg, messages.ScanStatusMessage):
+            if not self.gui_is_alive():
+                return
+            self.auto_updates.run(msg)
 
-    def start(self, wait: bool = False) -> None:
-        """Start the GUI server."""
-        logger.warning("Using <gui>.start() is deprecated, use <gui>.show() instead.")
-        return self._start(wait=wait)
-
-    def show(self, wait=True) -> None:
+    def show(self) -> None:
         """
-        Show the GUI window.
-        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.
+        Show the figure.
         """
-        if self._check_if_server_is_alive():
-            return self._show_all()
-        return self._start(wait=wait)
+        if self._process is None or self._process.poll() is not None:
+            self._start_update_script()
+            self._process, self._process_output_processing_thread = _start_plot_process(
+                self._gui_id, self.__class__, self._client._service_config.config_path
+            )
+        while not self.gui_is_alive():
+            print("Waiting for GUI to start...")
+            time.sleep(1)
 
-    def hide(self):
-        """Hide the GUI window."""
-        return self._hide_all()
-
-    def new(
-        self,
-        name: str | None = None,
-        wait: bool = True,
-        geometry: tuple[int, int, int, int] | None = None,
-        launch_script: str = "dock_area",
-        **kwargs,
-    ) -> client.BECDockArea:
-        """Create a new top-level dock area.
-
-        Args:
-            name(str, optional): The name of the dock area. Defaults to None.
-            wait(bool, optional): Whether to wait for the server to start. Defaults to True.
-            geometry(tuple[int, int, int, int] | None): The geometry of the dock area (pos_x, pos_y, w, h)
-        Returns:
-            client.BECDockArea: The new dock area.
+    def close(self) -> None:
         """
-        if not self._check_if_server_is_alive():
-            self.start(wait=True)
-        if wait:
-            with wait_for_server(self):
-                widget = self.launcher._run_rpc(
-                    "launch", launch_script=launch_script, name=name, geometry=geometry, **kwargs
-                )  # pylint: disable=protected-access
-                return widget
-        widget = self.launcher._run_rpc(
-            "launch", launch_script=launch_script, name=name, geometry=geometry, **kwargs
-        )  # pylint: disable=protected-access
-        return widget
-
-    def delete(self, name: str) -> None:
-        """Delete a dock area.
-
-        Args:
-            name(str): The name of the dock area.
+        Close the gui window.
         """
-        widget = self.windows.get(name)
-        if widget is None:
-            raise ValueError(f"Dock area {name} not found.")
-        widget._run_rpc("close")  # pylint: disable=protected-access
-
-    def delete_all(self) -> None:
-        """Delete all dock areas."""
-        for widget_name in self.windows:
-            self.delete(widget_name)
-
-    def kill_server(self) -> None:
-        """Kill the GUI server."""
-        # Unregister the registry state
-        self._killed = True
-
-        if self._gui_started_timer is not None:
-            self._gui_started_timer.cancel()
-            self._gui_started_timer.join()
-
         if self._process is None:
             return
 
+        self._client.shutdown()
         if self._process:
-            logger.success("Stopping GUI...")
             self._process.terminate()
             if self._process_output_processing_thread:
                 self._process_output_processing_thread.join()
             self._process.wait()
             self._process = None
 
-        # Unregister the registry state
-        self._client.connector.unregister(
-            MessageEndpoints.gui_registry_state(self._gui_id), cb=self._handle_registry_update
+
+class RPCResponseTimeoutError(Exception):
+    """Exception raised when an RPC response is not received within the expected time."""
+
+    def __init__(self, request_id, timeout):
+        super().__init__(
+            f"RPC response not received within {timeout} seconds for request ID {request_id}"
         )
-        # Remove all reference from top level
-        self._top_level.clear()
-        self._server_registry.clear()
 
-    def close(self):
-        """Deprecated. Use kill_server() instead."""
-        # FIXME, deprecated in favor of kill, will be removed in the future
-        self.kill_server()
 
-    #########################
-    #### Private methods ####
-    #########################
+class QtRedisMessageWaiter:
+    def __init__(self, redis_connector, message_to_wait):
+        self.ev_loop = QEventLoop()
+        self.response = None
+        self.connector = redis_connector
+        self.message_to_wait = message_to_wait
+        self.pubsub = redis_connector._redis_conn.pubsub()
+        self.pubsub.subscribe(self.message_to_wait.endpoint)
+        fd = self.pubsub.connection._sock.fileno()
+        self.notifier = QSocketNotifier(fd, QSocketNotifier.Read)
+        self.notifier.activated.connect(self._pubsub_readable)
 
-    def _check_if_server_is_alive(self):
-        """Checks if the process is alive"""
-        if self._process is None:
-            return False
-        if self._process.poll() is not None:
-            return False
-        return True
+    def _msg_received(self, msg_obj):
+        self.response = msg_obj.value
+        self.ev_loop.quit()
 
-    def _gui_post_startup(self):
-        timeout = 60
-        # Wait for 'bec' gui to be registered, this may take some time
-        # After 60s timeout. Should this raise an exception on timeout?
-        while time.time() < time.time() + timeout:
-            if len(list(self._server_registry.keys())) < 2 or not hasattr(
-                self, self._anchor_widget
-            ):
-                time.sleep(0.1)
+    def wait(self, timeout=1):
+        timer = QTimer()
+        timer.singleShot(timeout * 1000, self.ev_loop.quit)
+        self.ev_loop.exec_()
+        timer.stop()
+        self.notifier.setEnabled(False)
+        self.pubsub.close()
+        return self.response
+
+    def _pubsub_readable(self, fd):
+        while True:
+            msg = self.pubsub.get_message()
+            if msg:
+                if msg["type"] == "subscribe":
+                    # get_message buffers, so we may already have the answer
+                    # let's check...
+                    continue
+                else:
+                    break
             else:
-                break
+                return
+        channel = msg["channel"].decode()
+        msg = MessageObject(topic=channel, value=MsgpackSerialization.loads(msg["data"]))
+        self.connector._execute_callback(self._msg_received, msg, {})
 
-        self._gui_started_event.set()
 
-    def _start_server(self, wait: bool = False) -> None:
+class RPCBase:
+    def __init__(self, gui_id: str = None, config: dict = None, parent=None) -> None:
+        self._client = BECDispatcher().client
+        self._config = config if config is not None else {}
+        self._gui_id = gui_id if gui_id is not None else str(uuid.uuid4())
+        self._parent = parent
+        super().__init__()
+        # print(f"RPCBase: {self._gui_id}")
+
+    def __repr__(self):
+        type_ = type(self)
+        qualname = type_.__qualname__
+        return f"<{qualname} object at {hex(id(self))}>"
+
+    @property
+    def _root(self):
         """
-        Start the GUI server, and execute callback when it is launched
+        Get the root widget. This is the BECFigure widget that holds
+        the anchor gui_id.
         """
-        if self._gui_is_alive():
-            self._gui_started_event.set()
-            return
-        if self._process is None or self._process.poll() is not None:
-            logger.success("GUI starting...")
-            self._startup_timeout = 5
-            self._gui_started_event.clear()
-            self._process, self._process_output_processing_thread = _start_plot_process(
-                self._gui_id,
-                gui_class_id="bec",
-                config=self._client._service_config.config,  # pylint: disable=protected-access
-                logger=logger,
-            )
+        parent = self
+        # pylint: disable=protected-access
+        while parent._parent is not None:
+            parent = parent._parent
+        return parent
 
-            def gui_started_callback(callback):
-                try:
-                    if callable(callback):
-                        callback()
-                finally:
-                    threading.current_thread().cancel()  # type: ignore
+    def _run_rpc(self, method, *args, wait_for_rpc_response=True, timeout=3, **kwargs):
+        """
+        Run the RPC call.
 
-            self._gui_started_timer = RepeatTimer(
-                0.5, lambda: self._gui_is_alive() and gui_started_callback(self._gui_post_startup)
-            )
-            self._gui_started_timer.start()
+        Args:
+            method: The method to call.
+            args: The arguments to pass to the method.
+            wait_for_rpc_response: Whether to wait for the RPC response.
+            kwargs: The keyword arguments to pass to the method.
 
-        if wait:
-            self._gui_started_event.wait()
-
-    def _start(self, wait: bool = False) -> None:
-        self._killed = False
-        self._client.connector.register(
-            MessageEndpoints.gui_registry_state(self._gui_id),
-            cb=self._handle_registry_update,
-            parent=self,
+        Returns:
+            The result of the RPC call.
+        """
+        request_id = str(uuid.uuid4())
+        rpc_msg = messages.GUIInstructionMessage(
+            action=method,
+            parameter={"args": args, "kwargs": kwargs, "gui_id": self._gui_id},
+            metadata={"request_id": request_id},
         )
-        return self._start_server(wait=wait)
 
-    @staticmethod
-    def _handle_registry_update(
-        msg: dict[str, GUIRegistryStateMessage], parent: BECGuiClient
-    ) -> None:
-        # This was causing a deadlock during shutdown, not sure why.
-        # with self._lock:
-        self = parent
-        self._server_registry = cast(dict[str, RegistryState], msg["data"].state)
-        self._update_dynamic_namespace(self._server_registry)
+        # pylint: disable=protected-access
+        receiver = self._root._gui_id
+        if wait_for_rpc_response:
+            redis_msg = QtRedisMessageWaiter(
+                self._client.connector, MessageEndpoints.gui_instruction_response(request_id)
+            )
 
-    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
-        for window in self._top_level.values():
-            window.show()
+        self._client.connector.set_and_publish(MessageEndpoints.gui_instructions(receiver), rpc_msg)
 
-    def _show_all(self):
-        with wait_for_server(self):
-            return self._do_show_all()
+        if wait_for_rpc_response:
+            response = redis_msg.wait(timeout)
 
-    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 response is None:
+                raise RPCResponseTimeoutError(request_id, timeout)
 
-    def _update_dynamic_namespace(self, server_registry: dict):
+            # get class name
+            if not response.accepted:
+                raise ValueError(response.message["error"])
+            msg_result = response.message.get("result")
+            return self._create_widget_from_msg_result(msg_result)
+
+    def _create_widget_from_msg_result(self, msg_result):
+        if msg_result is None:
+            return None
+        if isinstance(msg_result, list):
+            return [self._create_widget_from_msg_result(res) for res in msg_result]
+        if isinstance(msg_result, dict):
+            if "__rpc__" not in msg_result:
+                return {
+                    key: self._create_widget_from_msg_result(val) for key, val in msg_result.items()
+                }
+            cls = msg_result.pop("widget_class", None)
+            msg_result.pop("__rpc__", None)
+
+            if not cls:
+                return msg_result
+
+            cls = getattr(client, cls)
+            # print(msg_result)
+            return cls(parent=self, **msg_result)
+        return msg_result
+
+    def gui_is_alive(self):
         """
-        Update the dynamic name space with the given server registry.
-        Setting the server registry to an empty dictionary will remove all widgets from the namespace.
-
-        Args:
-            server_registry (dict): The server registry
+        Check if the GUI is alive.
         """
-        top_level_widgets: dict[str, RPCReference] = {}
-        for gui_id, state in server_registry.items():
-            widget = self._add_widget(state, self)
-            if widget is None:
-                # ignore widgets that are not supported
-                continue
-            # get all top-level widgets. These are widgets that have no parent
-            if not state["config"].get("parent_id"):
-                top_level_widgets[gui_id] = widget
-
-        remove_from_registry = []
-        for gui_id, widget in self._ipython_registry.items():
-            if gui_id not in server_registry:
-                remove_from_registry.append(gui_id)
-        for gui_id in remove_from_registry:
-            self._ipython_registry.pop(gui_id)
-
-        removed_widgets = [
-            widget.object_name for widget in self._top_level.values() if widget._is_deleted()
-        ]
-
-        for widget_name in removed_widgets:
-            # the check is not strictly necessary, but better safe
-            # than sorry; who knows what the user has done
-            if hasattr(self, widget_name):
-                delattr(self, widget_name)
-
-        for gui_id, widget_ref in top_level_widgets.items():
-            setattr(self, widget_ref.object_name, widget_ref)
-
-        self._top_level = top_level_widgets
-
-        for widget in self._ipython_registry.values():
-            widget._refresh_references()
-
-    def _add_widget(self, state: dict, parent: object) -> RPCReference | None:
-        """Add a widget to the namespace
-
-        Args:
-            state (dict): The state of the widget from the _server_registry.
-            parent (object): The parent object.
-        """
-        object_name = state["object_name"]
-        gui_id = state["gui_id"]
-        if state["widget_class"] in IGNORE_WIDGETS:
-            return
-        widget_class = getattr(client, state["widget_class"], None)
-        if widget_class is None:
-            return
-        obj = self._ipython_registry.get(gui_id)
-        if obj is None:
-            widget = widget_class(gui_id=gui_id, object_name=object_name, parent=parent)
-            self._ipython_registry[gui_id] = widget
-        else:
-            widget = obj
-        obj = RPCReference(registry=self._ipython_registry, gui_id=gui_id)
-        return obj
-
-
-if __name__ == "__main__":  # pragma: no cover
-    from bec_lib.client import BECClient
-    from bec_lib.service_config import ServiceConfig
-
-    try:
-        config = ServiceConfig()
-        bec_client = BECClient(config)
-        bec_client.start()
-
-        # Test the client_utils.py module
-        gui = BECGuiClient()
-
-        gui.show(wait=True)
-        gui.new().new(widget="Waveform")
-        time.sleep(10)
-    finally:
-        gui.kill_server()
+        heart = self._client.connector.get(MessageEndpoints.gui_heartbeat(self._root._gui_id))
+        return heart is not None

bec_widgets/cli/generate_cli.py

@@ -2,21 +2,16 @@
 from __future__ import annotations
 
 import argparse
-import importlib
 import inspect
 import os
 import sys
-from pathlib import Path
+from typing import Literal
 
 import black
 import isort
-from bec_lib.logger import bec_logger
-from qtpy.QtCore import Property as QtProperty
 
-from bec_widgets.utils.generate_designer_plugin import DesignerPluginGenerator, plugin_filenames
-from bec_widgets.utils.plugin_utils import BECClassContainer, get_custom_classes
-
-logger = bec_logger.logger
+from bec_widgets.utils.generate_designer_plugin import DesignerPluginGenerator
+from bec_widgets.utils.plugin_utils import get_rpc_classes
 
 if sys.version_info >= (3, 11):
     from typing import get_overloads
@@ -34,56 +29,28 @@ else:
 
 
 class ClientGenerator:
-    def __init__(self, base=False):
-        self._base = base
-        base_imports = (
-            """import enum
-import inspect
-import traceback
-from functools import reduce
-from operator import add
-from typing import Literal, Optional
-"""
-            if self._base
-            else "\n"
-        )
-        self.header = f"""# This file was automatically generated by generate_cli.py
-# type: ignore \n
-from __future__ import annotations
-{base_imports}
-from bec_lib.logger import bec_logger
+    def __init__(self):
+        self.header = """# This file was automatically generated by generate_cli.py\n
+import enum
+from typing import Literal, Optional, overload
 
-from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call, rpc_timeout
-{"from bec_widgets.utils.bec_plugin_helper import get_all_plugin_widgets, get_plugin_client_module" if self._base else ""}
-
-logger = bec_logger.logger
+from bec_widgets.cli.client_utils import RPCBase, rpc_call, BECGuiClientMixin
 
 # pylint: skip-file"""
 
         self.content = ""
 
-    def generate_client(self, class_container: BECClassContainer):
+    def generate_client(
+        self, published_classes: dict[Literal["connector_classes", "top_level_classes"], list[type]]
+    ):
         """
-        Generate the client for the published classes, skipping any classes
-        that have `RPC = False`.
+        Generate the client for the published classes.
 
         Args:
-            class_container: The class container with the classes to generate the client for.
+            published_classes(dict): A dictionary with keys "connector_classes" and "top_level_classes" and values as lists of classes.
         """
-        # Filter out classes that explicitly have RPC=False
-        rpc_top_level_classes = [
-            cls for cls in class_container.rpc_top_level_classes if getattr(cls, "RPC", True)
-        ]
-        rpc_top_level_classes.sort(key=lambda x: x.__name__)
-
-        connector_classes = [
-            cls for cls in class_container.connector_classes if getattr(cls, "RPC", True)
-        ]
-        connector_classes.sort(key=lambda x: x.__name__)
-
-        self.write_client_enum(rpc_top_level_classes)
-        for cls in connector_classes:
-            logger.debug(f"generating RPC client class for {cls.__name__}")
+        self.write_client_enum(published_classes["top_level_classes"])
+        for cls in published_classes["connector_classes"]:
             self.content += "\n\n"
             self.generate_content_for_class(cls)
 
@@ -91,50 +58,14 @@ logger = bec_logger.logger
         """
         Write the client enum to the content.
         """
-        if self._base:
-            self.content += """
-class _WidgetsEnumType(str, enum.Enum):
-    \"\"\" Enum for the available widgets, to be generated programatically  \"\"\"
-    ...
-    """
-
         self.content += """
-
-_Widgets = {
+class Widgets(str, enum.Enum):
+    \"\"\"
+    Enum for the available widgets.
+    \"\"\"
     """
         for cls in published_classes:
-            self.content += f'"{cls.__name__}": "{cls.__name__}",\n    '
-
-        self.content += """}
-"""
-        if self._base:
-            self.content += """
-
-try:
-    _plugin_widgets = get_all_plugin_widgets().as_dict()
-    plugin_client = get_plugin_client_module()
-    Widgets = _WidgetsEnumType("Widgets", {name: name for name in _plugin_widgets} | _Widgets)
-
-    if (_overlap := _Widgets.keys() & _plugin_widgets.keys()) != set():
-        for _widget in _overlap:
-            logger.warning(f"Detected duplicate widget {_widget} in plugin repo file: {inspect.getfile(_plugin_widgets[_widget])} !")
-    for plugin_name, plugin_class in inspect.getmembers(plugin_client, inspect.isclass):
-        if issubclass(plugin_class, RPCBase) and plugin_class is not RPCBase:
-            if plugin_name in globals():
-                conflicting_file = (
-                    inspect.getfile(_plugin_widgets[plugin_name])
-                    if plugin_name in _plugin_widgets
-                    else f"{plugin_client}"
-                )
-                logger.warning(
-                    f"Plugin widget {plugin_name} from {conflicting_file} conflicts with a built-in class!"
-                )
-                continue
-            if plugin_name not in _overlap:
-                globals()[plugin_name] = plugin_class
-except ImportError as e:
-    logger.error(f"Failed loading plugins: \\n{reduce(add, traceback.format_exception(e))}")
-"""
+            self.content += f'{cls.__name__} = "{cls.__name__}"\n    '
 
     def generate_content_for_class(self, cls):
         """
@@ -146,55 +77,22 @@ except ImportError as e:
 
         class_name = cls.__name__
 
-        if class_name == "BECDockArea":
+        # Generate the content
+        if cls.__name__ == "BECDockArea":
             self.content += f"""
-class {class_name}(RPCBase):"""
+class {class_name}(RPCBase, BECGuiClientMixin):"""
         else:
             self.content += f"""
 class {class_name}(RPCBase):"""
-
-        if cls.__doc__:
-            # We only want the first line of the docstring
-            # But skip the first line if it's a blank line
-            first_line = cls.__doc__.split("\n")[0]
-            if first_line:
-                class_docs = first_line
-            else:
-                class_docs = cls.__doc__.split("\n")[1]
-            self.content += f"""
-    \"\"\"{class_docs}\"\"\"
-    """
         if not cls.USER_ACCESS:
             self.content += """...
     """
-
         for method in cls.USER_ACCESS:
-            is_property_setter = False
-            obj = getattr(cls, method, None)
-            if obj is None:
-                obj = getattr(cls, method.split(".setter")[0], None)
-                is_property_setter = True
-                method = method.split(".setter")[0]
-            if obj is None:
-                raise AttributeError(
-                    f"Method {method} not found in class {cls.__name__}. "
-                    f"Please check the USER_ACCESS list."
-                )
-            if hasattr(obj, "__rpc_timeout__"):
-                timeout = {"value": obj.__rpc_timeout__}
-            else:
-                timeout = {}
-            if isinstance(obj, (property, QtProperty)):
-                # for the cli, we can map qt properties to regular properties
-                if is_property_setter:
-                    self.content += f"""
-    @{method}.setter
-    @rpc_call"""
-                else:
-                    self.content += """
+            obj = getattr(cls, method)
+            if isinstance(obj, property):
+                self.content += """
     @property
     @rpc_call"""
-
                 sig = str(inspect.signature(obj.fget))
                 doc = inspect.getdoc(obj.fget)
             else:
@@ -208,26 +106,14 @@ class {class_name}(RPCBase):"""
     def {method}{str(sig_overload)}: ...
     """
 
-                self.content += f"""
-    {self._rpc_call(timeout)}"""
+                self.content += """
+    @rpc_call"""
             self.content += f"""
     def {method}{str(sig)}:
         \"\"\"
 {doc}
         \"\"\""""
 
-    def _rpc_call(self, timeout_info: dict[str, float | None]):
-        """
-        Decorator to mark a method as an RPC call.
-        This is used to generate the client code for the method.
-        """
-        if not timeout_info:
-            return "@rpc_call"
-        timeout = timeout_info.get("value", None)
-        return f"""
-    @rpc_timeout({timeout})
-    @rpc_call"""
-
     def write(self, file_name: str):
         """
         Write the content to a file, automatically formatted with black.
@@ -238,18 +124,18 @@ class {class_name}(RPCBase):"""
         # Combine header and content, then format with black
         full_content = self.header + "\n" + self.content
         try:
-            formatted_content = black.format_str(full_content, mode=black.Mode(line_length=100))
+            formatted_content = black.format_str(full_content, mode=black.FileMode(line_length=100))
         except black.NothingChanged:
             formatted_content = full_content
 
-        config = isort.Config(
+        isort.Config(
             profile="black",
             line_length=100,
             multi_line_output=3,
-            include_trailing_comma=False,
+            include_trailing_comma=True,
             known_first_party=["bec_widgets"],
         )
-        formatted_content = isort.code(formatted_content, config=config)
+        formatted_content = isort.code(formatted_content)
 
         with open(file_name, "w", encoding="utf-8") as file:
             file.write(formatted_content)
@@ -261,78 +147,42 @@ def main():
     """
 
     parser = argparse.ArgumentParser(description="Auto-generate the client for RPC widgets")
-    parser.add_argument(
-        "--target",
-        action="store",
-        type=str,
-        help="Which package to generate plugin files for. Should be installed in the local environment (example: my_plugin_repo)",
-    )
+    parser.add_argument("--core", action="store_true", help="Whether to generate the core client")
 
     args = parser.parse_args()
-    if args.target is None:
-        logger.error(
-            "You must provide a target - for safety, the default of running this on bec_widgets core has been removed. To generate the client for bec_widgets, run `bw-generate-cli --target bec_widgets`"
-        )
-        return
 
-    logger.info(f"BEC Widget code generation tool started with args: {args}")
+    if args.core:
+        current_path = os.path.dirname(__file__)
+        client_path = os.path.join(current_path, "client.py")
 
-    client_subdir = "cli" if args.target == "bec_widgets" else "widgets"
-    module_name = "bec_widgets" if args.target == "bec_widgets" else f"{args.target}.bec_widgets"
+        rpc_classes = get_rpc_classes("bec_widgets")
+        rpc_classes["connector_classes"].sort(key=lambda x: x.__name__)
 
-    try:
-        module = importlib.import_module(module_name)
-        assert module.__file__ is not None
-        module_file = Path(module.__file__)
-        module_dir = module_file.parent if module_file.is_file() else module_file
-    except Exception as e:
-        logger.error(f"Failed to load module {module_name} for code generation: {e}")
-        return
+        generator = ClientGenerator()
+        generator.generate_client(rpc_classes)
+        generator.write(client_path)
 
-    client_path = module_dir / client_subdir / "client.py"
+        for cls in rpc_classes["top_level_classes"]:
+            plugin = DesignerPluginGenerator(cls)
+            if not hasattr(plugin, "info"):
+                continue
 
-    rpc_classes = get_custom_classes(module_name)
-    logger.info(f"Obtained classes with RPC objects: {rpc_classes!r}")
-
-    generator = ClientGenerator(base=module_name == "bec_widgets")
-    logger.info(f"Generating client file at {client_path}")
-    generator.generate_client(rpc_classes)
-    generator.write(str(client_path))
-
-    if module_name != "bec_widgets":
-        non_overwrite_classes = list(clsinfo.name for clsinfo in get_custom_classes("bec_widgets"))
-        logger.info(
-            f"Not writing plugins which would conflict with builtin classes: {non_overwrite_classes}"
-        )
-    else:
-        non_overwrite_classes = []
-
-    for cls in rpc_classes.plugins:
-        logger.info(f"Writing bec-designer plugin files for {cls.__name__}...")
-
-        if cls.__name__ in non_overwrite_classes:
-            logger.error(
-                f"Not writing plugin files for {cls.__name__} because a built-in widget with that name exists"
-            )
-
-        plugin = DesignerPluginGenerator(cls)
-        if not hasattr(plugin, "info"):
-            continue
-
-        def _exists(file: str):
-            return os.path.exists(os.path.join(plugin.info.base_path, file))
-
-        if any(_exists(file) for file in plugin_filenames(plugin.info.plugin_name_snake)):
-            logger.debug(
-                f"Skipping generation of extra plugin files for {plugin.info.plugin_name_snake} - at least one file out of 'plugin.py', 'pyproject', and 'register_{plugin.info.plugin_name_snake}.py' already exists."
-            )
-            continue
-
-        plugin.run()
+            # if the class directory already has a register, plugin and pyproject file, skip
+            if os.path.exists(
+                os.path.join(plugin.info.base_path, f"register_{plugin.info.plugin_name_snake}.py")
+            ):
+                continue
+            if os.path.exists(
+                os.path.join(plugin.info.base_path, f"{plugin.info.plugin_name_snake}_plugin.py")
+            ):
+                continue
+            if os.path.exists(
+                os.path.join(plugin.info.base_path, f"{plugin.info.plugin_name_snake}.pyproject")
+            ):
+                continue
+            plugin.run()
 
 
 if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    sys.argv = ["bw-generate-cli", "--target", "bec_widgets"]
+    sys.argv = ["generate_cli.py", "--core"]
     main()

bec_widgets/cli/rpc/rpc_base.py

@@ -1,338 +0,0 @@
-from __future__ import annotations
-
-import inspect
-import threading
-import uuid
-from functools import wraps
-from typing import TYPE_CHECKING, Any, cast
-
-from bec_lib.client import BECClient
-from bec_lib.device import DeviceBaseWithConfig
-from bec_lib.endpoints import MessageEndpoints
-from bec_lib.utils.import_utils import lazy_import, lazy_import_from
-
-if TYPE_CHECKING:  # pragma: no cover
-    from bec_lib import messages
-    from bec_lib.connector import MessageObject
-
-    import bec_widgets.cli.client as client
-    from bec_widgets.cli.client_utils import BECGuiClient
-else:
-    client = lazy_import("bec_widgets.cli.client")  # avoid circular import
-    messages = lazy_import("bec_lib.messages")
-    MessageObject = lazy_import_from("bec_lib.connector", ("MessageObject",))
-
-# pylint: disable=protected-access
-
-
-def _name_arg(arg):
-    if isinstance(arg, DeviceBaseWithConfig):
-        # if dev.<device> is passed to GUI, it passes full_name
-        if hasattr(arg, "full_name"):
-            return arg.full_name
-    elif hasattr(arg, "name"):
-        return arg.name
-    return arg
-
-
-def _transform_args_kwargs(args, kwargs) -> tuple[tuple, dict]:
-    return tuple(_name_arg(arg) for arg in args), {k: _name_arg(v) for k, v in kwargs.items()}
-
-
-def rpc_timeout(timeout):
-    """
-    A decorator to set a timeout for an RPC call.
-
-    Args:
-        timeout: The timeout in seconds.
-
-    Returns:
-        The decorated function.
-    """
-
-    def decorator(func):
-        @wraps(func)
-        def wrapper(self, *args, **kwargs):
-            if "timeout" not in kwargs:
-                kwargs["timeout"] = timeout
-            return func(self, *args, **kwargs)
-
-        return wrapper
-
-    return decorator
-
-
-def rpc_call(func):
-    """
-    A decorator for calling a function on the server.
-
-    Args:
-        func: The function to call.
-
-    Returns:
-        The result of the function call.
-    """
-
-    @wraps(func)
-    def wrapper(self, *args, **kwargs):
-        # we could rely on a strict type check here, but this is more flexible
-        # moreover, it would anyway crash for objects...
-        caller_frame = inspect.currentframe().f_back  # type: ignore
-        while caller_frame:
-            if "jedi" in caller_frame.f_globals:
-                # Jedi module is present, likely tab completion
-                # Do not run the RPC call
-                return None  # func(*args, **kwargs)
-            caller_frame = caller_frame.f_back
-
-        args, kwargs = _transform_args_kwargs(args, kwargs)
-        if not self._root._gui_is_alive():
-            raise RuntimeError("GUI is not alive")
-        return self._run_rpc(func.__name__, *args, **kwargs)
-
-    return wrapper
-
-
-class RPCResponseTimeoutError(Exception):
-    """Exception raised when an RPC response is not received within the expected time."""
-
-    def __init__(self, request_id, timeout):
-        super().__init__(
-            f"RPC response not received within {timeout} seconds for request ID {request_id}"
-        )
-
-
-class DeletedWidgetError(Exception): ...
-
-
-def check_for_deleted_widget(func):
-    @wraps(func)
-    def wrapper(self, *args, **kwargs):
-        if self._gui_id not in self._registry:
-            raise DeletedWidgetError(f"Widget with gui_id {self._gui_id} has been deleted")
-        return func(self, *args, **kwargs)
-
-    return wrapper
-
-
-class RPCReference:
-    def __init__(self, registry: dict, gui_id: str) -> None:
-        self._registry = registry
-        self._gui_id = gui_id
-        self.object_name = self._registry[self._gui_id].object_name
-
-    @check_for_deleted_widget
-    def __getattr__(self, name):
-        if name in ["_registry", "_gui_id", "_is_deleted", "object_name"]:
-            return super().__getattribute__(name)
-        return self._registry[self._gui_id].__getattribute__(name)
-
-    def __setattr__(self, name, value):
-        if name in ["_registry", "_gui_id", "_is_deleted", "object_name"]:
-            return super().__setattr__(name, value)
-        if self._gui_id not in self._registry:
-            raise DeletedWidgetError(f"Widget with gui_id {self._gui_id} has been deleted")
-        self._registry[self._gui_id].__setattr__(name, value)
-
-    def __repr__(self):
-        if self._gui_id not in self._registry:
-            return f"<Deleted widget with gui_id {self._gui_id}>"
-        return self._registry[self._gui_id].__repr__()
-
-    def __str__(self):
-        if self._gui_id not in self._registry:
-            return f"<Deleted widget with gui_id {self._gui_id}>"
-        return self._registry[self._gui_id].__str__()
-
-    def __dir__(self):
-        if self._gui_id not in self._registry:
-            return []
-        return self._registry[self._gui_id].__dir__()
-
-    def _is_deleted(self) -> bool:
-        return self._gui_id not in self._registry
-
-
-class RPCBase:
-    def __init__(
-        self,
-        gui_id: str | None = None,
-        config: dict | None = None,
-        object_name: str | None = None,
-        parent=None,
-        **kwargs,
-    ) -> None:
-        self._client = BECClient()  # BECClient is a singleton; here, we simply get the instance
-        self._config = config if config is not None else {}
-        self._gui_id = gui_id if gui_id is not None else str(uuid.uuid4())[:5]
-        self.object_name = object_name if object_name is not None else str(uuid.uuid4())[:5]
-        self._parent = parent
-        self._msg_wait_event = threading.Event()
-        self._rpc_response = None
-        super().__init__()
-        self._rpc_references: dict[str, str] = {}
-
-    def __repr__(self):
-        type_ = type(self)
-        qualname = type_.__qualname__
-        return f"<{qualname} with name: {self.object_name}>"
-
-    def remove(self):
-        """
-        Remove the widget.
-        """
-        obj = self._root._server_registry.get(self._gui_id)
-        if obj is None:
-            raise ValueError(f"Widget {self._gui_id} not found.")
-        if proxy := obj.get("container_proxy"):
-            assert isinstance(proxy, str)
-            self._run_rpc("remove", gui_id=proxy)
-            return
-        self._run_rpc("remove")
-
-    @property
-    def _root(self) -> BECGuiClient:
-        """
-        Get the root widget. This is the BECFigure widget that holds
-        the anchor gui_id.
-        """
-        parent = self
-        # pylint: disable=protected-access
-        while parent._parent is not None:
-            parent = parent._parent
-        return parent  # type: ignore
-
-    def _run_rpc(
-        self,
-        method,
-        *args,
-        wait_for_rpc_response=True,
-        timeout=5,
-        gui_id: str | None = None,
-        **kwargs,
-    ) -> Any:
-        """
-        Run the RPC call.
-
-        Args:
-            method: The method to call.
-            args: The arguments to pass to the method.
-            wait_for_rpc_response: Whether to wait for the RPC response.
-            timeout: The timeout for the RPC response.
-            gui_id: The GUI ID to use for the RPC call. If None, the default GUI ID is used.
-            kwargs: The keyword arguments to pass to the method.
-
-        Returns:
-            The result of the RPC call.
-        """
-        request_id = str(uuid.uuid4())
-        rpc_msg = messages.GUIInstructionMessage(
-            action=method,
-            parameter={"args": args, "kwargs": kwargs, "gui_id": gui_id or self._gui_id},
-            metadata={"request_id": request_id},
-        )
-        # pylint: disable=protected-access
-        receiver = self._root._gui_id
-        if wait_for_rpc_response:
-            self._rpc_response = None
-            self._msg_wait_event.clear()
-            self._client.connector.register(
-                MessageEndpoints.gui_instruction_response(request_id),
-                cb=self._on_rpc_response,
-                parent=self,
-            )
-
-        self._client.connector.set_and_publish(MessageEndpoints.gui_instructions(receiver), rpc_msg)
-
-        if wait_for_rpc_response:
-            try:
-                finished = self._msg_wait_event.wait(timeout)
-                if not finished:
-                    raise RPCResponseTimeoutError(request_id, timeout)
-            finally:
-                self._msg_wait_event.clear()
-                self._client.connector.unregister(
-                    MessageEndpoints.gui_instruction_response(request_id), cb=self._on_rpc_response
-                )
-
-            # we can assume that the response is a RequestResponseMessage, updated by
-            # the _on_rpc_response method
-            assert isinstance(self._rpc_response, messages.RequestResponseMessage)
-
-            if not self._rpc_response.accepted:
-                raise ValueError(self._rpc_response.message["error"])
-            msg_result = self._rpc_response.message.get("result")
-            self._rpc_response = None
-            return self._create_widget_from_msg_result(msg_result)
-
-    @staticmethod
-    def _on_rpc_response(msg_obj: MessageObject, parent: RPCBase) -> None:
-        msg = cast(messages.RequestResponseMessage, msg_obj.value)
-        parent._rpc_response = msg
-        parent._msg_wait_event.set()
-
-    def _create_widget_from_msg_result(self, msg_result):
-        if msg_result is None:
-            return None
-        if isinstance(msg_result, list):
-            return [self._create_widget_from_msg_result(res) for res in msg_result]
-        if isinstance(msg_result, dict):
-            if "__rpc__" not in msg_result:
-                return {
-                    key: self._create_widget_from_msg_result(val) for key, val in msg_result.items()
-                }
-            cls = msg_result.pop("widget_class", None)
-            msg_result.pop("__rpc__", None)
-
-            if not cls:
-                return msg_result
-
-            cls = getattr(client, cls)
-            # The namespace of the object will be updated dynamically on the client side
-            # Therefore it is important to check if the object is already in the registry
-            # If yes, we return the reference to the object, otherwise we create a new object
-            # pylint: disable=protected-access
-            if msg_result["gui_id"] in self._root._ipython_registry:
-                return RPCReference(self._root._ipython_registry, msg_result["gui_id"])
-            ret = cls(parent=self, **msg_result)
-            self._root._ipython_registry[ret._gui_id] = ret
-            self._refresh_references()
-            obj = RPCReference(self._root._ipython_registry, ret._gui_id)
-            return obj
-            # return ret
-        return msg_result
-
-    def _gui_is_alive(self):
-        """
-        Check if the GUI is alive.
-        """
-        heart = self._client.connector.get(MessageEndpoints.gui_heartbeat(self._root._gui_id))
-        if heart is None:
-            return False
-        if heart.status == messages.BECStatus.RUNNING:
-            return True
-        return False
-
-    def _refresh_references(self):
-        """
-        Refresh the references.
-        """
-        with self._root._lock:
-            references = {}
-            for key, val in self._root._server_registry.items():
-                parent_id = val["config"].get("parent_id")
-                if parent_id == self._gui_id:
-                    references[key] = {
-                        "gui_id": val["config"]["gui_id"],
-                        "object_name": val["object_name"],
-                    }
-            removed_references = set(self._rpc_references.keys()) - set(references.keys())
-            for key in removed_references:
-                delattr(self, self._rpc_references[key]["object_name"])
-            self._rpc_references = references
-            for key, val in references.items():
-                setattr(
-                    self,
-                    val["object_name"],
-                    RPCReference(self._root._ipython_registry, val["gui_id"]),
-                )

bec_widgets/cli/rpc/rpc_register.py

@@ -1,189 +0,0 @@
-from __future__ import annotations
-
-from functools import wraps
-from threading import RLock
-from typing import TYPE_CHECKING, Callable
-from weakref import WeakValueDictionary
-
-from bec_lib.logger import bec_logger
-from qtpy.QtCore import QObject
-
-if TYPE_CHECKING:  # pragma: no cover
-    from bec_widgets.utils.bec_connector import BECConnector
-    from bec_widgets.utils.bec_widget import BECWidget
-    from bec_widgets.widgets.containers.dock.dock import BECDock
-    from bec_widgets.widgets.containers.dock.dock_area import BECDockArea
-
-logger = bec_logger.logger
-
-
-def broadcast_update(func):
-    """
-    Decorator to broadcast updates to the RPCRegister whenever a new RPC object is added or removed.
-    If class attribute _skip_broadcast is set to True, the broadcast will be skipped
-    """
-
-    @wraps(func)
-    def wrapper(self, *args, **kwargs):
-        result = func(self, *args, **kwargs)
-        self.broadcast()
-        return result
-
-    return wrapper
-
-
-class RPCRegister:
-    """
-    A singleton class that keeps track of all the RPC objects registered in the system for CLI usage.
-    """
-
-    _instance = None
-    _initialized = False
-
-    def __new__(cls, *args, **kwargs):
-        if cls._instance is None:
-            cls._instance = super(RPCRegister, cls).__new__(cls)
-            cls._initialized = False
-        return cls._instance
-
-    def __init__(self):
-        if self._initialized:
-            return
-        self._rpc_register = WeakValueDictionary()
-        self._broadcast_on_hold = RPCRegisterBroadcast(self)
-        self._lock = RLock()
-        self._skip_broadcast = False
-        self._initialized = True
-        self.callbacks = []
-
-    @classmethod
-    def delayed_broadcast(cls):
-        """
-        Delay the broadcast of the update to all the callbacks.
-        """
-        register = cls()
-        return register._broadcast_on_hold
-
-    @broadcast_update
-    def add_rpc(self, rpc: BECConnector):
-        """
-        Add an RPC object to the register.
-
-        Args:
-            rpc(QObject): The RPC object to be added to the register.
-        """
-        if not hasattr(rpc, "gui_id"):
-            raise ValueError("RPC object must have a 'gui_id' attribute.")
-        self._rpc_register[rpc.gui_id] = rpc
-
-    @broadcast_update
-    def remove_rpc(self, rpc: BECConnector):
-        """
-        Remove an RPC object from the register.
-
-        Args:
-            rpc(str): The RPC object to be removed from the register.
-        """
-        if not hasattr(rpc, "gui_id"):
-            raise ValueError(f"RPC object {rpc} must have a 'gui_id' attribute.")
-        self._rpc_register.pop(rpc.gui_id, None)
-
-    def get_rpc_by_id(self, gui_id: str) -> QObject | None:
-        """
-        Get an RPC object by its ID.
-
-        Args:
-            gui_id(str): The ID of the RPC object to be retrieved.
-
-        Returns:
-            QObject | None: The RPC object with the given ID or None
-        """
-        rpc_object = self._rpc_register.get(gui_id, None)
-        return rpc_object
-
-    def list_all_connections(self) -> dict:
-        """
-        List all the registered RPC objects.
-
-        Returns:
-            dict: A dictionary containing all the registered RPC objects.
-        """
-        with self._lock:
-            connections = dict(self._rpc_register)
-        return connections
-
-    def get_names_of_rpc_by_class_type(
-        self, cls: type[BECWidget] | type[BECConnector] | type[BECDock] | type[BECDockArea]
-    ) -> list[str]:
-        """Get all the names of the widgets.
-
-        Args:
-            cls(BECWidget | BECConnector): The class of the RPC object to be retrieved.
-        """
-        # This retrieves any rpc objects that are subclass of BECWidget,
-        # i.e. curve and image items are excluded
-        widgets = [rpc for rpc in self._rpc_register.values() if isinstance(rpc, cls)]
-        return [widget.object_name for widget in widgets]
-
-    def broadcast(self):
-        """
-        Broadcast the update to all the callbacks.
-        """
-
-        if self._skip_broadcast:
-            return
-        connections = self.list_all_connections()
-        for callback in self.callbacks:
-            callback(connections)
-
-    def object_is_registered(self, obj: BECConnector) -> bool:
-        """
-        Check if an object is registered in the RPC register.
-
-        Args:
-            obj(QObject): The object to check.
-
-        Returns:
-            bool: True if the object is registered, False otherwise.
-        """
-        return obj.gui_id in self._rpc_register
-
-    def add_callback(self, callback: Callable[[dict], None]):
-        """
-        Add a callback that will be called whenever the registry is updated.
-
-        Args:
-            callback(Callable[[dict], None]): The callback to be added. It should accept a dictionary of all the
-            registered RPC objects as an argument.
-        """
-        self.callbacks.append(callback)
-
-    @classmethod
-    def reset_singleton(cls):
-        """
-        Reset the singleton instance.
-        """
-        cls._instance = None
-        cls._initialized = False
-
-
-class RPCRegisterBroadcast:
-    """Context manager for RPCRegister broadcast."""
-
-    def __init__(self, rpc_register: RPCRegister) -> None:
-        self.rpc_register = rpc_register
-        self._call_depth = 0
-
-    def __enter__(self):
-        """Enter the context manager"""
-        self._call_depth += 1  # Needed for nested calls
-        self.rpc_register._skip_broadcast = True
-        return self.rpc_register
-
-    def __exit__(self, *exc):
-        """Exit the context manager"""
-
-        self._call_depth -= 1  # Remove nested calls
-        if self._call_depth == 0:  # The Last one to exit is responsible for broadcasting
-            self.rpc_register._skip_broadcast = False
-        self.rpc_register.broadcast()

bec_widgets/cli/rpc_register.py

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

bec_widgets/cli/rpc_wigdet_handler.py

@@ -1,9 +1,4 @@
-from __future__ import annotations
-
-from bec_widgets.cli.client_utils import IGNORE_WIDGETS
-from bec_widgets.utils.bec_plugin_helper import get_all_plugin_widgets
-from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.plugin_utils import get_custom_classes
+from bec_widgets.utils import BECConnector
 
 
 class RPCWidgetHandler:
@@ -13,7 +8,7 @@ class RPCWidgetHandler:
         self._widget_classes = None
 
     @property
-    def widget_classes(self) -> dict[str, type[BECWidget]]:
+    def widget_classes(self):
         """
         Get the available widget classes.
 
@@ -22,7 +17,7 @@ class RPCWidgetHandler:
         """
         if self._widget_classes is None:
             self.update_available_widgets()
-        return self._widget_classes  # type: ignore
+        return self._widget_classes
 
     def update_available_widgets(self):
         """
@@ -31,23 +26,25 @@ class RPCWidgetHandler:
         Returns:
             None
         """
-        self._widget_classes = (
-            get_custom_classes("bec_widgets") + get_all_plugin_widgets()
-        ).as_dict(IGNORE_WIDGETS)
+        from bec_widgets.utils.plugin_utils import get_rpc_classes
 
-    def create_widget(self, widget_type, **kwargs) -> BECWidget:
+        clss = get_rpc_classes("bec_widgets")
+        self._widget_classes = {cls.__name__: cls for cls in clss["top_level_classes"]}
+
+    def create_widget(self, widget_type, **kwargs) -> BECConnector:
         """
         Create a widget from an RPC message.
 
         Args:
             widget_type(str): The type of the widget.
-            name (str): The name of the widget.
             **kwargs: The keyword arguments for the widget.
 
         Returns:
-            widget(BECWidget): The created widget.
+            widget(BECConnector): The created widget.
         """
-        widget_class = self.widget_classes.get(widget_type)  # type: ignore
+        if self._widget_classes is None:
+            self.update_available_widgets()
+        widget_class = self._widget_classes.get(widget_type)
         if widget_class:
             return widget_class(**kwargs)
         raise ValueError(f"Unknown widget type: {widget_type}")

bec_widgets/cli/server.py

@@ -1,191 +1,219 @@
 from __future__ import annotations
 
-import argparse
-import json
-import os
+import inspect
 import signal
 import sys
 from contextlib import redirect_stderr, redirect_stdout
+from typing import Union
 
-import darkdetect
+from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import bec_logger
 from bec_lib.service_config import ServiceConfig
-from bec_qthemes import apply_theme
-from qtmonaco.pylsp_provider import pylsp_server
-from qtpy.QtCore import QSize, Qt
-from qtpy.QtGui import QIcon
-from qtpy.QtWidgets import QApplication
+from bec_lib.utils.import_utils import lazy_import
+from qtpy.QtCore import QTimer
 
-import bec_widgets
-from bec_widgets.applications.launch_window import LaunchWindow
-from bec_widgets.cli.rpc.rpc_register import RPCRegister
-from bec_widgets.utils.bec_dispatcher import BECDispatcher
+from bec_widgets.cli.rpc_register import RPCRegister
+from bec_widgets.utils import BECDispatcher
+from bec_widgets.utils.bec_connector import BECConnector
+from bec_widgets.utils.bec_dispatcher import QtRedisConnector
+from bec_widgets.widgets.dock.dock_area import BECDockArea
+from bec_widgets.widgets.figure import BECFigure
 
+messages = lazy_import("bec_lib.messages")
 logger = bec_logger.logger
 
-MODULE_PATH = os.path.dirname(bec_widgets.__file__)
+
+class BECWidgetsCLIServer:
+
+    def __init__(
+        self,
+        gui_id: str = None,
+        dispatcher: BECDispatcher = None,
+        client=None,
+        config=None,
+        gui_class: Union[BECFigure, BECDockArea] = BECFigure,
+    ) -> None:
+        self.dispatcher = BECDispatcher(config=config) if dispatcher is None else dispatcher
+        self.client = self.dispatcher.client if client is None else client
+        self.client.start()
+        self.gui_id = gui_id
+        self.gui = gui_class(gui_id=self.gui_id)
+        self.rpc_register = RPCRegister()
+        self.rpc_register.add_rpc(self.gui)
+
+        self.dispatcher.connect_slot(
+            self.on_rpc_update, MessageEndpoints.gui_instructions(self.gui_id)
+        )
+
+        # Setup QTimer for heartbeat
+        self._shutdown_event = False
+        self._heartbeat_timer = QTimer()
+        self._heartbeat_timer.timeout.connect(self.emit_heartbeat)
+        self._heartbeat_timer.start(200)
+
+    def on_rpc_update(self, msg: dict, metadata: dict):
+        request_id = metadata.get("request_id")
+        try:
+            obj = self.get_object_from_config(msg["parameter"])
+            method = msg["action"]
+            args = msg["parameter"].get("args", [])
+            kwargs = msg["parameter"].get("kwargs", {})
+            res = self.run_rpc(obj, method, args, kwargs)
+        except Exception as e:
+            print(e)
+            self.send_response(request_id, False, {"error": str(e)})
+        else:
+            self.send_response(request_id, True, {"result": res})
+
+    def send_response(self, request_id: str, accepted: bool, msg: dict):
+        self.client.connector.set_and_publish(
+            MessageEndpoints.gui_instruction_response(request_id),
+            messages.RequestResponseMessage(accepted=accepted, message=msg),
+            expire=60,
+        )
+
+    def get_object_from_config(self, config: dict):
+        gui_id = config.get("gui_id")
+        obj = self.rpc_register.get_rpc_by_id(gui_id)
+        if obj is None:
+            raise ValueError(f"Object with gui_id {gui_id} not found")
+        return obj
+
+    def run_rpc(self, obj, method, args, kwargs):
+        method_obj = getattr(obj, method)
+        # check if the method accepts args and kwargs
+        if not callable(method_obj):
+            res = method_obj
+        else:
+            sig = inspect.signature(method_obj)
+            if sig.parameters:
+                res = method_obj(*args, **kwargs)
+            else:
+                res = method_obj()
+
+        if isinstance(res, list):
+            res = [self.serialize_object(obj) for obj in res]
+        elif isinstance(res, dict):
+            res = {key: self.serialize_object(val) for key, val in res.items()}
+        else:
+            res = self.serialize_object(res)
+        return res
+
+    def serialize_object(self, obj):
+        if isinstance(obj, BECConnector):
+            return {
+                "gui_id": obj.gui_id,
+                "widget_class": obj.__class__.__name__,
+                "config": obj.config.model_dump(),
+                "__rpc__": True,
+            }
+        return obj
+
+    def emit_heartbeat(self):
+        if self._shutdown_event is False:
+            self.client.connector.set(
+                MessageEndpoints.gui_heartbeat(self.gui_id),
+                messages.StatusMessage(name=self.gui_id, status=1, info={}),
+                expire=1,
+            )
+
+    def shutdown(self):  # TODO not sure if needed when cleanup is done at level of BECConnector
+        self._shutdown_event = True
+        self._heartbeat_timer.stop()
+        self.gui.close()
+        self.client.shutdown()
 
 
 class SimpleFileLikeFromLogOutputFunc:
     def __init__(self, log_func):
         self._log_func = log_func
-        self._buffer = []
 
     def write(self, buffer):
-        self._buffer.append(buffer)
+        for line in buffer.rstrip().splitlines():
+            line = line.rstrip()
+            if line:
+                self._log_func(line)
 
     def flush(self):
-        lines, _, remaining = "".join(self._buffer).rpartition("\n")
-        if lines:
-            self._log_func(lines)
-        self._buffer = [remaining]
-
-    @property
-    def encoding(self):
-        return "utf-8"
+        return
 
     def close(self):
         return
 
 
-class GUIServer:
-    """
-    This class is used to start the BEC GUI and is the main entry point for launching BEC Widgets in a subprocess.
-    """
-
-    def __init__(self, args):
-        self.config = args.config
-        self.gui_id = args.id
-        self.gui_class = args.gui_class
-        self.gui_class_id = args.gui_class_id
-        self.hide = args.hide
-        self.app: QApplication | None = None
-        self.launcher_window: LaunchWindow | None = None
-        self.dispatcher: BECDispatcher | None = None
-
-    def start(self):
-        """
-        Start the GUI server.
-        """
-        bec_logger.level = bec_logger.LOGLEVEL.INFO
-        if self.hide:
-            # pylint: disable=protected-access
-            bec_logger._stderr_log_level = bec_logger.LOGLEVEL.ERROR
-            bec_logger._update_sinks()
-
-        with redirect_stdout(SimpleFileLikeFromLogOutputFunc(logger.info)):  # type: ignore
-            with redirect_stderr(SimpleFileLikeFromLogOutputFunc(logger.error)):  # type: ignore
-                self._run()
-
-    def _get_service_config(self) -> ServiceConfig:
-        if self.config:
-            try:
-                config = json.loads(self.config)
-                service_config = ServiceConfig(config=config)
-            except (json.JSONDecodeError, TypeError):
-                service_config = ServiceConfig(config_path=config)
-        else:
-            # if no config is provided, use the default config
-            service_config = ServiceConfig()
-        return service_config
-
-    def _run(self):
-        """
-        Run the GUI server.
-        """
-        self.app = QApplication(sys.argv)
-        if darkdetect.isDark():
-            apply_theme("dark")
-        else:
-            apply_theme("light")
-
-        self.app.setApplicationName("BEC")
-        self.app.gui_id = self.gui_id  # type: ignore
-        self.setup_bec_icon()
-
-        service_config = self._get_service_config()
-        self.dispatcher = BECDispatcher(config=service_config, gui_id=self.gui_id)
-        # self.dispatcher.start_cli_server(gui_id=self.gui_id)
-
-        self.launcher_window = LaunchWindow(gui_id=f"{self.gui_id}:launcher")
-        self.launcher_window.setAttribute(Qt.WA_ShowWithoutActivating)  # type: ignore
-
-        self.app.aboutToQuit.connect(self.shutdown)
-        self.app.setQuitOnLastWindowClosed(False)
-
-        if self.gui_class:
-            # If the server is started with a specific gui class, we launch it.
-            # This will automatically hide the launcher.
-            self.launcher_window.launch(self.gui_class, name=self.gui_class_id)
-
-        def sigint_handler(*args):
-            # display message, for people to let it terminate gracefully
-            print("Caught SIGINT, exiting")
-            # Widgets should be all closed.
-            with RPCRegister.delayed_broadcast():
-                for widget in QApplication.instance().topLevelWidgets():  # type: ignore
-                    widget.close()
-            if self.app:
-                self.app.quit()
-
-        signal.signal(signal.SIGINT, sigint_handler)
-        signal.signal(signal.SIGTERM, sigint_handler)
-
-        sys.exit(self.app.exec())
-
-    def setup_bec_icon(self):
-        """
-        Set the BEC icon for the application
-        """
-        if self.app is None:
-            return
-        icon = QIcon()
-        icon.addFile(
-            os.path.join(MODULE_PATH, "assets", "app_icons", "bec_widgets_icon.png"),
-            size=QSize(48, 48),
-        )
-        self.app.setWindowIcon(icon)
-
-    def shutdown(self):
-        """
-        Shutdown the GUI server.
-        """
-        if pylsp_server.is_running():
-            pylsp_server.stop()
-        if self.dispatcher:
-            self.dispatcher.stop_cli_server()
-            self.dispatcher.disconnect_all()
-
-
 def main():
-    """
-    Main entry point for subprocesses that start a GUI server.
-    """
+    import argparse
+    import os
+    import sys
+
+    from qtpy.QtCore import QSize
+    from qtpy.QtGui import QIcon
+    from qtpy.QtWidgets import QApplication, QMainWindow
+
+    import bec_widgets
 
     parser = argparse.ArgumentParser(description="BEC Widgets CLI Server")
-    parser.add_argument("--id", type=str, default="test", help="The id of the server")
+    parser.add_argument("--id", type=str, help="The id of the server")
     parser.add_argument(
         "--gui_class",
         type=str,
         help="Name of the gui class to be rendered. Possible values: \n- BECFigure\n- BECDockArea",
     )
-    parser.add_argument(
-        "--gui_class_id",
-        type=str,
-        default="bec",
-        help="The id of the gui class that is added to the QApplication",
-    )
-    parser.add_argument("--config", type=str, help="Config file or config string.")
-    parser.add_argument("--hide", action="store_true", help="Hide on startup")
+    parser.add_argument("--config", type=str, help="Config file")
 
     args = parser.parse_args()
 
-    server = GUIServer(args)
-    server.start()
+    if args.gui_class == "BECFigure":
+        gui_class = BECFigure
+    elif args.gui_class == "BECDockArea":
+        gui_class = BECDockArea
+    else:
+        print(
+            "Please specify a valid gui_class to run. Use -h for help."
+            "\n Starting with default gui_class BECFigure."
+        )
+        gui_class = BECFigure
+
+    with redirect_stdout(SimpleFileLikeFromLogOutputFunc(logger.debug)):
+        with redirect_stderr(SimpleFileLikeFromLogOutputFunc(logger.error)):
+            app = QApplication(sys.argv)
+            app.setApplicationName("BEC Figure")
+            module_path = os.path.dirname(bec_widgets.__file__)
+            icon = QIcon()
+            icon.addFile(
+                os.path.join(module_path, "assets", "bec_widgets_icon.png"), size=QSize(48, 48)
+            )
+            app.setWindowIcon(icon)
+
+            win = QMainWindow()
+            win.setWindowTitle("BEC Widgets")
+
+            service_config = ServiceConfig(args.config)
+            bec_logger.configure(
+                service_config.redis,
+                QtRedisConnector,
+                service_name="BECWidgetsCLIServer",
+                service_config=service_config.service_config,
+            )
+            server = BECWidgetsCLIServer(gui_id=args.id, config=service_config, gui_class=gui_class)
+
+            gui = server.gui
+            win.setCentralWidget(gui)
+            win.resize(800, 600)
+            win.show()
+
+            app.aboutToQuit.connect(server.shutdown)
+
+            def sigint_handler(*args):
+                # display message, for people to let it terminate gracefully
+                print("Caught SIGINT, exiting")
+                app.quit()
+
+            signal.signal(signal.SIGINT, sigint_handler)
+            signal.signal(signal.SIGTERM, sigint_handler)
+
+            sys.exit(app.exec())
 
 
-if __name__ == "__main__":
-    # import sys
-
-    # sys.argv = ["bec_widgets", "--gui_class", "MainWindow"]
+if __name__ == "__main__":  # pragma: no cover
     main()

bec_widgets/examples/__init__.py

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

bec_widgets/examples/general_app/general_app.py

@@ -1,92 +0,0 @@
-import os
-import sys
-
-from qtpy.QtCore import QSize
-from qtpy.QtGui import QActionGroup, QIcon
-from qtpy.QtWidgets import QApplication, QMainWindow, QStyle
-
-import bec_widgets
-from bec_widgets.examples.general_app.web_links import BECWebLinksMixin
-from bec_widgets.utils.colors import apply_theme
-from bec_widgets.utils.ui_loader import UILoader
-
-MODULE_PATH = os.path.dirname(bec_widgets.__file__)
-
-
-class BECGeneralApp(QMainWindow):
-    def __init__(self, parent=None):
-        super(BECGeneralApp, self).__init__(parent)
-        ui_file_path = os.path.join(os.path.dirname(__file__), "general_app.ui")
-        self.load_ui(ui_file_path)
-
-        self.resize(1280, 720)
-
-        self.ini_ui()
-
-    def ini_ui(self):
-        self._setup_icons()
-        self._hook_menubar_docs()
-        self._hook_theme_bar()
-
-    def load_ui(self, ui_file):
-        loader = UILoader(self)
-        self.ui = loader.loader(ui_file)
-        self.setCentralWidget(self.ui)
-
-    def _hook_menubar_docs(self):
-        # BEC Docs
-        self.ui.action_BEC_docs.triggered.connect(BECWebLinksMixin.open_bec_docs)
-        # BEC Widgets Docs
-        self.ui.action_BEC_widgets_docs.triggered.connect(BECWebLinksMixin.open_bec_widgets_docs)
-        # Bug report
-        self.ui.action_bug_report.triggered.connect(BECWebLinksMixin.open_bec_bug_report)
-
-    def change_theme(self, theme):
-        apply_theme(theme)
-
-    def _setup_icons(self):
-        help_icon = QApplication.style().standardIcon(QStyle.SP_MessageBoxQuestion)
-        bug_icon = QApplication.style().standardIcon(QStyle.SP_MessageBoxInformation)
-        computer_icon = QIcon.fromTheme("computer")
-        widget_icon = QIcon(os.path.join(MODULE_PATH, "assets", "designer_icons", "dock_area.png"))
-
-        self.ui.action_BEC_docs.setIcon(help_icon)
-        self.ui.action_BEC_widgets_docs.setIcon(help_icon)
-        self.ui.action_bug_report.setIcon(bug_icon)
-
-        self.ui.central_tab.setTabIcon(0, widget_icon)
-        self.ui.central_tab.setTabIcon(1, computer_icon)
-
-    def _hook_theme_bar(self):
-        self.ui.action_light.setCheckable(True)
-        self.ui.action_dark.setCheckable(True)
-
-        # Create an action group to make sure only one can be checked at a time
-        theme_group = QActionGroup(self)
-        theme_group.addAction(self.ui.action_light)
-        theme_group.addAction(self.ui.action_dark)
-        theme_group.setExclusive(True)
-
-        # Connect the actions to the theme change method
-
-        self.ui.action_light.triggered.connect(lambda: self.change_theme("light"))
-        self.ui.action_dark.triggered.connect(lambda: self.change_theme("dark"))
-
-        self.ui.action_dark.trigger()
-
-
-def main():  # pragma: no cover
-
-    app = QApplication(sys.argv)
-    icon = QIcon()
-    icon.addFile(
-        os.path.join(MODULE_PATH, "assets", "app_icons", "BEC-General-App.png"), size=QSize(48, 48)
-    )
-    app.setWindowIcon(icon)
-    main_window = BECGeneralApp()
-    main_window.show()
-    sys.exit(app.exec_())
-
-
-if __name__ == "__main__":  # pragma: no cover
-    main()

bec_widgets/examples/general_app/general_app.ui

@@ -1,262 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
-    <class>MainWindow</class>
-    <widget class="QMainWindow" name="MainWindow">
-        <property name="geometry">
-            <rect>
-                <x>0</x>
-                <y>0</y>
-                <width>1718</width>
-                <height>1139</height>
-            </rect>
-        </property>
-        <property name="windowTitle">
-            <string>MainWindow</string>
-        </property>
-        <property name="tabShape">
-            <enum>QTabWidget::TabShape::Rounded</enum>
-        </property>
-        <widget class="QWidget" name="centralwidget">
-            <layout class="QVBoxLayout" name="verticalLayout_3">
-                <item>
-                    <widget class="QTabWidget" name="central_tab">
-                        <property name="currentIndex">
-                            <number>0</number>
-                        </property>
-                        <widget class="QWidget" name="dock_area_tab">
-                            <attribute name="title">
-                                <string>Dock Area</string>
-                            </attribute>
-                            <layout class="QVBoxLayout" name="verticalLayout">
-                                <property name="leftMargin">
-                                    <number>2</number>
-                                </property>
-                                <property name="topMargin">
-                                    <number>1</number>
-                                </property>
-                                <property name="rightMargin">
-                                    <number>2</number>
-                                </property>
-                                <property name="bottomMargin">
-                                    <number>2</number>
-                                </property>
-                                <item>
-                                    <widget class="BECDockArea" name="dock_area"/>
-                                </item>
-                            </layout>
-                        </widget>
-                        <widget class="QWidget" name="vscode_tab">
-                            <attribute name="icon">
-                                <iconset theme="QIcon::ThemeIcon::Computer"/>
-                            </attribute>
-                            <attribute name="title">
-                                <string>Visual Studio Code</string>
-                            </attribute>
-                            <layout class="QVBoxLayout" name="verticalLayout_2">
-                                <property name="leftMargin">
-                                    <number>2</number>
-                                </property>
-                                <property name="topMargin">
-                                    <number>1</number>
-                                </property>
-                                <property name="rightMargin">
-                                    <number>2</number>
-                                </property>
-                                <property name="bottomMargin">
-                                    <number>2</number>
-                                </property>
-                                <item>
-                                    <widget class="VSCodeEditor" name="vscode"/>
-                                </item>
-                            </layout>
-                        </widget>
-                    </widget>
-                </item>
-            </layout>
-        </widget>
-        <widget class="QMenuBar" name="menubar">
-            <property name="geometry">
-                <rect>
-                    <x>0</x>
-                    <y>0</y>
-                    <width>1718</width>
-                    <height>31</height>
-                </rect>
-            </property>
-            <widget class="QMenu" name="menuHelp">
-                <property name="title">
-                    <string>Help</string>
-                </property>
-                <addaction name="action_BEC_docs"/>
-                <addaction name="action_BEC_widgets_docs"/>
-                <addaction name="action_bug_report"/>
-            </widget>
-            <widget class="QMenu" name="menuTheme">
-                <property name="title">
-                    <string>Theme</string>
-                </property>
-                <addaction name="action_light"/>
-                <addaction name="action_dark"/>
-            </widget>
-            <addaction name="menuTheme"/>
-            <addaction name="menuHelp"/>
-        </widget>
-        <widget class="QStatusBar" name="statusbar"/>
-        <widget class="QDockWidget" name="dock_scan_control">
-            <property name="windowTitle">
-                <string>Scan Control</string>
-            </property>
-            <attribute name="dockWidgetArea">
-                <number>2</number>
-            </attribute>
-            <widget class="QWidget" name="dockWidgetContents_2">
-                <layout class="QVBoxLayout" name="verticalLayout_4">
-                    <item>
-                        <widget class="ScanControl" name="scan_control"/>
-                    </item>
-                </layout>
-            </widget>
-        </widget>
-        <widget class="QDockWidget" name="dock_status_2">
-            <property name="windowTitle">
-                <string>BEC Service Status</string>
-            </property>
-            <attribute name="dockWidgetArea">
-                <number>2</number>
-            </attribute>
-            <widget class="QWidget" name="dockWidgetContents_3">
-                <layout class="QVBoxLayout" name="verticalLayout_5">
-                    <property name="leftMargin">
-                        <number>0</number>
-                    </property>
-                    <property name="topMargin">
-                        <number>0</number>
-                    </property>
-                    <property name="rightMargin">
-                        <number>0</number>
-                    </property>
-                    <property name="bottomMargin">
-                        <number>0</number>
-                    </property>
-                    <item>
-                        <widget class="BECStatusBox" name="bec_status_box_2"/>
-                    </item>
-                </layout>
-            </widget>
-        </widget>
-        <widget class="QDockWidget" name="dock_queue">
-            <property name="windowTitle">
-                <string>Scan Queue</string>
-            </property>
-            <attribute name="dockWidgetArea">
-                <number>2</number>
-            </attribute>
-            <widget class="QWidget" name="dockWidgetContents_4">
-                <layout class="QVBoxLayout" name="verticalLayout_6">
-                    <property name="leftMargin">
-                        <number>0</number>
-                    </property>
-                    <property name="topMargin">
-                        <number>0</number>
-                    </property>
-                    <property name="rightMargin">
-                        <number>0</number>
-                    </property>
-                    <property name="bottomMargin">
-                        <number>0</number>
-                    </property>
-                    <item>
-                        <widget class="BECQueue" name="bec_queue">
-                            <row/>
-                            <column/>
-                            <column/>
-                            <column/>
-                            <item row="0" column="0"/>
-                            <item row="0" column="1"/>
-                            <item row="0" column="2"/>
-                        </widget>
-                    </item>
-                </layout>
-            </widget>
-        </widget>
-        <action name="action_BEC_docs">
-            <property name="icon">
-                <iconset theme="QIcon::ThemeIcon::DialogQuestion"/>
-            </property>
-            <property name="text">
-                <string>BEC Docs</string>
-            </property>
-        </action>
-        <action name="action_BEC_widgets_docs">
-            <property name="icon">
-                <iconset theme="QIcon::ThemeIcon::DialogQuestion"/>
-            </property>
-            <property name="text">
-                <string>BEC Widgets Docs</string>
-            </property>
-        </action>
-        <action name="action_bug_report">
-            <property name="icon">
-                <iconset theme="QIcon::ThemeIcon::DialogError"/>
-            </property>
-            <property name="text">
-                <string>Bug Report</string>
-            </property>
-        </action>
-        <action name="action_light">
-            <property name="checkable">
-                <bool>true</bool>
-            </property>
-            <property name="text">
-                <string>Light</string>
-            </property>
-        </action>
-        <action name="action_dark">
-            <property name="checkable">
-                <bool>true</bool>
-            </property>
-            <property name="text">
-                <string>Dark</string>
-            </property>
-        </action>
-    </widget>
-    <customwidgets>
-        <customwidget>
-            <class>WebsiteWidget</class>
-            <extends>QWebEngineView</extends>
-            <header>website_widget</header>
-        </customwidget>
-        <customwidget>
-            <class>BECQueue</class>
-            <extends>QTableWidget</extends>
-            <header>bec_queue</header>
-        </customwidget>
-        <customwidget>
-            <class>ScanControl</class>
-            <extends>QWidget</extends>
-            <header>scan_control</header>
-        </customwidget>
-        <customwidget>
-            <class>VSCodeEditor</class>
-            <extends>WebsiteWidget</extends>
-            <header>vs_code_editor</header>
-        </customwidget>
-        <customwidget>
-            <class>BECStatusBox</class>
-            <extends>QWidget</extends>
-            <header>bec_status_box</header>
-        </customwidget>
-        <customwidget>
-            <class>BECDockArea</class>
-            <extends>QWidget</extends>
-            <header>dock_area</header>
-        </customwidget>
-        <customwidget>
-            <class>QWebEngineView</class>
-            <extends></extends>
-            <header location="global">QtWebEngineWidgets/QWebEngineView</header>
-        </customwidget>
-    </customwidgets>
-    <resources/>
-    <connections/>
-</ui>

bec_widgets/examples/general_app/web_links.py

@@ -1,15 +0,0 @@
-import webbrowser
-
-
-class BECWebLinksMixin:
-    @staticmethod
-    def open_bec_docs():
-        webbrowser.open("https://beamline-experiment-control.readthedocs.io/en/latest/")
-
-    @staticmethod
-    def open_bec_widgets_docs():
-        webbrowser.open("https://bec.readthedocs.io/projects/bec-widgets/en/latest/")
-
-    @staticmethod
-    def open_bec_bug_report():
-        webbrowser.open("https://gitlab.psi.ch/groups/bec/-/issues/")

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -2,31 +2,17 @@ import os
 
 import numpy as np
 import pyqtgraph as pg
-from bec_qthemes import material_icon
-from qtpy.QtWidgets import (
-    QApplication,
-    QGroupBox,
-    QHBoxLayout,
-    QPushButton,
-    QSplitter,
-    QTabWidget,
-    QVBoxLayout,
-    QWidget,
-)
+import qdarktheme
+from qtconsole.inprocess import QtInProcessKernelManager
+from qtconsole.rich_jupyter_widget import RichJupyterWidget
+from qtpy.QtCore import QSize
+from qtpy.QtGui import QIcon
+from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
 
-from bec_widgets.utils import BECDispatcher
-from bec_widgets.utils.colors import apply_theme
-from bec_widgets.utils.widget_io import WidgetHierarchy as wh
-from bec_widgets.widgets.containers.advanced_dock_area.advanced_dock_area import AdvancedDockArea
-from bec_widgets.widgets.containers.dock import BECDockArea
-from bec_widgets.widgets.containers.layout_manager.layout_manager import LayoutManagerWidget
-from bec_widgets.widgets.editors.jupyter_console.jupyter_console import BECJupyterConsole
-from bec_widgets.widgets.plots.image.image import Image
-from bec_widgets.widgets.plots.motor_map.motor_map import MotorMap
-from bec_widgets.widgets.plots.multi_waveform.multi_waveform import MultiWaveform
-from bec_widgets.widgets.plots.plot_base import PlotBase
-from bec_widgets.widgets.plots.scatter_waveform.scatter_waveform import ScatterWaveform
-from bec_widgets.widgets.plots.waveform.waveform import Waveform
+from bec_widgets.utils import BECDispatcher, UILoader
+from bec_widgets.widgets.dock.dock_area import BECDockArea
+from bec_widgets.widgets.figure import BECFigure
+from bec_widgets.widgets.jupyter_console.jupyter_console import BECJupyterConsole
 
 
 class JupyterConsoleWindow(QWidget):  # pragma: no cover:
@@ -35,130 +21,119 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
     def __init__(self, parent=None):
         super().__init__(parent)
 
+        current_path = os.path.dirname(__file__)
+        self.ui = UILoader().load_ui(os.path.join(current_path, "jupyter_console_window.ui"), self)
+
         self._init_ui()
 
+        self.ui.splitter.setSizes([200, 100])
+        self.safe_close = False
+
         # console push
         if self.console.inprocess is True:
             self.console.kernel_manager.kernel.shell.push(
                 {
                     "np": np,
                     "pg": pg,
-                    "wh": wh,
+                    "fig": self.figure,
                     "dock": self.dock,
-                    "im": self.im,
-                    "ads": self.ads,
-                    # "mi": self.mi,
-                    # "mm": self.mm,
-                    # "lm": self.lm,
-                    # "btn1": self.btn1,
-                    # "btn2": self.btn2,
-                    # "btn3": self.btn3,
-                    # "btn4": self.btn4,
-                    # "btn5": self.btn5,
-                    # "btn6": self.btn6,
-                    # "pb": self.pb,
-                    # "pi": self.pi,
-                    # "wf": self.wf,
-                    # "scatter": self.scatter,
-                    # "scatter_mi": self.scatter,
-                    # "mwf": self.mwf,
+                    "w1": self.w1,
+                    "w2": self.w2,
+                    "w3": self.w3,
+                    "w1_c": self.w1_c,
+                    "w2_c": self.w2_c,
+                    "w3_c": self.w3_c,
+                    "w4": self.w4,
+                    "d0": self.d0,
+                    "d1": self.d1,
+                    "d2": self.d2,
+                    "plt": self.plt,
+                    "bar": self.bar,
                 }
             )
 
     def _init_ui(self):
-        self.layout = QHBoxLayout(self)
+        # Plotting window
+        self.glw_1_layout = QVBoxLayout(self.ui.glw)  # Create a new QVBoxLayout
+        self.figure = BECFigure(parent=self, gui_id="remote")  # Create a new BECDeviceMonitor
+        self.glw_1_layout.addWidget(self.figure)  # Add BECDeviceMonitor to the layout
 
-        # Horizontal splitter
-        splitter = QSplitter(self)
-        self.layout.addWidget(splitter)
+        self.dock_layout = QVBoxLayout(self.ui.dock_placeholder)
+        self.dock = BECDockArea(gui_id="remote")
+        self.dock_layout.addWidget(self.dock)
 
-        tab_widget = QTabWidget(splitter)
+        # add stuff to figure
+        self._init_figure()
 
-        first_tab = QWidget()
-        first_tab_layout = QVBoxLayout(first_tab)
-        self.dock = BECDockArea(gui_id="dock")
-        first_tab_layout.addWidget(self.dock)
-        tab_widget.addTab(first_tab, "Dock Area")
+        # init dock for testing
+        self._init_dock()
 
-        # third_tab = QWidget()
-        # third_tab_layout = QVBoxLayout(third_tab)
-        # self.lm = LayoutManagerWidget()
-        # third_tab_layout.addWidget(self.lm)
-        # tab_widget.addTab(third_tab, "Layout Manager Widget")
-        #
-        # fourth_tab = QWidget()
-        # fourth_tab_layout = QVBoxLayout(fourth_tab)
-        # self.pb = PlotBase()
-        # self.pi = self.pb.plot_item
-        # fourth_tab_layout.addWidget(self.pb)
-        # tab_widget.addTab(fourth_tab, "PlotBase")
-        #
-        # tab_widget.setCurrentIndex(3)
-        #
-        group_box = QGroupBox("Jupyter Console", splitter)
-        group_box_layout = QVBoxLayout(group_box)
+        self.console_layout = QVBoxLayout(self.ui.widget_console)
         self.console = BECJupyterConsole(inprocess=True)
-        group_box_layout.addWidget(self.console)
-        #
-        # # Some buttons for layout testing
-        # self.btn1 = QPushButton("Button 1")
-        # self.btn2 = QPushButton("Button 2")
-        # self.btn3 = QPushButton("Button 3")
-        # self.btn4 = QPushButton("Button 4")
-        # 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)
-        #
-        sixth_tab = QWidget()
-        sixth_tab_layout = QVBoxLayout(sixth_tab)
-        self.im = Image(popups=True)
-        self.mi = self.im.main_image
-        sixth_tab_layout.addWidget(self.im)
-        tab_widget.addTab(sixth_tab, "Image Next Gen")
-        tab_widget.setCurrentIndex(1)
-        #
-        seventh_tab = QWidget()
-        seventh_tab_layout = QVBoxLayout(seventh_tab)
-        self.ads = AdvancedDockArea(gui_id="ads")
-        seventh_tab_layout.addWidget(self.ads)
-        tab_widget.addTab(seventh_tab, "ADS")
-        tab_widget.setCurrentIndex(2)
-        #
-        # eighth_tab = QWidget()
-        # eighth_tab_layout = QVBoxLayout(eighth_tab)
-        # self.mm = MotorMap()
-        # eighth_tab_layout.addWidget(self.mm)
-        # tab_widget.addTab(eighth_tab, "Motor Map")
-        # tab_widget.setCurrentIndex(7)
-        #
-        # ninth_tab = QWidget()
-        # ninth_tab_layout = QVBoxLayout(ninth_tab)
-        # self.mwf = MultiWaveform()
-        # ninth_tab_layout.addWidget(self.mwf)
-        # tab_widget.addTab(ninth_tab, "MultiWaveform")
-        # tab_widget.setCurrentIndex(8)
-        #
-        # # add stuff to the new Waveform widget
-        # self._init_waveform()
-        #
-        # self.setWindowTitle("Jupyter Console Window")
+        self.console_layout.addWidget(self.console)
 
-    def _init_waveform(self):
-        self.wf.plot(y_name="bpm4i", y_entry="bpm4i", dap="GaussianModel")
-        self.wf.plot(y_name="bpm3a", y_entry="bpm3a", dap="GaussianModel")
+    def _init_figure(self):
+        self.figure.plot(x_name="samx", y_name="samy", z_name="bpm4i", color_map_z="cividis")
+        self.figure.motor_map("samx", "samy")
+        self.figure.image("eiger", color_map="viridis", vrange=(0, 100))
+        self.figure.plot(
+            x_name="samx", y_name="samy", z_name="bpm4i", color_map_z="magma", new=True
+        )
+
+        self.figure.change_layout(2, 2)
+
+        self.w1 = self.figure[0, 0]
+        self.w2 = self.figure[0, 1]
+        self.w3 = self.figure[1, 0]
+        self.w4 = self.figure[1, 1]
+
+        # Plot Customisation
+        self.w1.set_title("Waveform 1")
+        self.w1.set_x_label("Motor Position (samx)")
+        self.w1.set_y_label("Intensity A.U.")
+
+        # Image Customisation
+        self.w3.set_title("Eiger Image")
+        self.w3.set_x_label("X")
+        self.w3.set_y_label("Y")
+
+        # Configs to try to pass
+        self.w1_c = self.w1._config_dict
+        self.w2_c = self.w2._config_dict
+        self.w3_c = self.w3._config_dict
+
+        # curves for w1
+        self.c1 = self.w1.get_config()
+
+        self.fig_c = self.figure._config_dict
+
+    def _init_dock(self):
+
+        self.d0 = self.dock.add_dock(name="dock_0")
+        self.fig0 = self.d0.add_widget("BECFigure")
+        data = np.random.rand(10, 2)
+        self.fig0.plot(data, label="2d Data")
+        self.fig0.image("eiger", vrange=(0, 100))
+
+        self.d1 = self.dock.add_dock(name="dock_1", position="right")
+        self.fig1 = self.d1.add_widget("BECFigure")
+        self.fig1.plot(x_name="samx", y_name="bpm4i")
+        self.fig1.plot(x_name="samx", y_name="bpm3a")
+
+        self.d2 = self.dock.add_dock(name="dock_2", position="bottom")
+        self.fig2 = self.d2.add_widget("BECFigure", row=0, col=0)
+        self.plt = self.fig2.plot(x_name="samx", y_name="bpm3a")
+        self.plt.plot(x_name="samx", y_name="bpm4i", dap="GaussianModel")
+        self.bar = self.d2.add_widget("RingProgressBar", row=0, col=1)
+        self.bar.set_diameter(200)
+
+        self.dock.save_state()
 
     def closeEvent(self, event):
         """Override to handle things when main window is closed."""
         self.dock.cleanup()
-        self.dock.close()
-        self.console.close()
-
+        self.figure.clear_all()
+        self.figure.client.shutdown()
         super().closeEvent(event)
 
 
@@ -170,19 +145,19 @@ if __name__ == "__main__":  # pragma: no cover
     module_path = os.path.dirname(bec_widgets.__file__)
 
     app = QApplication(sys.argv)
-    apply_theme("dark")
     app.setApplicationName("Jupyter Console")
     app.setApplicationDisplayName("Jupyter Console")
-    icon = material_icon("terminal", color=(255, 255, 255, 255), filled=True)
+    qdarktheme.setup_theme("auto")
+    icon = QIcon()
+    icon.addFile(os.path.join(module_path, "assets", "terminal_icon.png"), size=QSize(48, 48))
     app.setWindowIcon(icon)
 
-    bec_dispatcher = BECDispatcher(gui_id="jupyter_console")
+    bec_dispatcher = BECDispatcher()
     client = bec_dispatcher.client
     client.start()
 
     win = JupyterConsoleWindow()
     win.show()
-    win.resize(1500, 800)
 
     app.aboutToQuit.connect(win.close)
     sys.exit(app.exec_())

bec_widgets/examples/jupyter_console/jupyter_console_window.ui

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

bec_widgets/examples/motor_movement/__init__.py

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

bec_widgets/examples/motor_movement/motor_control_compilations.py

@@ -0,0 +1,250 @@
+# pylint: disable = no-name-in-module,missing-class-docstring, missing-module-docstring
+
+import qdarktheme
+from qtpy.QtCore import Qt
+from qtpy.QtWidgets import QApplication, QSplitter, QVBoxLayout, QWidget
+
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
+from bec_widgets.widgets.motor_control.motor_control import MotorThread
+from bec_widgets.widgets.motor_control.motor_table.motor_table import MotorCoordinateTable
+from bec_widgets.widgets.motor_control.movement_absolute.movement_absolute import (
+    MotorControlAbsolute,
+)
+from bec_widgets.widgets.motor_control.movement_relative.movement_relative import (
+    MotorControlRelative,
+)
+from bec_widgets.widgets.motor_control.selection.selection import MotorControlSelection
+
+CONFIG_DEFAULT = {
+    "motor_control": {
+        "motor_x": "samx",
+        "motor_y": "samy",
+        "step_size_x": 3,
+        "step_size_y": 3,
+        "precision": 4,
+        "step_x_y_same": False,
+        "move_with_arrows": False,
+    },
+    "plot_settings": {
+        "colormap": "Greys",
+        "scatter_size": 5,
+        "max_points": 1000,
+        "num_dim_points": 100,
+        "precision": 2,
+        "num_columns": 1,
+        "background_value": 25,
+    },
+    "motors": [
+        {
+            "plot_name": "Motor Map",
+            "x_label": "Motor X",
+            "y_label": "Motor Y",
+            "signals": {
+                "x": [{"name": "samx", "entry": "samx"}],
+                "y": [{"name": "samy", "entry": "samy"}],
+            },
+        }
+    ],
+}
+
+
+class MotorControlApp(QWidget):
+    def __init__(self, parent=None, client=None, config=None):
+        super().__init__(parent)
+
+        bec_dispatcher = BECDispatcher()
+        self.client = bec_dispatcher.client if client is None else client
+        self.config = config
+
+        # Widgets
+        self.motor_control_panel = MotorControlPanel(client=self.client, config=self.config)
+        # Create MotorMap
+        # self.motion_map = MotorMap(client=self.client, config=self.config)
+        # Create MotorCoordinateTable
+        self.motor_table = MotorCoordinateTable(client=self.client, config=self.config)
+
+        # Create the splitter and add MotorMap and MotorControlPanel
+        splitter = QSplitter(Qt.Horizontal)
+        # splitter.addWidget(self.motion_map)
+        splitter.addWidget(self.motor_control_panel)
+        splitter.addWidget(self.motor_table)
+
+        # Set the main layout
+        layout = QVBoxLayout(self)
+        layout.addWidget(splitter)
+        self.setLayout(layout)
+
+        # Connecting signals and slots
+        # self.motor_control_panel.selection_widget.selected_motors_signal.connect(
+        #     lambda x, y: self.motion_map.change_motors(x, y, 0)
+        # )
+        self.motor_control_panel.absolute_widget.coordinates_signal.connect(
+            self.motor_table.add_coordinate
+        )
+        self.motor_control_panel.relative_widget.precision_signal.connect(
+            self.motor_table.set_precision
+        )
+        self.motor_control_panel.relative_widget.precision_signal.connect(
+            self.motor_control_panel.absolute_widget.set_precision
+        )
+
+        # self.motor_table.plot_coordinates_signal.connect(self.motion_map.plot_saved_coordinates)
+
+
+class MotorControlMap(QWidget):
+    def __init__(self, parent=None, client=None, config=None):
+        super().__init__(parent)
+
+        bec_dispatcher = BECDispatcher()
+        self.client = bec_dispatcher.client if client is None else client
+        self.config = config
+
+        # Widgets
+        self.motor_control_panel = MotorControlPanel(client=self.client, config=self.config)
+        # Create MotorMap
+        # self.motion_map = MotorMap(client=self.client, config=self.config)
+
+        # Create the splitter and add MotorMap and MotorControlPanel
+        splitter = QSplitter(Qt.Horizontal)
+        # splitter.addWidget(self.motion_map)
+        splitter.addWidget(self.motor_control_panel)
+
+        # Set the main layout
+        layout = QVBoxLayout(self)
+        layout.addWidget(splitter)
+        self.setLayout(layout)
+
+        # Connecting signals and slots
+        # self.motor_control_panel.selection_widget.selected_motors_signal.connect(
+        #     lambda x, y: self.motion_map.change_motors(x, y, 0)
+        # )
+
+
+class MotorControlPanel(QWidget):
+    def __init__(self, parent=None, client=None, config=None):
+        super().__init__(parent)
+
+        bec_dispatcher = BECDispatcher()
+        self.client = bec_dispatcher.client if client is None else client
+        self.config = config
+
+        self.motor_thread = MotorThread(client=self.client)
+
+        self.selection_widget = MotorControlSelection(
+            client=self.client, config=self.config, motor_thread=self.motor_thread
+        )
+        self.relative_widget = MotorControlRelative(
+            client=self.client, config=self.config, motor_thread=self.motor_thread
+        )
+        self.absolute_widget = MotorControlAbsolute(
+            client=self.client, config=self.config, motor_thread=self.motor_thread
+        )
+
+        layout = QVBoxLayout(self)
+
+        layout.addWidget(self.selection_widget)
+        layout.addWidget(self.relative_widget)
+        layout.addWidget(self.absolute_widget)
+
+        # Connecting signals and slots
+        self.selection_widget.selected_motors_signal.connect(self.relative_widget.change_motors)
+        self.selection_widget.selected_motors_signal.connect(self.absolute_widget.change_motors)
+
+        # Set the window to a fixed size based on its contents
+        # self.layout().setSizeConstraint(layout.SetFixedSize)
+
+
+class MotorControlPanelAbsolute(QWidget):
+    def __init__(self, parent=None, client=None, config=None):
+        super().__init__(parent)
+
+        bec_dispatcher = BECDispatcher()
+        self.client = bec_dispatcher.client if client is None else client
+        self.config = config
+
+        self.motor_thread = MotorThread(client=self.client)
+
+        self.selection_widget = MotorControlSelection(
+            client=client, config=config, motor_thread=self.motor_thread
+        )
+        self.absolute_widget = MotorControlAbsolute(
+            client=client, config=config, motor_thread=self.motor_thread
+        )
+
+        layout = QVBoxLayout(self)
+        layout.addWidget(self.selection_widget)
+        layout.addWidget(self.absolute_widget)
+
+        # Connecting signals and slots
+        self.selection_widget.selected_motors_signal.connect(self.absolute_widget.change_motors)
+
+
+class MotorControlPanelRelative(QWidget):
+    def __init__(self, parent=None, client=None, config=None):
+        super().__init__(parent)
+
+        bec_dispatcher = BECDispatcher()
+        self.client = bec_dispatcher.client if client is None else client
+        self.config = config
+
+        self.motor_thread = MotorThread(client=self.client)
+
+        self.selection_widget = MotorControlSelection(
+            client=client, config=config, motor_thread=self.motor_thread
+        )
+        self.relative_widget = MotorControlRelative(
+            client=client, config=config, motor_thread=self.motor_thread
+        )
+
+        layout = QVBoxLayout(self)
+        layout.addWidget(self.selection_widget)
+        layout.addWidget(self.relative_widget)
+
+        # Connecting signals and slots
+        self.selection_widget.selected_motors_signal.connect(self.relative_widget.change_motors)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    import argparse
+    import sys
+
+    parser = argparse.ArgumentParser(description="Run various Motor Control Widgets compositions.")
+    parser.add_argument(
+        "-v",
+        "--variant",
+        type=str,
+        choices=["app", "map", "panel", "panel_abs", "panel_rel"],
+        help="Select the variant of the motor control to run. "
+        "'app' for the full application, "
+        "'map' for MotorMap, "
+        "'panel' for the MotorControlPanel, "
+        "'panel_abs' for MotorControlPanel with absolute control, "
+        "'panel_rel' for MotorControlPanel with relative control.",
+    )
+
+    args = parser.parse_args()
+
+    bec_dispatcher = BECDispatcher()
+    client = bec_dispatcher.client
+    client.start()
+
+    app = QApplication([])
+    qdarktheme.setup_theme("auto")
+
+    if args.variant == "app":
+        window = MotorControlApp(client=client)  # , config=CONFIG_DEFAULT)
+    elif args.variant == "map":
+        window = MotorControlMap(client=client)  # , config=CONFIG_DEFAULT)
+    elif args.variant == "panel":
+        window = MotorControlPanel(client=client)  # , config=CONFIG_DEFAULT)
+    elif args.variant == "panel_abs":
+        window = MotorControlPanelAbsolute(client=client)  # , config=CONFIG_DEFAULT)
+    elif args.variant == "panel_rel":
+        window = MotorControlPanelRelative(client=client)  # , config=CONFIG_DEFAULT)
+    else:
+        print("Please specify a valid variant to run. Use -h for help.")
+        print("Running the full application by default.")
+        window = MotorControlApp(client=client)  # , config=CONFIG_DEFAULT)
+
+    window.show()
+    sys.exit(app.exec())

bec_widgets/examples/motor_movement/motor_controller.ui

@@ -0,0 +1,926 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Form</class>
+ <widget class="QWidget" name="Form">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>1561</width>
+    <height>748</height>
+   </rect>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>1409</width>
+    <height>748</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>Motor Controller</string>
+  </property>
+  <layout class="QHBoxLayout" name="horizontalLayout" stretch="8,5,8">
+   <item>
+    <widget class="GraphicsLayoutWidget" name="glw">
+     <property name="enabled">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="QFrame" name="Controls">
+     <property name="minimumSize">
+      <size>
+       <width>221</width>
+       <height>471</height>
+      </size>
+     </property>
+     <layout class="QVBoxLayout" name="verticalLayout_6" stretch="1,1,1,0,1">
+      <property name="spacing">
+       <number>1</number>
+      </property>
+      <property name="sizeConstraint">
+       <enum>QLayout::SetMinimumSize</enum>
+      </property>
+      <item>
+       <widget class="QGroupBox" name="motorSelection">
+        <property name="minimumSize">
+         <size>
+          <width>261</width>
+          <height>145</height>
+         </size>
+        </property>
+        <property name="title">
+         <string>Motor Selection</string>
+        </property>
+        <layout class="QGridLayout" name="gridLayout_4">
+         <item row="2" column="0">
+          <widget class="QLabel" name="label_8">
+           <property name="text">
+            <string>Motor Y</string>
+           </property>
+          </widget>
+         </item>
+         <item row="1" column="1">
+          <widget class="QComboBox" name="comboBox_motor_x"/>
+         </item>
+         <item row="2" column="1">
+          <widget class="QComboBox" name="comboBox_motor_y"/>
+         </item>
+         <item row="1" column="0">
+          <widget class="QLabel" name="label_5">
+           <property name="text">
+            <string>Motor X</string>
+           </property>
+          </widget>
+         </item>
+         <item row="3" column="0" colspan="2">
+          <widget class="QPushButton" name="pushButton_connecMotors">
+           <property name="text">
+            <string>Connect Motors</string>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </widget>
+      </item>
+      <item>
+       <spacer name="verticalSpacer_3">
+        <property name="orientation">
+         <enum>Qt::Vertical</enum>
+        </property>
+        <property name="sizeType">
+         <enum>QSizePolicy::Minimum</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>20</width>
+          <height>18</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+      <item>
+       <widget class="QGroupBox" name="motorControl">
+        <property name="minimumSize">
+         <size>
+          <width>261</width>
+          <height>339</height>
+         </size>
+        </property>
+        <property name="title">
+         <string>Motor Relative</string>
+        </property>
+        <layout class="QVBoxLayout" name="verticalLayout_5">
+         <item>
+          <widget class="QCheckBox" name="checkBox_enableArrows">
+           <property name="text">
+            <string>Move with arrow keys</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QCheckBox" name="checkBox_same_xy">
+           <property name="text">
+            <string>Step [X] = Step [Y]</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <layout class="QGridLayout" name="step_grid">
+           <item row="2" column="0">
+            <widget class="QLabel" name="label_step_y">
+             <property name="minimumSize">
+              <size>
+               <width>111</width>
+               <height>19</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>Step [Y]</string>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="0">
+            <widget class="QLabel" name="label_2">
+             <property name="minimumSize">
+              <size>
+               <width>111</width>
+               <height>19</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>Decimal</string>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="1">
+            <widget class="QDoubleSpinBox" name="spinBox_step_x">
+             <property name="minimumSize">
+              <size>
+               <width>110</width>
+               <height>19</height>
+              </size>
+             </property>
+             <property name="alignment">
+              <set>Qt::AlignCenter</set>
+             </property>
+             <property name="minimum">
+              <double>0.000000000000000</double>
+             </property>
+             <property name="maximum">
+              <double>99.000000000000000</double>
+             </property>
+             <property name="singleStep">
+              <double>0.100000000000000</double>
+             </property>
+             <property name="value">
+              <double>1.000000000000000</double>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="0">
+            <widget class="QLabel" name="label_step_x">
+             <property name="minimumSize">
+              <size>
+               <width>111</width>
+               <height>19</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>Step [X]</string>
+             </property>
+            </widget>
+           </item>
+           <item row="2" column="1">
+            <widget class="QDoubleSpinBox" name="spinBox_step_y">
+             <property name="minimumSize">
+              <size>
+               <width>110</width>
+               <height>19</height>
+              </size>
+             </property>
+             <property name="alignment">
+              <set>Qt::AlignCenter</set>
+             </property>
+             <property name="minimum">
+              <double>0.000000000000000</double>
+             </property>
+             <property name="maximum">
+              <double>99.000000000000000</double>
+             </property>
+             <property name="singleStep">
+              <double>0.100000000000000</double>
+             </property>
+             <property name="value">
+              <double>1.000000000000000</double>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="1">
+            <widget class="QSpinBox" name="spinBox_precision">
+             <property name="minimumSize">
+              <size>
+               <width>110</width>
+               <height>19</height>
+              </size>
+             </property>
+             <property name="alignment">
+              <set>Qt::AlignCenter</set>
+             </property>
+             <property name="maximum">
+              <number>8</number>
+             </property>
+             <property name="value">
+              <number>2</number>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+         <item>
+          <layout class="QGridLayout" name="direction_grid">
+           <property name="sizeConstraint">
+            <enum>QLayout::SetDefaultConstraint</enum>
+           </property>
+           <item row="1" column="2" alignment="Qt::AlignHCenter|Qt::AlignVCenter">
+            <widget class="QToolButton" name="toolButton_up">
+             <property name="minimumSize">
+              <size>
+               <width>26</width>
+               <height>26</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>...</string>
+             </property>
+             <property name="arrowType">
+              <enum>Qt::UpArrow</enum>
+             </property>
+            </widget>
+           </item>
+           <item row="2" column="4">
+            <spacer name="horizontalSpacer_2">
+             <property name="orientation">
+              <enum>Qt::Horizontal</enum>
+             </property>
+             <property name="sizeHint" stdset="0">
+              <size>
+               <width>40</width>
+               <height>20</height>
+              </size>
+             </property>
+            </spacer>
+           </item>
+           <item row="3" column="2" alignment="Qt::AlignHCenter|Qt::AlignVCenter">
+            <widget class="QToolButton" name="toolButton_down">
+             <property name="minimumSize">
+              <size>
+               <width>26</width>
+               <height>26</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>...</string>
+             </property>
+             <property name="arrowType">
+              <enum>Qt::DownArrow</enum>
+             </property>
+            </widget>
+           </item>
+           <item row="2" column="1">
+            <widget class="QToolButton" name="toolButton_left">
+             <property name="minimumSize">
+              <size>
+               <width>26</width>
+               <height>26</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>...</string>
+             </property>
+             <property name="arrowType">
+              <enum>Qt::LeftArrow</enum>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="2">
+            <spacer name="verticalSpacer">
+             <property name="orientation">
+              <enum>Qt::Vertical</enum>
+             </property>
+             <property name="sizeHint" stdset="0">
+              <size>
+               <width>20</width>
+               <height>40</height>
+              </size>
+             </property>
+            </spacer>
+           </item>
+           <item row="2" column="3">
+            <widget class="QToolButton" name="toolButton_right">
+             <property name="minimumSize">
+              <size>
+               <width>26</width>
+               <height>26</height>
+              </size>
+             </property>
+             <property name="text">
+              <string>...</string>
+             </property>
+             <property name="arrowType">
+              <enum>Qt::RightArrow</enum>
+             </property>
+            </widget>
+           </item>
+           <item row="2" column="0">
+            <spacer name="horizontalSpacer">
+             <property name="orientation">
+              <enum>Qt::Horizontal</enum>
+             </property>
+             <property name="sizeHint" stdset="0">
+              <size>
+               <width>40</width>
+               <height>20</height>
+              </size>
+             </property>
+            </spacer>
+           </item>
+           <item row="4" column="2">
+            <spacer name="verticalSpacer_2">
+             <property name="orientation">
+              <enum>Qt::Vertical</enum>
+             </property>
+             <property name="sizeHint" stdset="0">
+              <size>
+               <width>20</width>
+               <height>40</height>
+              </size>
+             </property>
+            </spacer>
+           </item>
+          </layout>
+         </item>
+        </layout>
+       </widget>
+      </item>
+      <item>
+       <spacer name="verticalSpacer_4">
+        <property name="orientation">
+         <enum>Qt::Vertical</enum>
+        </property>
+        <property name="sizeType">
+         <enum>QSizePolicy::Minimum</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>20</width>
+          <height>18</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+      <item>
+       <widget class="QGroupBox" name="motorControl_absolute">
+        <property name="minimumSize">
+         <size>
+          <width>261</width>
+          <height>195</height>
+         </size>
+        </property>
+        <property name="title">
+         <string>Move Absolute</string>
+        </property>
+        <layout class="QVBoxLayout" name="verticalLayout">
+         <item>
+          <widget class="QCheckBox" name="checkBox_save_with_go">
+           <property name="text">
+            <string>Save position with Go</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <layout class="QGridLayout" name="gridLayout_3">
+           <item row="1" column="1">
+            <widget class="QDoubleSpinBox" name="spinBox_absolute_y">
+             <property name="alignment">
+              <set>Qt::AlignCenter</set>
+             </property>
+             <property name="minimum">
+              <double>-500.000000000000000</double>
+             </property>
+             <property name="maximum">
+              <double>500.000000000000000</double>
+             </property>
+             <property name="singleStep">
+              <double>0.100000000000000</double>
+             </property>
+            </widget>
+           </item>
+           <item row="1" column="0">
+            <widget class="QDoubleSpinBox" name="spinBox_absolute_x">
+             <property name="alignment">
+              <set>Qt::AlignCenter</set>
+             </property>
+             <property name="minimum">
+              <double>-500.000000000000000</double>
+             </property>
+             <property name="maximum">
+              <double>500.000000000000000</double>
+             </property>
+             <property name="singleStep">
+              <double>0.100000000000000</double>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="1">
+            <widget class="QLabel" name="label_7">
+             <property name="text">
+              <string>Y</string>
+             </property>
+             <property name="alignment">
+              <set>Qt::AlignCenter</set>
+             </property>
+            </widget>
+           </item>
+           <item row="0" column="0">
+            <widget class="QLabel" name="label_6">
+             <property name="text">
+              <string>X</string>
+             </property>
+             <property name="alignment">
+              <set>Qt::AlignCenter</set>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+         <item>
+          <layout class="QHBoxLayout" name="horizontalLayout_2">
+           <item>
+            <widget class="QPushButton" name="pushButton_save">
+             <property name="text">
+              <string>Save</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QPushButton" name="pushButton_set">
+             <property name="text">
+              <string>Set</string>
+             </property>
+            </widget>
+           </item>
+           <item>
+            <widget class="QPushButton" name="pushButton_go_absolute">
+             <property name="text">
+              <string>Go</string>
+             </property>
+            </widget>
+           </item>
+          </layout>
+         </item>
+         <item>
+          <widget class="QPushButton" name="pushButton_stop">
+           <property name="text">
+            <string>Stop Movement</string>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QTabWidget" name="tabWidget_tables">
+     <property name="enabled">
+      <bool>true</bool>
+     </property>
+     <property name="currentIndex">
+      <number>0</number>
+     </property>
+     <widget class="QWidget" name="tab_coordinates">
+      <attribute name="title">
+       <string>Coordinates</string>
+      </attribute>
+      <layout class="QVBoxLayout" name="verticalLayout_3">
+       <item>
+        <layout class="QHBoxLayout" name="horizontalLayout_3">
+         <item>
+          <spacer name="horizontalSpacer_3">
+           <property name="orientation">
+            <enum>Qt::Horizontal</enum>
+           </property>
+           <property name="sizeHint" stdset="0">
+            <size>
+             <width>40</width>
+             <height>20</height>
+            </size>
+           </property>
+          </spacer>
+         </item>
+         <item>
+          <widget class="QLabel" name="label">
+           <property name="text">
+            <string>Entries Mode:</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QComboBox" name="comboBox_mode">
+           <item>
+            <property name="text">
+             <string>Individual</string>
+            </property>
+           </item>
+           <item>
+            <property name="text">
+             <string>Start/Stop</string>
+            </property>
+           </item>
+          </widget>
+         </item>
+        </layout>
+       </item>
+       <item>
+        <widget class="QTableWidget" name="tableWidget_coordinates">
+         <property name="selectionMode">
+          <enum>QAbstractItemView::MultiSelection</enum>
+         </property>
+         <property name="selectionBehavior">
+          <enum>QAbstractItemView::SelectRows</enum>
+         </property>
+         <column>
+          <property name="text">
+           <string>Show</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>Move</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>Tag</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>X</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>Y</string>
+          </property>
+         </column>
+        </widget>
+       </item>
+       <item>
+        <layout class="QGridLayout" name="gridLayout">
+         <item row="1" column="1">
+          <widget class="QPushButton" name="pushButton_resize_table">
+           <property name="text">
+            <string>Resize Table</string>
+           </property>
+          </widget>
+         </item>
+         <item row="0" column="1">
+          <widget class="QCheckBox" name="checkBox_resize_auto">
+           <property name="text">
+            <string>Resize Auto</string>
+           </property>
+           <property name="checked">
+            <bool>true</bool>
+           </property>
+          </widget>
+         </item>
+         <item row="1" column="0">
+          <widget class="QPushButton" name="pushButton_importCSV">
+           <property name="text">
+            <string>Import CSV</string>
+           </property>
+          </widget>
+         </item>
+         <item row="0" column="0">
+          <widget class="QPushButton" name="pushButton_exportCSV">
+           <property name="text">
+            <string>Export CSV</string>
+           </property>
+          </widget>
+         </item>
+         <item row="2" column="0">
+          <widget class="QPushButton" name="pushButton_help">
+           <property name="text">
+            <string>Help</string>
+           </property>
+          </widget>
+         </item>
+         <item row="2" column="1">
+          <widget class="QPushButton" name="pushButton_duplicate">
+           <property name="text">
+            <string>Duplicate Last Entry</string>
+           </property>
+          </widget>
+         </item>
+        </layout>
+       </item>
+      </layout>
+     </widget>
+     <widget class="QWidget" name="tab_settings">
+      <attribute name="title">
+       <string>Settings</string>
+      </attribute>
+      <layout class="QVBoxLayout" name="verticalLayout_4">
+       <item>
+        <widget class="QGroupBox" name="motorLimits">
+         <property name="enabled">
+          <bool>false</bool>
+         </property>
+         <property name="title">
+          <string>Motor Limits</string>
+         </property>
+         <layout class="QGridLayout" name="gridLayout_2">
+          <item row="2" column="1">
+           <widget class="QPushButton" name="pushButton_updateLimits">
+            <property name="text">
+             <string>Update</string>
+            </property>
+           </widget>
+          </item>
+          <item row="0" column="1">
+           <widget class="QLabel" name="label_Y_max">
+            <property name="text">
+             <string>+ Y</string>
+            </property>
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+           </widget>
+          </item>
+          <item row="4" column="1">
+           <widget class="QLabel" name="label_Y_min">
+            <property name="text">
+             <string>- Y</string>
+            </property>
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="0">
+           <widget class="QLabel" name="label_X_min">
+            <property name="text">
+             <string>- X</string>
+            </property>
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="2">
+           <widget class="QLabel" name="label_X_max">
+            <property name="text">
+             <string>+ X</string>
+            </property>
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="1">
+           <widget class="QDoubleSpinBox" name="spinBox_y_max">
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+            <property name="minimum">
+             <double>-1000.000000000000000</double>
+            </property>
+            <property name="maximum">
+             <double>1000.000000000000000</double>
+            </property>
+           </widget>
+          </item>
+          <item row="3" column="1">
+           <widget class="QDoubleSpinBox" name="spinBox_y_min">
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+            <property name="minimum">
+             <double>-1000.000000000000000</double>
+            </property>
+            <property name="maximum">
+             <double>1000.000000000000000</double>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="0">
+           <widget class="QDoubleSpinBox" name="spinBox_x_min">
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+            <property name="minimum">
+             <double>-1000.000000000000000</double>
+            </property>
+            <property name="maximum">
+             <double>1000.000000000000000</double>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="2">
+           <widget class="QDoubleSpinBox" name="spinBox_x_max">
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+            <property name="minimum">
+             <double>-1000.000000000000000</double>
+            </property>
+            <property name="maximum">
+             <double>1000.000000000000000</double>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+       <item>
+        <widget class="QGroupBox" name="groupBox_2">
+         <property name="title">
+          <string>Plotting Options</string>
+         </property>
+         <layout class="QGridLayout" name="gridLayout_5">
+          <item row="0" column="1" colspan="2">
+           <widget class="QSpinBox" name="spinBox_max_points">
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+            <property name="minimum">
+             <number>100</number>
+            </property>
+            <property name="maximum">
+             <number>10000</number>
+            </property>
+            <property name="singleStep">
+             <number>100</number>
+            </property>
+            <property name="value">
+             <number>5000</number>
+            </property>
+           </widget>
+          </item>
+          <item row="0" column="0">
+           <widget class="QLabel" name="label_15">
+            <property name="text">
+             <string>Max Points</string>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="1" colspan="2">
+           <widget class="QSpinBox" name="spinBox_scatter_size">
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+            <property name="minimum">
+             <number>1</number>
+            </property>
+            <property name="maximum">
+             <number>15</number>
+            </property>
+            <property name="value">
+             <number>5</number>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="0">
+           <widget class="QLabel" name="label_11">
+            <property name="text">
+             <string>Scatter Size</string>
+            </property>
+           </widget>
+          </item>
+          <item row="3" column="0" colspan="3">
+           <widget class="QPushButton" name="pushButton_update_config">
+            <property name="text">
+             <string>Update Settings</string>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="1" colspan="2">
+           <widget class="QSpinBox" name="spinBox_num_dim_points">
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
+            </property>
+            <property name="minimum">
+             <number>10</number>
+            </property>
+            <property name="maximum">
+             <number>1000</number>
+            </property>
+            <property name="singleStep">
+             <number>10</number>
+            </property>
+            <property name="value">
+             <number>100</number>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="0">
+           <widget class="QLabel" name="label_16">
+            <property name="text">
+             <string>N dim</string>
+            </property>
+           </widget>
+          </item>
+          <item row="4" column="0" colspan="3">
+           <widget class="QPushButton" name="pushButton_enableGUI">
+            <property name="text">
+             <string>Enable Control GUI</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+     <widget class="QWidget" name="tab_queue">
+      <attribute name="title">
+       <string>Queue</string>
+      </attribute>
+      <layout class="QVBoxLayout" name="verticalLayout_2">
+       <item>
+        <widget class="QLabel" name="label_3">
+         <property name="text">
+          <string>Work in progress</string>
+         </property>
+         <property name="alignment">
+          <set>Qt::AlignCenter</set>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QPushButton" name="pushButton_5">
+         <property name="enabled">
+          <bool>false</bool>
+         </property>
+         <property name="text">
+          <string>Reset Queue</string>
+         </property>
+        </widget>
+       </item>
+       <item>
+        <widget class="QTableWidget" name="tableWidget_2">
+         <property name="enabled">
+          <bool>false</bool>
+         </property>
+         <column>
+          <property name="text">
+           <string>queueID</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>scan_id</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>is_scan</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>type</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>scan_number</string>
+          </property>
+         </column>
+         <column>
+          <property name="text">
+           <string>IQ status</string>
+          </property>
+         </column>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>GraphicsLayoutWidget</class>
+   <extends>QGraphicsView</extends>
+   <header>pyqtgraph.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>

bec_widgets/examples/plugin_example_pyside/main.py

@@ -7,8 +7,7 @@ import sys
 
 from bec_ipython_client.main import BECIPythonClient
 from qtpy.QtWidgets import QApplication
-
-from bec_widgets.examples.plugin_example_pyside.tictactoe import TicTacToe
+from tictactoe import TicTacToe
 
 if __name__ == "__main__":  # pragma: no cover
     app = QApplication(sys.argv)

bec_widgets/examples/plugin_example_pyside/registertictactoe.py

@@ -2,9 +2,8 @@
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
 from qtpy.QtDesigner import QPyDesignerCustomWidgetCollection
-
-from bec_widgets.examples.plugin_example_pyside.tictactoe import TicTacToe
-from bec_widgets.examples.plugin_example_pyside.tictactoeplugin import TicTacToePlugin
+from tictactoe import TicTacToe
+from tictactoeplugin import TicTacToePlugin
 
 # Set PYSIDE_DESIGNER_PLUGINS to point to this directory and load the plugin
 

bec_widgets/examples/plugin_example_pyside/tictactoeplugin.py

@@ -1,13 +1,10 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
-import os
 
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
-
-import bec_widgets
-from bec_widgets.examples.plugin_example_pyside.tictactoe import TicTacToe
-from bec_widgets.examples.plugin_example_pyside.tictactoetaskmenu import TicTacToeTaskMenuFactory
-from bec_widgets.utils.bec_designer import designer_material_icon
+from qtpy.QtGui import QIcon
+from tictactoe import TicTacToe
+from tictactoetaskmenu import TicTacToeTaskMenuFactory
 
 DOM_XML = """
 <ui language='c++'>
@@ -27,8 +24,6 @@ DOM_XML = """
 </ui>
 """
 
-MODULE_PATH = os.path.dirname(bec_widgets.__file__)
-
 
 class TicTacToePlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
     def __init__(self):
@@ -43,10 +38,10 @@ class TicTacToePlugin(QDesignerCustomWidgetInterface):  # pragma: no cover
         return DOM_XML
 
     def group(self):
-        return "Games"
+        return ""
 
     def icon(self):
-        return designer_material_icon("sports_esports")
+        return QIcon()
 
     def includeFile(self):
         return "tictactoe"

bec_widgets/examples/plugin_example_pyside/tictactoetaskmenu.py

@@ -1,12 +1,11 @@
 # Copyright (C) 2022 The Qt Company Ltd.
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
+from qtpy.QtCore import Slot
 from qtpy.QtDesigner import QExtensionFactory, QPyDesignerTaskMenuExtension
 from qtpy.QtGui import QAction
 from qtpy.QtWidgets import QDialog, QDialogButtonBox, QVBoxLayout
-
-from bec_widgets.examples.plugin_example_pyside.tictactoe import TicTacToe
-from bec_widgets.utils.error_popups import SafeSlot as Slot
+from tictactoe import TicTacToe
 
 
 class TicTacToeDialog(QDialog):  # pragma: no cover

bec_widgets/tests/utils.py

@@ -1,285 +0,0 @@
-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):
-        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/utils/bec_connector.py

@@ -3,29 +3,19 @@ from __future__ import annotations
 
 import os
 import time
-import traceback
 import uuid
-from datetime import datetime
-from typing import TYPE_CHECKING, Optional
+from typing import Optional
 
-from bec_lib.logger import bec_logger
+import yaml
 from bec_lib.utils.import_utils import lazy_import_from
 from pydantic import BaseModel, Field, field_validator
-from qtpy.QtCore import QObject, QRunnable, QThreadPool, QTimer, Signal
-from qtpy.QtWidgets import QApplication
+from qtpy.QtCore import QObject, QRunnable, QThreadPool, Signal
+from qtpy.QtCore import Slot as pyqtSlot
 
-from bec_widgets.cli.rpc.rpc_register import RPCRegister
-from bec_widgets.utils.error_popups import ErrorPopupUtility, SafeSlot
-from bec_widgets.utils.widget_io import WidgetHierarchy
+from bec_widgets.cli.rpc_register import RPCRegister
 from bec_widgets.utils.yaml_dialog import load_yaml, load_yaml_gui, save_yaml, save_yaml_gui
 
-if TYPE_CHECKING:  # pragma: no cover
-    from bec_widgets.utils.bec_dispatcher import BECDispatcher
-    from bec_widgets.widgets.containers.dock import BECDock
-else:
-    BECDispatcher = lazy_import_from("bec_widgets.utils.bec_dispatcher", ("BECDispatcher",))
-
-logger = bec_logger.logger
+BECDispatcher = lazy_import_from("bec_widgets.utils.bec_dispatcher", ("BECDispatcher",))
 
 
 class ConnectionConfig(BaseModel):
@@ -43,7 +33,8 @@ class ConnectionConfig(BaseModel):
         """Generate a GUI ID if none is provided."""
         if v is None:
             widget_class = values.data["widget_class"]
-            v = f"{widget_class}_{datetime.now().strftime('%Y_%m_%d_%H_%M_%S_%f')}"
+            v = f"{widget_class}_{str(time.time())}"
+            return v
         return v
 
 
@@ -73,202 +64,38 @@ class Worker(QRunnable):
 
 
 class BECConnector:
-    """Connection mixin class to handle BEC client and device manager"""
+    """Connection mixin class for all BEC widgets, to handle BEC client and device manager"""
 
-    USER_ACCESS = ["_config_dict", "_get_all_rpc", "_rpc_id"]
-    EXIT_HANDLERS = {}
-    widget_removed = Signal()
-    name_established = Signal(str)
-
-    def __init__(
-        self,
-        client=None,
-        config: ConnectionConfig | None = None,
-        gui_id: str | None = None,
-        object_name: str | None = None,
-        parent_dock: BECDock | None = None,  # TODO should go away -> issue created #473
-        root_widget: bool = False,
-        **kwargs,
-    ):
-        """
-        BECConnector mixin class to handle BEC client and device manager.
-
-        Args:
-            client(BECClient, optional): The BEC client.
-            config(ConnectionConfig, optional): The connection configuration with specific gui id.
-            gui_id(str, optional): The GUI ID.
-            object_name(str, optional): The object name.
-            parent_dock(BECDock, optional): The parent dock.# TODO should go away -> issue created #473
-            root_widget(bool, optional): If set to True, the parent_id will be always set to None, thus enforcing that the widget is accessible as a root widget of the BECGuiClient object.
-            **kwargs:
-        """
-        # Extract object_name from kwargs to not pass it to Qt class
-        object_name = object_name or kwargs.pop("objectName", None)
-        # Ensure the parent is always the first argument for QObject
-        parent = kwargs.pop("parent", None)
-        # This initializes the QObject or any qt related class BECConnector has to be used from this line down with QObject, otherwise hierarchy logic will not work
-        super().__init__(parent=parent, **kwargs)
-
-        assert isinstance(
-            self, QObject
-        ), "BECConnector must be used with a QObject or any qt related class."
-
-        # flag to check if the object was destroyed and its cleanup was called
-        self._destroyed = False
+    USER_ACCESS = ["_config_dict", "_get_all_rpc"]
 
+    def __init__(self, client=None, config: ConnectionConfig = None, gui_id: str = None):
         # BEC related connections
         self.bec_dispatcher = BECDispatcher(client=client)
         self.client = self.bec_dispatcher.client if client is None else client
-        self._parent_dock = parent_dock  # TODO also remove at some point -> issue created #473
-        self.rpc_register = RPCRegister()
-
-        if not self.client in BECConnector.EXIT_HANDLERS:
-            # register function to clean connections at exit;
-            # the function depends on BECClient, and BECDispatcher
-            @SafeSlot()
-            def terminate(client=self.client, dispatcher=self.bec_dispatcher):
-                logger.info("Disconnecting", repr(dispatcher))
-                dispatcher.disconnect_all()
-                logger.info("Shutting down BEC Client", repr(client))
-                client.shutdown()
-
-            BECConnector.EXIT_HANDLERS[self.client] = terminate
-            QApplication.instance().aboutToQuit.connect(terminate)
 
         if config:
             self.config = config
             self.config.widget_class = self.__class__.__name__
         else:
-            logger.debug(
+            print(
                 f"No initial config found for {self.__class__.__name__}.\n"
                 f"Initializing with default config."
             )
             self.config = ConnectionConfig(widget_class=self.__class__.__name__)
 
-        # If the gui_id is passed, it should be respected. However, this should be revisted since
-        # the gui_id has to be unique, and may no longer be.
         if gui_id:
             self.config.gui_id = gui_id
-            self.gui_id: str = gui_id  # Keep namespace in sync
+            self.gui_id = gui_id
         else:
-            self.gui_id: str = self.config.gui_id  # type: ignore
+            self.gui_id = self.config.gui_id
 
-        if object_name is not None:
-            self.setObjectName(object_name)
-
-        # 1) If no objectName is set, set the initial name
-        if not self.objectName():
-            self.setObjectName(self.__class__.__name__)
-        self.object_name = self.objectName()
-
-        # 2) Enforce unique objectName among siblings with the same BECConnector parent
-        self.setParent(parent)
-
-        # Error popups
-        self.error_utility = ErrorPopupUtility()
+        # register widget to rpc register
+        self.rpc_register = RPCRegister()
+        self.rpc_register.add_rpc(self)
 
         self._thread_pool = QThreadPool.globalInstance()
-        # Store references to running workers so they're not garbage collected prematurely.
-        self._workers = []
 
-        # If set to True, the parent_id will be always set to None, thus enforcing that the widget is accessible as a root widget of the BECGuiClient object.
-        self.root_widget = root_widget
-
-        QTimer.singleShot(0, self._update_object_name)
-
-    @property
-    def parent_id(self) -> str | None:
-        try:
-            if self.root_widget:
-                return None
-            connector_parent = WidgetHierarchy._get_becwidget_ancestor(self)
-            return connector_parent.gui_id if connector_parent else None
-        except:
-            logger.error(f"Error getting parent_id for {self.__class__.__name__}")
-
-    def change_object_name(self, name: str) -> None:
-        """
-        Change the object name of the widget. Unregister old name and register the new one.
-
-        Args:
-            name (str): The new object name.
-        """
-        self.rpc_register.remove_rpc(self)
-        self.setObjectName(name.replace("-", "_").replace(" ", "_"))
-        QTimer.singleShot(0, self._update_object_name)
-
-    def _update_object_name(self) -> None:
-        """
-        Enforce a unique object name among siblings and register the object for RPC.
-        This method is called through a single shot timer kicked off in the constructor.
-        """
-        # 1) Enforce unique objectName among siblings with the same BECConnector parent
-        self._enforce_unique_sibling_name()
-        # 2) Register the object for RPC
-        self.rpc_register.add_rpc(self)
-        try:
-            self.name_established.emit(self.object_name)
-        except RuntimeError:
-            return
-
-    def _enforce_unique_sibling_name(self):
-        """
-        Enforce that this BECConnector has a unique objectName among its siblings.
-
-        Sibling logic:
-          - 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()
-        parent_bec = WidgetHierarchy._get_becwidget_ancestor(self)
-
-        if parent_bec:
-            # We have a parent => only compare with siblings under that parent
-            siblings = parent_bec.findChildren(BECConnector)
-        else:
-            # No parent => treat all top-level BECConnectors as siblings
-            # 1) Gather all BECConnectors from QApplication
-            all_widgets = QApplication.allWidgets()
-            all_bec = [w for w in all_widgets if isinstance(w, BECConnector)]
-            # 2) "Top-level" means closest BECConnector parent is None
-            top_level_bec = [
-                w for w in all_bec if WidgetHierarchy._get_becwidget_ancestor(w) is None
-            ]
-            # 3) We are among these top-level siblings
-            siblings = top_level_bec
-
-        # Collect used names among siblings
-        used_names = {sib.objectName() for sib in siblings if sib is not self}
-
-        base_name = self.object_name
-        if base_name not in used_names:
-            # Name is already unique among siblings
-            return
-
-        # Need a suffix to avoid collision
-        counter = 0
-        while True:
-            trial_name = f"{base_name}_{counter}"
-            if trial_name not in used_names:
-                self.setObjectName(trial_name)
-                self.object_name = trial_name
-                break
-            counter += 1
-
-    # pylint: disable=invalid-name
-    def setObjectName(self, name: str) -> None:
-        """
-        Set the object name of the widget.
-
-        Args:
-            name (str): The new object name.
-        """
-        super().setObjectName(name)
-        self.object_name = name
-        if self.rpc_register.object_is_registered(self):
-            self.rpc_register.broadcast()
-
-    def submit_task(self, fn, *args, on_complete: SafeSlot = None, **kwargs) -> Worker:
+    def submit_task(self, fn, *args, on_complete: pyqtSlot = None, **kwargs) -> Worker:
         """
         Submit a task to run in a separate thread. The task will run the specified
         function with the provided arguments and emit the completed signal when done.
@@ -295,14 +122,11 @@ class BECConnector:
             >>> def on_complete():
             >>>     print("Task complete")
             >>> self.submit_task(my_function, 1, 2, on_complete=on_complete)
+
         """
         worker = Worker(fn, *args, **kwargs)
         if on_complete:
             worker.signals.completed.connect(on_complete)
-        # Keep a reference to the worker so it is not garbage collected.
-        self._workers.append(worker)
-        # When the worker is done, remove it from our list.
-        worker.signals.completed.connect(lambda: self._workers.remove(worker))
         self._thread_pool.start(worker)
         return worker
 
@@ -334,39 +158,37 @@ class BECConnector:
     @_config_dict.setter
     def _config_dict(self, config: BaseModel) -> None:
         """
-        Set the configuration of the widget.
+        Get the configuration of the widget.
 
-        Args:
-            config (BaseModel): The new configuration model.
+        Returns:
+            dict: The configuration of the widget.
         """
         self.config = config
 
-    # FIXME some thoughts are required to decide how thhis should work with rpc registry
     def apply_config(self, config: dict, generate_new_id: bool = True) -> None:
         """
         Apply the configuration to the widget.
 
         Args:
-            config (dict): Configuration settings.
-            generate_new_id (bool): If True, generate a new GUI ID for the widget.
+            config(dict): Configuration settings.
+            generate_new_id(bool): If True, generate a new GUI ID for the widget.
         """
         self.config = ConnectionConfig(**config)
         if generate_new_id is True:
             gui_id = str(uuid.uuid4())
             self.rpc_register.remove_rpc(self)
-            self._set_gui_id(gui_id)
+            self.set_gui_id(gui_id)
             self.rpc_register.add_rpc(self)
         else:
             self.gui_id = self.config.gui_id
 
-    # FIXME some thoughts are required to decide how thhis should work with rpc registry
     def load_config(self, path: str | None = None, gui: bool = False):
         """
         Load the configuration of the widget from YAML.
 
         Args:
-            path (str | None): Path to the configuration file for non-GUI dialog mode.
-            gui (bool): If True, use the GUI dialog to load the configuration file.
+            path(str): Path to the configuration file for non-GUI dialog mode.
+            gui(bool): If True, use the GUI dialog to load the configuration file.
         """
         if gui is True:
             config = load_yaml_gui(self)
@@ -385,8 +207,8 @@ class BECConnector:
         Save the configuration of the widget to YAML.
 
         Args:
-            path (str | None): Path to save the configuration file for non-GUI dialog mode.
-            gui (bool): If True, use the GUI dialog to save the configuration file.
+            path(str): Path to save the configuration file for non-GUI dialog mode.
+            gui(bool): If True, use the GUI dialog to save the configuration file.
         """
         if gui is True:
             save_yaml_gui(self, self._config_dict)
@@ -394,15 +216,16 @@ class BECConnector:
             if path is None:
                 path = os.getcwd()
             file_path = os.path.join(path, f"{self.__class__.__name__}_config.yaml")
+
             save_yaml(file_path, self._config_dict)
 
-    # @SafeSlot(str)
-    def _set_gui_id(self, gui_id: str) -> None:
+    @pyqtSlot(str)
+    def set_gui_id(self, gui_id: str) -> None:
         """
         Set the GUI ID for the widget.
 
         Args:
-            gui_id (str): GUI ID.
+            gui_id(str): GUI ID
         """
         self.config.gui_id = gui_id
         self.gui_id = gui_id
@@ -423,85 +246,49 @@ class BECConnector:
         """Update the client and device manager from BEC and create object for BEC shortcuts.
 
         Args:
-            client: BEC client.
+            client: BEC client
         """
         self.client = client
         self.get_bec_shortcuts()
 
-    @SafeSlot(ConnectionConfig)  # TODO can be also dict
+    @pyqtSlot(ConnectionConfig)  # TODO can be also dict
     def on_config_update(self, config: ConnectionConfig | dict) -> None:
         """
         Update the configuration for the widget.
 
         Args:
-            config (ConnectionConfig | dict): Configuration settings.
+            config(ConnectionConfig): Configuration settings.
         """
-        gui_id = getattr(config, "gui_id", None)
         if isinstance(config, dict):
             config = ConnectionConfig(**config)
-        self.config = config
-        if gui_id and config.gui_id != gui_id:  # Recreating config should not overwrite the gui_id
-            self.config.gui_id = gui_id
+            # TODO add error handler
 
-    def remove(self):
-        """Cleanup the BECConnector"""
-        # If the widget is attached to a dock, remove it from the dock.
-        # TODO this should be handled by dock and dock are not by BECConnector  -> issue created #473
-        if self._parent_dock is not None:
-            self._parent_dock.delete(self.object_name)
-        # If the widget is from Qt, trigger its close method.
-        elif hasattr(self, "close"):
-            self.close()
-        # If the widget is neither from a Dock nor from Qt, remove it from the RPC registry.
-        # i.e. Curve Item from Waveform
-        else:
-            self.rpc_register.remove_rpc(self)
-        self.widget_removed.emit()  # Emit the remove signal to notify listeners (eg docks in QtADS)
+        self.config = config
 
     def get_config(self, dict_output: bool = True) -> dict | BaseModel:
         """
         Get the configuration of the widget.
 
         Args:
-            dict_output (bool): If True, return the configuration as a dictionary.
-                                If False, return the configuration as a pydantic model.
+            dict_output(bool): If True, return the configuration as a dictionary. If False, return the configuration as a pydantic model.
 
         Returns:
-            dict | BaseModel: The configuration of the widget.
+            dict: The configuration of the plot widget.
         """
         if dict_output:
             return self.config.model_dump()
         else:
             return self.config
 
+    def cleanup(self):
+        """Cleanup the widget."""
+        self.rpc_register.remove_rpc(self)
+        all_connections = self.rpc_register.list_all_connections()
+        if len(all_connections) == 0:
+            print("No more connections. Shutting down GUI BEC client.")
+            self.bec_dispatcher.disconnect_all()
+            self.client.shutdown()
 
-# --- Example usage of BECConnector: running a simple task ---
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    # Create a QApplication instance (required for QThreadPool)
-    app = QApplication(sys.argv)
-
-    connector = BECConnector()
-
-    def print_numbers():
-        """
-        Task function that prints numbers 1 to 10 with a 0.5 second delay between each.
-        """
-        for i in range(1, 11):
-            print(i)
-            time.sleep(0.5)
-
-    def task_complete():
-        """
-        Called when the task is complete.
-        """
-        print("Task complete")
-        # Exit the application after the task completes.
-        app.quit()
-
-    # Submit the task using the connector's submit_task method.
-    connector.submit_task(print_numbers, on_complete=task_complete)
-
-    # Start the Qt event loop.
-    sys.exit(app.exec_())
+    # def closeEvent(self, event):
+    #     self.cleanup()
+    #     super().closeEvent(event)

bec_widgets/utils/bec_designer.py

@@ -6,38 +6,21 @@ import sys
 import sysconfig
 from pathlib import Path
 
-from bec_qthemes import material_icon
 from qtpy import PYSIDE6
-from qtpy.QtGui import QIcon
-
-from bec_widgets.utils.bec_plugin_helper import user_widget_plugin
 
 if PYSIDE6:
     from PySide6.scripts.pyside_tool import (
         _extend_path_var,
         init_virtual_env,
+        qt_tool_wrapper,
         is_pyenv_python,
         is_virtual_env,
-        qt_tool_wrapper,
         ui_tool_binary,
     )
 
 import bec_widgets
 
 
-def designer_material_icon(icon_name: str) -> QIcon:
-    """
-    Create a QIcon for the BECDesigner with the given material icon name.
-
-    Args:
-        icon_name (str): The name of the material icon.
-
-    Returns:
-        QIcon: The QIcon for the material icon.
-    """
-    return QIcon(material_icon(icon_name, filled=True, convert_to_pixmap=True))
-
-
 def list_editable_packages() -> set[str]:
     """
     List all editable packages in the environment.
@@ -78,7 +61,7 @@ def list_editable_packages() -> set[str]:
     return editable_packages
 
 
-def patch_designer(cmd_args: list[str] = []):  # pragma: no cover
+def patch_designer():  # pragma: no cover
     if not PYSIDE6:
         print("PYSIDE6 is not available in the environment. Cannot patch designer.")
         return
@@ -95,31 +78,24 @@ def patch_designer(cmd_args: list[str] = []):  # pragma: no cover
             _extend_path_var("PATH", os.fspath(Path(sys._base_executable).parent), True)
     else:
         if sys.platform == "linux":
+            suffix = f"{sys.abiflags}.so"
             env_var = "LD_PRELOAD"
-            current_pid = os.getpid()
-            with open(f"/proc/{current_pid}/maps", "rt") as f:
-                for line in f:
-                    if "libpython" in line:
-                        lib_path = line.split()[-1]
-                        os.environ[env_var] = lib_path
-                        break
-
         elif sys.platform == "darwin":
             suffix = ".dylib"
             env_var = "DYLD_INSERT_LIBRARIES"
-            version = f"{major_version}.{minor_version}"
-            library_name = f"libpython{version}{suffix}"
-            lib_path = str(Path(sysconfig.get_config_var("LIBDIR")) / library_name)
-            os.environ[env_var] = lib_path
         else:
             raise RuntimeError(f"Unsupported platform: {sys.platform}")
+        version = f"{major_version}.{minor_version}"
+        library_name = f"libpython{version}{suffix}"
+        lib_path = str(Path(sysconfig.get_config_var("LIBDIR")) / library_name)
+        os.environ[env_var] = lib_path
 
         if is_pyenv_python() or is_virtual_env():
             # append all editable packages to the PYTHONPATH
             editable_packages = list_editable_packages()
             for pckg in editable_packages:
                 _extend_path_var("PYTHONPATH", pckg, True)
-    qt_tool_wrapper(ui_tool_binary("designer"), cmd_args)
+    qt_tool_wrapper(ui_tool_binary("designer"), sys.argv[1:])
 
 
 def find_plugin_paths(base_path: Path):
@@ -147,24 +123,15 @@ def set_plugin_environment_variable(plugin_paths):
 
 
 # Patch the designer function
-def open_designer(cmd_args: list[str] = []):  # pragma: no cover
+def main():  # pragma: no cover
     if not PYSIDE6:
         print("PYSIDE6 is not available in the environment. Exiting...")
         return
     base_dir = Path(os.path.dirname(bec_widgets.__file__)).resolve()
-
     plugin_paths = find_plugin_paths(base_dir)
-    if (plugin_repo := user_widget_plugin()) and isinstance(plugin_repo.__file__, str):
-        plugin_repo_dir = Path(os.path.dirname(plugin_repo.__file__)).resolve()
-        plugin_paths.extend(find_plugin_paths(plugin_repo_dir))
-
     set_plugin_environment_variable(plugin_paths)
 
-    patch_designer(cmd_args)
-
-
-def main():
-    open_designer(sys.argv[1:])
+    patch_designer()
 
 
 if __name__ == "__main__":  # pragma: no cover

bec_widgets/utils/bec_dispatcher.py

@@ -1,66 +1,36 @@
 from __future__ import annotations
 
 import collections
-import random
-import string
 from collections.abc import Callable
-from typing import TYPE_CHECKING, DefaultDict, Hashable, Union
+from typing import TYPE_CHECKING, Union
 
-import louie
 import redis
 from bec_lib.client import BECClient
-from bec_lib.logger import bec_logger
 from bec_lib.redis_connector import MessageObject, RedisConnector
 from bec_lib.service_config import ServiceConfig
-from qtpy.QtCore import QObject
+from qtpy.QtCore import PYQT5, PYQT6, PYSIDE2, PYSIDE6, QCoreApplication, QObject
 from qtpy.QtCore import Signal as pyqtSignal
 
-from bec_widgets.utils.serialization import register_serializer_extension
-
-logger = bec_logger.logger
-
-if TYPE_CHECKING:  # pragma: no cover
+if TYPE_CHECKING:
     from bec_lib.endpoints import EndpointInfo
 
-    from bec_widgets.utils.rpc_server import RPCServer
-
 
 class QtThreadSafeCallback(QObject):
-    """QtThreadSafeCallback is a wrapper around a callback function to make it thread-safe for Qt."""
-
     cb_signal = pyqtSignal(dict, dict)
 
-    def __init__(self, cb: Callable, cb_info: dict | None = None):
-        """
-        Initialize the QtThreadSafeCallback.
-
-        Args:
-            cb (Callable): The callback function to be wrapped.
-            cb_info (dict, optional): Additional information about the callback. Defaults to None.
-        """
+    def __init__(self, cb):
         super().__init__()
-        self.cb_info = cb_info
 
         self.cb = cb
-        self.cb_ref = louie.saferef.safe_ref(cb)
         self.cb_signal.connect(self.cb)
-        self.topics = set()
 
     def __hash__(self):
         # make 2 differents QtThreadSafeCallback to look
         # identical when used as dictionary keys, if the
         # callback is the same
-        return f"{id(self.cb_ref)}{self.cb_info}".__hash__()
-
-    def __eq__(self, other):
-        if not isinstance(other, QtThreadSafeCallback):
-            return False
-        return self.cb_ref == other.cb_ref and self.cb_info == other.cb_info
+        return id(self.cb)
 
     def __call__(self, msg_content, metadata):
-        if self.cb_ref() is None:
-            # callback has been deleted
-            return
         self.cb_signal.emit(msg_content, metadata)
 
 
@@ -95,34 +65,32 @@ class QtRedisConnector(RedisConnector):
             cb(msg.content, msg.metadata)
 
 
+class BECClientWithoutLoggerInit(BECClient):
+    def _initialize_logger(self):
+        return
+
+
 class BECDispatcher:
     """Utility class to keep track of slots connected to a particular redis connector"""
 
     _instance = None
     _initialized = False
-    client: BECClient
-    cli_server: RPCServer | None = None
+    qapp = None
 
-    def __new__(
-        cls,
-        client=None,
-        config: str | ServiceConfig | None = None,
-        gui_id: str | None = None,
-        *args,
-        **kwargs,
-    ):
+    def __new__(cls, client=None, config: str = None, *args, **kwargs):
         if cls._instance is None:
             cls._instance = super(BECDispatcher, cls).__new__(cls)
             cls._initialized = False
         return cls._instance
 
-    def __init__(self, client=None, config: str | ServiceConfig | None = None, gui_id: str = None):
+    def __init__(self, client=None, config: str | ServiceConfig = None):
         if self._initialized:
             return
 
-        self._registered_slots: DefaultDict[Hashable, QtThreadSafeCallback] = (
-            collections.defaultdict()
-        )
+        if not QCoreApplication.instance():
+            BECDispatcher.qapp = QCoreApplication([])
+
+        self._slots = collections.defaultdict(set)
         self.client = client
 
         if self.client is None:
@@ -130,154 +98,79 @@ class BECDispatcher:
                 if not isinstance(config, ServiceConfig):
                     # config is supposed to be a path
                     config = ServiceConfig(config)
-            self.client = BECClient(
-                config=config, connector_cls=QtRedisConnector, name="BECWidgets"
-            )
+                self.client = BECClientWithoutLoggerInit(
+                    config=config, connector_cls=QtRedisConnector
+                )  # , forced=True)
+            else:
+                self.client = BECClientWithoutLoggerInit(
+                    connector_cls=QtRedisConnector
+                )  # , forced=True)
         else:
             if self.client.started:
                 # have to reinitialize client to use proper connector
-                logger.info("Shutting down BECClient to switch to QtRedisConnector")
                 self.client.shutdown()
             self.client._BECClient__init_params["connector_cls"] = QtRedisConnector
 
         try:
             self.client.start()
         except redis.exceptions.ConnectionError:
-            logger.warning("Could not connect to Redis, skipping start of BECClient.")
+            print("Could not connect to Redis, skipping start of BECClient.")
 
-        register_serializer_extension()
-
-        logger.success("Initialized BECDispatcher")
-
-        self.start_cli_server(gui_id=gui_id)
         self._initialized = True
 
     @classmethod
     def reset_singleton(cls):
-        """
-        Reset the singleton instance of the BECDispatcher.
-        """
         cls._instance = None
         cls._initialized = False
 
+        if not cls.qapp:
+            return
+
+        # shutdown QCoreApp if it exists
+        if PYQT5 or PYQT6:
+            cls.qapp.exit()
+        elif PYSIDE2 or PYSIDE6:
+            cls.qapp.shutdown()
+        cls.qapp = None
+
     def connect_slot(
-        self,
-        slot: Callable,
-        topics: EndpointInfo | str | list[EndpointInfo] | list[str],
-        cb_info: dict | None = None,
-        **kwargs,
+        self, slot: Callable, topics: Union[EndpointInfo, str, list[Union[EndpointInfo, str]]]
     ) -> None:
-        """Connect widget's qt slot, so that it is called on new pub/sub topic message.
+        """Connect widget's pyqt slot, so that it is called on new pub/sub topic message.
 
         Args:
             slot (Callable): A slot method/function that accepts two inputs: content and metadata of
                 the corresponding pub/sub message
-            topics EndpointInfo | str | list[EndpointInfo] | list[str]: A topic or list of topics that can typically be acquired via bec_lib.MessageEndpoints
-            cb_info (dict | None): A dictionary containing information about the callback. Defaults to None.
+            topics (EndpointInfo | str | list): A topic or list of topics that can typically be acquired via bec_lib.MessageEndpoints
         """
-        qt_slot = QtThreadSafeCallback(cb=slot, cb_info=cb_info)
-        if qt_slot not in self._registered_slots:
-            self._registered_slots[qt_slot] = qt_slot
-        qt_slot = self._registered_slots[qt_slot]
-        self.client.connector.register(topics, cb=qt_slot, **kwargs)
+        slot = QtThreadSafeCallback(slot)
+        self.client.connector.register(topics, cb=slot)
         topics_str, _ = self.client.connector._convert_endpointinfo(topics)
-        qt_slot.topics.update(set(topics_str))
+        self._slots[slot].update(set(topics_str))
 
-    def disconnect_slot(
-        self, slot: Callable, topics: EndpointInfo | str | list[EndpointInfo] | list[str]
-    ):
-        """
-        Disconnect a slot from a topic.
-
-        Args:
-            slot(Callable): The slot to disconnect
-            topics EndpointInfo | str | list[EndpointInfo] | list[str]: A topic or list of topics to unsub from.
-        """
+    def disconnect_slot(self, slot: Callable, topics: Union[str, list]):
         # find the right slot to disconnect from ;
         # slot callbacks are wrapped in QtThreadSafeCallback objects,
         # but the slot we receive here is the original callable
-        for connected_slot in self._registered_slots.values():
+        for connected_slot in self._slots:
             if connected_slot.cb == slot:
                 break
         else:
             return
         self.client.connector.unregister(topics, cb=connected_slot)
         topics_str, _ = self.client.connector._convert_endpointinfo(topics)
-        self._registered_slots[connected_slot].topics.difference_update(set(topics_str))
-        if not self._registered_slots[connected_slot].topics:
-            del self._registered_slots[connected_slot]
+        self._slots[slot].difference_update(set(topics_str))
+        if not self._slots[slot]:
+            del self._slots[slot]
 
     def disconnect_topics(self, topics: Union[str, list]):
-        """
-        Disconnect all slots from a topic.
-
-        Args:
-            topics(Union[str, list]): The topic(s) to disconnect from
-        """
         self.client.connector.unregister(topics)
         topics_str, _ = self.client.connector._convert_endpointinfo(topics)
-
-        remove_slots = []
-        for connected_slot in self._registered_slots.values():
-            connected_slot.topics.difference_update(set(topics_str))
-
-            if not connected_slot.topics:
-                remove_slots.append(connected_slot)
-
-        for connected_slot in remove_slots:
-            self._registered_slots.pop(connected_slot, None)
+        for slot in list(self._slots.keys()):
+            slot_topics = self._slots[slot]
+            slot_topics.difference_update(set(topics_str))
+            if not slot_topics:
+                del self._slots[slot]
 
     def disconnect_all(self, *args, **kwargs):
-        """
-        Disconnect all slots from all topics.
-
-        Args:
-            *args: Arbitrary positional arguments
-            **kwargs: Arbitrary keyword arguments
-        """
-        # pylint: disable=protected-access
         self.disconnect_topics(self.client.connector._topics_cb)
-
-    def start_cli_server(self, gui_id: str | None = None):
-        """
-        Start the CLI server.
-
-        Args:
-            gui_id(str, optional): The GUI ID. Defaults to None. If None, a unique identifier will be generated.
-        """
-        # pylint: disable=import-outside-toplevel
-        from bec_widgets.utils.rpc_server import RPCServer
-
-        if gui_id is None:
-            gui_id = self.generate_unique_identifier()
-
-        if not self.client.started:
-            logger.error("Cannot start CLI server without a running client")
-            return
-        self.cli_server = RPCServer(gui_id, dispatcher=self, client=self.client)
-        logger.success(f"Started CLI server with gui_id: {gui_id}")
-
-    def stop_cli_server(self):
-        """
-        Stop the CLI server.
-        """
-        if self.cli_server is None:
-            logger.error("Cannot stop CLI server without starting it first")
-            return
-        self.cli_server.shutdown()
-        self.cli_server = None
-        logger.success("Stopped CLI server")
-
-    @staticmethod
-    def generate_unique_identifier(length: int = 4) -> str:
-        """
-        Generate a unique identifier for the application.
-
-        Args:
-            length: The length of the identifier. Defaults to 4.
-
-        Returns:
-            str: The unique identifier.
-        """
-        allowed_chars = string.ascii_lowercase + string.digits
-        return "".join(random.choices(allowed_chars, k=length))

bec_widgets/utils/bec_plugin_helper.py

@@ -1,105 +0,0 @@
-from __future__ import annotations
-
-import importlib.metadata
-import inspect
-import pkgutil
-import traceback
-from importlib import util as importlib_util
-from importlib.machinery import FileFinder, ModuleSpec, SourceFileLoader
-from types import ModuleType
-from typing import Generator
-
-from bec_lib.logger import bec_logger
-
-from bec_widgets.utils.plugin_utils import BECClassContainer, BECClassInfo
-
-logger = bec_logger.logger
-
-
-def _submodule_specs(module: ModuleType) -> tuple[ModuleSpec | None, ...]:
-    """Return specs for all submodules of the given module."""
-    return tuple(
-        module_info.module_finder.find_spec(module_info.name)
-        for module_info in pkgutil.iter_modules(module.__path__)
-        if isinstance(module_info.module_finder, FileFinder)
-    )
-
-
-def _loaded_submodules_from_specs(
-    submodule_specs: tuple[ModuleSpec | None, ...],
-) -> Generator[ModuleType, None, None]:
-    """Load all submodules from the given specs."""
-    for submodule in (
-        importlib_util.module_from_spec(spec) for spec in submodule_specs if spec is not None
-    ):
-        assert isinstance(
-            submodule.__loader__, SourceFileLoader
-        ), "Module found from FileFinder should have SourceFileLoader!"
-        try:
-            submodule.__loader__.exec_module(submodule)
-        except Exception as e:
-            exception_text = "".join(traceback.format_exception(e))
-            if "(most likely due to a circular import)" in exception_text:
-                logger.warning(f"Circular import encountered while loading {submodule}")
-            else:
-                logger.error(f"Error loading plugin {submodule}: \n{exception_text}")
-        yield submodule
-
-
-def _submodule_by_name(module: ModuleType, name: str):
-    for submod in _loaded_submodules_from_specs(_submodule_specs(module)):
-        if submod.__name__ == name:
-            return submod
-    return None
-
-
-def _get_widgets_from_module(module: ModuleType) -> BECClassContainer:
-    """Find any BECWidget subclasses in the given module and return them with their info."""
-    from bec_widgets.utils.bec_widget import BECWidget  # avoid circular import
-
-    classes = inspect.getmembers(
-        module,
-        predicate=lambda item: inspect.isclass(item)
-        and issubclass(item, BECWidget)
-        and item is not BECWidget
-        and not item.__module__.startswith("bec_widgets"),
-    )
-    return BECClassContainer(
-        BECClassInfo(name=k, module=module.__name__, file=module.__loader__.get_filename(), obj=v)
-        for k, v in classes
-    )
-
-
-def _all_widgets_from_all_submods(module) -> BECClassContainer:
-    """Recursively load submodules, find any BECWidgets, and return them all as a flat dict."""
-    widgets = _get_widgets_from_module(module)
-    if not hasattr(module, "__path__"):
-        return widgets
-    for submod in _loaded_submodules_from_specs(_submodule_specs(module)):
-        widgets += _all_widgets_from_all_submods(submod)
-    return widgets
-
-
-def user_widget_plugin() -> ModuleType | None:
-    plugins = importlib.metadata.entry_points(group="bec.widgets.user_widgets")  # type: ignore
-    return None if len(plugins) == 0 else tuple(plugins)[0].load()
-
-
-def get_plugin_client_module() -> ModuleType | None:
-    """If there is a plugin repository installed, return the client module."""
-    return _submodule_by_name(plugin, "client") if (plugin := user_widget_plugin()) else None
-
-
-def get_all_plugin_widgets() -> BECClassContainer:
-    """If there is a plugin repository installed, load all widgets from it."""
-    if plugin := user_widget_plugin():
-        return _all_widgets_from_all_submods(plugin)
-    else:
-        return BECClassContainer()
-
-
-if __name__ == "__main__":  # pragma: no cover
-
-    client = get_plugin_client_module()
-    print(get_all_plugin_widgets())
-    ...

bec_widgets/utils/bec_plugin_manager/create/widget.py

@@ -1,86 +0,0 @@
-import traceback
-from pathlib import Path
-from typing import Annotated
-
-import copier
-import typer
-from bec_lib.logger import bec_logger
-from bec_lib.plugin_helper import plugin_repo_path
-from bec_lib.utils.plugin_manager._constants import ANSWER_KEYS
-from bec_lib.utils.plugin_manager._util import existing_data, git_stage_files, make_commit
-
-from bec_widgets.utils.bec_plugin_manager.edit_ui import open_and_watch_ui_editor
-
-logger = bec_logger.logger
-_app = typer.Typer(rich_markup_mode="rich")
-
-
-def _commit_added_widget(repo: Path, name: str):
-    git_stage_files(repo, [".copier-answers.yml"])
-    git_stage_files(repo / repo.name / "bec_widgets" / "widgets" / name, [])
-    make_commit(repo, f"plugin-manager added new widget: {name}")
-    logger.info(f"Committing new widget {name}")
-
-
-def _widget_exists(widget_list: list[dict[str, str | bool]], name: str):
-    return name in [w["name"] for w in widget_list]
-
-
-def _editor_cb(ctx: typer.Context, value: bool):
-    if value and not ctx.params["use_ui"]:
-        raise typer.BadParameter("Can only open the editor if creating a .ui file!")
-    return value
-
-
-_bold_blue = "\033[34m\033[1m"
-_off = "\033[0m"
-_USE_UI_MSG = "Generate a .ui file for use in bec-designer."
-_OPEN_DESIGNER_MSG = f"""This app can watch for changes and recompile them to a python file imported to the widget whenever it is saved.
-To open this editor independently, you can use {_bold_blue}bec-plugin-manager edit-ui [widget_name]{_off}.
-Open the created widget .ui file in bec-designer now?"""
-
-
-@_app.command()
-def widget(
-    name: Annotated[str, typer.Argument(help="Enter a name for your widget in snake_case")],
-    use_ui: Annotated[bool, typer.Option(prompt=_USE_UI_MSG, help=_USE_UI_MSG)] = True,
-    open_editor: Annotated[
-        bool, typer.Option(prompt=_OPEN_DESIGNER_MSG, help=_OPEN_DESIGNER_MSG, callback=_editor_cb)
-    ] = True,
-):
-    """Create a new widget plugin with the given name.
-
-If [bold white]use_ui[/bold white] is set, a bec-designer .ui file will also be created. If \
-[bold white]open_editor[/bold white] is additionally set, the .ui file will be opened in \
-bec-designer and the compiled python version will be updated when changes are made and saved."""
-    if (formatted_name := name.lower().replace("-", "_")) != name:
-        logger.warning(f"Adjusting widget name from {name} to {formatted_name}")
-    if not formatted_name.isidentifier():
-        logger.error(
-            f"{name} is not a valid name for a widget (even after converting to {formatted_name}) - please enter something in snake_case"
-        )
-        exit(-1)
-    logger.info(f"Adding new widget {formatted_name} to the template...")
-    try:
-        repo = Path(plugin_repo_path())
-        plugin_data = existing_data(repo, [ANSWER_KEYS.VERSION, ANSWER_KEYS.WIDGETS])
-        if _widget_exists(plugin_data[ANSWER_KEYS.WIDGETS], formatted_name):
-            logger.error(f"Widget {formatted_name} already exists!")
-            exit(-1)
-        plugin_data[ANSWER_KEYS.WIDGETS].append({"name": formatted_name, "use_ui": use_ui})
-        copier.run_update(
-            repo,
-            data=plugin_data,
-            defaults=True,
-            unsafe=True,
-            overwrite=True,
-            vcs_ref=plugin_data[ANSWER_KEYS.VERSION],
-        )
-        _commit_added_widget(repo, formatted_name)
-    except Exception:
-        logger.error(traceback.format_exc())
-        logger.error("exiting...")
-        exit(-1)
-    logger.success(f"Added widget {formatted_name}!")
-    if open_editor:
-        open_and_watch_ui_editor(formatted_name)

bec_widgets/utils/bec_plugin_manager/edit_ui.py

@@ -1,136 +0,0 @@
-import re
-import subprocess
-from pathlib import Path
-
-from bec_lib.logger import bec_logger
-from bec_lib.plugin_helper import plugin_package_name, plugin_repo_path
-from watchdog.events import (
-    DirCreatedEvent,
-    DirModifiedEvent,
-    DirMovedEvent,
-    FileCreatedEvent,
-    FileModifiedEvent,
-    FileMovedEvent,
-    FileSystemEvent,
-    FileSystemEventHandler,
-)
-from watchdog.observers import Observer
-
-from bec_widgets.utils.bec_designer import open_designer
-from bec_widgets.utils.bec_plugin_helper import get_all_plugin_widgets
-from bec_widgets.utils.plugin_utils import get_custom_classes
-
-logger = bec_logger.logger
-
-
-class RecompileHandler(FileSystemEventHandler):
-    def __init__(self, in_file: Path, out_file: Path) -> None:
-        super().__init__()
-        self.in_file = str(in_file)
-        self.out_file = str(out_file)
-        self._pyside_import_re = re.compile(r"from PySide6\.(.*) import ")
-        self._widget_import_re = re.compile(
-            r"^from ([a-zA-Z_]*) import ([a-zA-Z_]*)$", re.MULTILINE
-        )
-        self._widget_modules = {
-            c.name: c.module for c in (get_custom_classes("bec_widgets") + get_all_plugin_widgets())
-        }
-
-    def on_created(self, event: DirCreatedEvent | FileCreatedEvent) -> None:
-        self.recompile(event)
-
-    def on_modified(self, event: DirModifiedEvent | FileModifiedEvent) -> None:
-        self.recompile(event)
-
-    def on_moved(self, event: DirMovedEvent | FileMovedEvent) -> None:
-        self.recompile(event)
-
-    def recompile(self, event: FileSystemEvent) -> None:
-        if event.src_path == self.in_file or event.dest_path == self.in_file:
-            self._recompile()
-
-    def _recompile(self):
-        logger.success(".ui file modified, recompiling...")
-        code = subprocess.call(
-            ["pyside6-uic", "--absolute-imports", self.in_file, "-o", self.out_file]
-        )
-        logger.success(f"compilation exited with code {code}")
-        if code != 0:
-            return
-        self._add_comment_to_file()
-        logger.success("updating imports...")
-        self._update_imports()
-        logger.success("formatting...")
-        code = subprocess.call(
-            ["black", "--line-length=100", "--skip-magic-trailing-comma", self.out_file]
-        )
-        if code != 0:
-            logger.error(f"Error while running black on {self.out_file}, code: {code}")
-            return
-        code = subprocess.call(
-            [
-                "isort",
-                "--line-length=100",
-                "--profile=black",
-                "--multi-line=3",
-                "--trailing-comma",
-                self.out_file,
-            ]
-        )
-        if code != 0:
-            logger.error(f"Error while running isort on {self.out_file}, code: {code}")
-            return
-        logger.success("done!")
-
-    def _add_comment_to_file(self):
-        with open(self.out_file, "r+") as f:
-            initial = f.read()
-            f.seek(0)
-            f.write(f"# Generated from {self.in_file} by bec-plugin-manager - do not edit! \n")
-            f.write(
-                "# Use 'bec-plugin-manager edit-ui [widget_name]' to make changes, and this file will be updated accordingly. \n\n"
-            )
-            f.write(initial)
-
-    def _update_imports(self):
-        with open(self.out_file, "r+") as f:
-            initial = f.read()
-            f.seek(0)
-            qtpy_imports = re.sub(
-                self._pyside_import_re, lambda ob: f"from qtpy.{ob.group(1)} import ", initial
-            )
-            print(self._widget_modules)
-            print(re.findall(self._widget_import_re, qtpy_imports))
-            widget_imports = re.sub(
-                self._widget_import_re,
-                lambda ob: (
-                    f"from {module} import {ob.group(2)}"
-                    if (module := self._widget_modules.get(ob.group(2))) is not None
-                    else ob.group(1)
-                ),
-                qtpy_imports,
-            )
-            f.write(widget_imports)
-            f.truncate()
-
-
-def open_and_watch_ui_editor(widget_name: str):
-    logger.info(f"Opening the editor for {widget_name}, and watching")
-    repo = Path(plugin_repo_path())
-    widget_dir = repo / plugin_package_name() / "bec_widgets" / "widgets" / widget_name
-    ui_file = widget_dir / f"{widget_name}.ui"
-    ui_outfile = widget_dir / f"{widget_name}_ui.py"
-
-    logger.info(
-        f"Opening the editor for {widget_name}, and watching {ui_file} for changes. Whenever you save the file, it will be recompiled to {ui_outfile}"
-    )
-    recompile_handler = RecompileHandler(ui_file, ui_outfile)
-    observer = Observer()
-    observer.schedule(recompile_handler, str(ui_file.parent))
-    observer.start()
-    try:
-        open_designer([str(ui_file)])
-    finally:
-        observer.stop()
-        observer.join()
-    logger.info("Editing session ended, exiting...")

bec_widgets/utils/bec_signal_proxy.py

@@ -1,90 +0,0 @@
-"""This custom class is a thin wrapper around the SignalProxy class to allow signal calls to be blocked.
-Unblocking the proxy needs to be done through the slot unblock_proxy. The most likely use case for this class is
-when the callback function is potentially initiating a slower progress, i.e. requesting a data analysis routine to
-analyse data. Requesting a new fit may lead to request piling up and an overall slow done of performance. This proxy
-will allow you to decide by yourself when to unblock and execute the callback again."""
-
-from pyqtgraph import SignalProxy
-from qtpy.QtCore import QTimer, Signal
-
-from bec_widgets.utils.error_popups import SafeSlot
-
-
-class BECSignalProxy(SignalProxy):
-    """
-    Thin wrapper around the SignalProxy class to allow signal calls to be blocked,
-    but arguments still being stored.
-
-    Args:
-        *args: Arguments to pass to the SignalProxy class.
-        rateLimit (int): The rateLimit of the proxy.
-        timeout (float): The number of seconds after which the proxy automatically
-                         unblocks if still blocked. Default is 10.0 seconds.
-        **kwargs: Keyword arguments to pass to the SignalProxy class.
-
-    Example:
-        >>> proxy = BECSignalProxy(signal, rate_limit=25, slot=callback)
-    """
-
-    is_blocked = Signal(bool)
-
-    def __init__(self, *args, rateLimit=25, timeout=10.0, **kwargs):
-        super().__init__(*args, rateLimit=rateLimit, **kwargs)
-        self._blocking = False
-        self.old_args = None
-        self.new_args = None
-
-        # Store timeout value (in seconds)
-        self._timeout = timeout
-
-        # Create a single-shot timer for auto-unblocking
-        self._timer = QTimer()
-        self._timer.setSingleShot(True)
-        self._timer.timeout.connect(self._timeout_unblock)
-
-    @property
-    def blocked(self):
-        """Returns if the proxy is blocked"""
-        return self._blocking
-
-    @blocked.setter
-    def blocked(self, value: bool):
-        self._blocking = value
-        self.is_blocked.emit(value)
-
-    def signalReceived(self, *args):
-        """Receive signal, store the args and call signalReceived from the parent class if not blocked"""
-        self.new_args = args
-        if self.blocked is True:
-            return
-        self.blocked = True
-        self.old_args = args
-        super().signalReceived(*args)
-
-        self._timer.start(int(self._timeout * 1000))
-
-    @SafeSlot()
-    def unblock_proxy(self):
-        """Unblock the proxy, and call the signalReceived method in case there was an update of the args."""
-        if self.blocked:
-            self._timer.stop()
-            self.blocked = False
-            if self.new_args != self.old_args:
-                self.signalReceived(*self.new_args)
-
-    @SafeSlot()
-    def _timeout_unblock(self):
-        """
-        Internal method called by the QTimer upon timeout. Unblocks the proxy
-        automatically if it is still blocked.
-        """
-        if self.blocked:
-            self.unblock_proxy()
-
-    def cleanup(self):
-        """
-        Cleanup the proxy by stopping the timer and disconnecting the timeout signal.
-        """
-        self._timer.stop()
-        self._timer.timeout.disconnect(self._timeout_unblock)
-        self._timer.deleteLater()

bec_widgets/utils/bec_widget.py

@@ -1,160 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime
-from typing import TYPE_CHECKING
-
-import PySide6QtAds as QtAds
-import shiboken6
-from bec_lib.logger import bec_logger
-from qtpy.QtCore import QObject
-from qtpy.QtWidgets import QApplication, QFileDialog, QWidget
-
-from bec_widgets.cli.rpc.rpc_register import RPCRegister
-from bec_widgets.utils.bec_connector import BECConnector, ConnectionConfig
-from bec_widgets.utils.error_popups import SafeConnect, SafeSlot
-from bec_widgets.utils.rpc_decorator import rpc_timeout
-from bec_widgets.utils.widget_io import WidgetHierarchy
-
-if TYPE_CHECKING:  # pragma: no cover
-    from bec_widgets.widgets.containers.dock import BECDock
-
-logger = bec_logger.logger
-
-
-class BECWidget(BECConnector):
-    """Mixin class for all BEC widgets, to handle cleanup"""
-
-    # The icon name is the name of the icon in the icon theme, typically a name taken
-    # from fonts.google.com/icons. Override this in subclasses to set the icon name.
-    ICON_NAME = "widgets"
-    USER_ACCESS = ["remove", "attach", "detach"]
-
-    # pylint: disable=too-many-arguments
-    def __init__(
-        self,
-        client=None,
-        config: ConnectionConfig = None,
-        gui_id: str | None = None,
-        theme_update: bool = False,
-        parent_dock: BECDock | None = None,  # TODO should go away -> issue created #473
-        **kwargs,
-    ):
-        """
-        Base class for all BEC widgets. This class should be used as a mixin class for all BEC widgets, e.g.:
-
-
-        >>> class MyWidget(BECWidget, QWidget):
-        >>>     def __init__(self, parent=None, client=None, config=None, gui_id=None):
-        >>>         super().__init__(parent=parent, client=client, config=config, gui_id=gui_id)
-
-
-        Args:
-            client(BECClient, optional): The BEC client.
-            config(ConnectionConfig, optional): The connection configuration.
-            gui_id(str, optional): The GUI ID.
-            theme_update(bool, optional): Whether to subscribe to theme updates. Defaults to False. When set to True, the
-                widget's apply_theme method will be called when the theme changes.
-        """
-
-        super().__init__(
-            client=client, config=config, gui_id=gui_id, parent_dock=parent_dock, **kwargs
-        )
-        if not isinstance(self, QObject):
-            raise RuntimeError(f"{repr(self)} is not a subclass of QWidget")
-        if theme_update:
-            logger.debug(f"Subscribing to theme updates for {self.__class__.__name__}")
-            self._connect_to_theme_change()
-
-    def _connect_to_theme_change(self):
-        """Connect to the theme change signal."""
-        qapp = QApplication.instance()
-        if hasattr(qapp, "theme"):
-            SafeConnect(self, qapp.theme.theme_changed, self._update_theme)
-
-    @SafeSlot(str)
-    @SafeSlot()
-    def _update_theme(self, theme: str | None = None):
-        """Update the theme."""
-        if theme is None:
-            qapp = QApplication.instance()
-            if hasattr(qapp, "theme"):
-                theme = qapp.theme.theme
-            else:
-                theme = "dark"
-        self.apply_theme(theme)
-
-    @SafeSlot(str)
-    def apply_theme(self, theme: str):
-        """
-        Apply the theme to the widget.
-
-        Args:
-            theme(str, optional): The theme to be applied.
-        """
-
-    @SafeSlot()
-    @SafeSlot(str)
-    @rpc_timeout(None)
-    def screenshot(self, file_name: str | None = None):
-        """
-        Take a screenshot of the dock area and save it to a file.
-        """
-        if not isinstance(self, QWidget):
-            logger.error("Cannot take screenshot of non-QWidget instance")
-            return
-
-        screenshot = self.grab()
-        if file_name is None:
-            file_name, _ = QFileDialog.getSaveFileName(
-                self,
-                "Save Screenshot",
-                f"bec_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png",
-                "PNG Files (*.png);;JPEG Files (*.jpg *.jpeg);;All Files (*)",
-            )
-        if not file_name:
-            return
-        screenshot.save(file_name)
-        logger.info(f"Screenshot saved to {file_name}")
-
-    def attach(self):
-        dock = WidgetHierarchy.find_ancestor(self, QtAds.CDockWidget)
-        if dock is None:
-            return
-
-        if not dock.isFloating():
-            return
-        dock.dockManager().addDockWidget(QtAds.DockWidgetArea.RightDockWidgetArea, dock)
-
-    def detach(self):
-        """
-        Detach the widget from its parent dock widget (if widget is in the dock), making it a floating widget.
-        """
-        dock = WidgetHierarchy.find_ancestor(self, QtAds.CDockWidget)
-        if dock is None:
-            return
-        if dock.isFloating():
-            return
-        dock.setFloating()
-
-    def cleanup(self):
-        """Cleanup the widget."""
-        with RPCRegister.delayed_broadcast():
-            # All widgets need to call super().cleanup() in their cleanup method
-            logger.info(f"Registry cleanup for widget {self.__class__.__name__}")
-            self.rpc_register.remove_rpc(self)
-        children = self.findChildren(BECWidget)
-        for child in children:
-            if not shiboken6.isValid(child):
-                # If the child is not valid, it means it has already been deleted
-                continue
-            child.close()
-            child.deleteLater()
-
-    def closeEvent(self, event):
-        """Wrap the close even to ensure the rpc_register is cleaned up."""
-        try:
-            if not self._destroyed:
-                self.cleanup()
-                self._destroyed = True
-        finally:
-            super().closeEvent(event)  # pylint: disable=no-member

bec_widgets/utils/clickable_label.py

@@ -1,13 +0,0 @@
-from __future__ import annotations
-
-from qtpy.QtCore import Signal
-from qtpy.QtGui import QMouseEvent
-from qtpy.QtWidgets import QLabel
-
-
-class ClickableLabel(QLabel):
-    clicked = Signal()
-
-    def mouseReleaseEvent(self, ev: QMouseEvent) -> None:
-        self.clicked.emit()
-        return super().mouseReleaseEvent(ev)

bec_widgets/utils/collapsible_panel_manager.py

@@ -1,380 +0,0 @@
-from __future__ import annotations
-
-import sys
-from typing import Literal
-
-import pyqtgraph as pg
-from qtpy.QtCore import Property, QEasingCurve, QObject, QPropertyAnimation
-from qtpy.QtWidgets import (
-    QApplication,
-    QHBoxLayout,
-    QMainWindow,
-    QPushButton,
-    QSizePolicy,
-    QVBoxLayout,
-    QWidget,
-)
-from typeguard import typechecked
-
-from bec_widgets.widgets.containers.layout_manager.layout_manager import LayoutManagerWidget
-
-
-class DimensionAnimator(QObject):
-    """
-    Helper class to animate the size of a panel widget.
-    """
-
-    def __init__(self, panel_widget: QWidget, direction: str):
-        super().__init__()
-        self.panel_widget = panel_widget
-        self.direction = direction
-        self._size = 0
-
-    @Property(int)
-    def panel_width(self):
-        """
-        Returns the current width of the panel widget.
-        """
-        return self._size
-
-    @panel_width.setter
-    def panel_width(self, val: int):
-        """
-        Set the width of the panel widget.
-
-        Args:
-            val(int): The width to set.
-        """
-        self._size = val
-        self.panel_widget.setFixedWidth(val)
-
-    @Property(int)
-    def panel_height(self):
-        """
-        Returns the current height of the panel widget.
-        """
-        return self._size
-
-    @panel_height.setter
-    def panel_height(self, val: int):
-        """
-        Set the height of the panel widget.
-
-        Args:
-            val(int): The height to set.
-        """
-        self._size = val
-        self.panel_widget.setFixedHeight(val)
-
-
-class CollapsiblePanelManager(QObject):
-    """
-    Manager class to handle collapsible panels from a main widget using LayoutManagerWidget.
-    """
-
-    def __init__(self, layout_manager: LayoutManagerWidget, reference_widget: QWidget, parent=None):
-        super().__init__(parent)
-        self.layout_manager = layout_manager
-        self.reference_widget = reference_widget
-        self.animations = {}
-        self.panels = {}
-        self.direction_settings = {
-            "left": {"property": b"maximumWidth", "default_size": 200},
-            "right": {"property": b"maximumWidth", "default_size": 200},
-            "top": {"property": b"maximumHeight", "default_size": 150},
-            "bottom": {"property": b"maximumHeight", "default_size": 150},
-        }
-
-    def add_panel(
-        self,
-        direction: Literal["left", "right", "top", "bottom"],
-        panel_widget: QWidget,
-        target_size: int | None = None,
-        duration: int = 300,
-    ):
-        """
-        Add a panel widget to the layout manager.
-
-        Args:
-            direction(Literal["left", "right", "top", "bottom"]): Direction of the panel.
-            panel_widget(QWidget): The panel widget to add.
-            target_size(int, optional): The target size of the panel. Defaults to None.
-            duration(int): The duration of the animation in milliseconds. Defaults to 300.
-        """
-        if direction not in self.direction_settings:
-            raise ValueError("Direction must be one of 'left', 'right', 'top', 'bottom'.")
-
-        if target_size is None:
-            target_size = self.direction_settings[direction]["default_size"]
-
-        self.layout_manager.add_widget_relative(
-            widget=panel_widget, reference_widget=self.reference_widget, position=direction
-        )
-        panel_widget.setVisible(False)
-
-        # Set initial constraints as flexible
-        if direction in ["left", "right"]:
-            panel_widget.setMaximumWidth(0)
-            panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-        else:
-            panel_widget.setMaximumHeight(0)
-            panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-
-        self.panels[direction] = {
-            "widget": panel_widget,
-            "direction": direction,
-            "target_size": target_size,
-            "duration": duration,
-            "animator": None,
-        }
-
-    def toggle_panel(
-        self,
-        direction: Literal["left", "right", "top", "bottom"],
-        target_size: int | None = None,
-        duration: int | None = None,
-        easing_curve: QEasingCurve = QEasingCurve.InOutQuad,
-        ensure_max: bool = False,
-        scale: float | None = None,
-        animation: bool = True,
-    ):
-        """
-        Toggle the specified panel.
-
-        Parameters:
-            direction (Literal["left", "right", "top", "bottom"]): Direction of the panel to toggle.
-            target_size (int, optional): Override target size for this toggle.
-            duration (int, optional): Override the animation duration.
-            easing_curve (QEasingCurve): Animation easing curve.
-            ensure_max (bool): If True, animate as a fixed-size panel.
-            scale (float, optional): If provided, calculate target_size from main widget size.
-            animation (bool): If False, no animation is performed; panel instantly toggles.
-        """
-        if direction not in self.panels:
-            raise ValueError(f"No panel found in direction '{direction}'.")
-
-        panel_info = self.panels[direction]
-        panel_widget = panel_info["widget"]
-        dir_settings = self.direction_settings[direction]
-
-        # Determine final target size
-        if scale is not None:
-            main_rect = self.reference_widget.geometry()
-            if direction in ["left", "right"]:
-                computed_target = int(main_rect.width() * scale)
-            else:
-                computed_target = int(main_rect.height() * scale)
-            final_target_size = computed_target
-        else:
-            if target_size is None:
-                final_target_size = panel_info["target_size"]
-            else:
-                final_target_size = target_size
-
-        if duration is None:
-            duration = panel_info["duration"]
-
-        expanding_property = dir_settings["property"]
-        currently_visible = panel_widget.isVisible()
-
-        if ensure_max:
-            if panel_info["animator"] is None:
-                panel_info["animator"] = DimensionAnimator(panel_widget, direction)
-            animator = panel_info["animator"]
-
-            if direction in ["left", "right"]:
-                prop_name = b"panel_width"
-            else:
-                prop_name = b"panel_height"
-        else:
-            animator = None
-            prop_name = expanding_property
-
-        if currently_visible:
-            # Hide the panel
-            if ensure_max:
-                start_value = final_target_size
-                end_value = 0
-                finish_callback = lambda w=panel_widget, d=direction: self._after_hide_reset(w, d)
-            else:
-                start_value = (
-                    panel_widget.width()
-                    if direction in ["left", "right"]
-                    else panel_widget.height()
-                )
-                end_value = 0
-                finish_callback = lambda w=panel_widget: w.setVisible(False)
-        else:
-            # Show the panel
-            start_value = 0
-            end_value = final_target_size
-            finish_callback = None
-            if ensure_max:
-                # Fix panel exactly
-                if direction in ["left", "right"]:
-                    panel_widget.setMinimumWidth(0)
-                    panel_widget.setMaximumWidth(final_target_size)
-                    panel_widget.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
-                else:
-                    panel_widget.setMinimumHeight(0)
-                    panel_widget.setMaximumHeight(final_target_size)
-                    panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
-            else:
-                # Flexible mode
-                if direction in ["left", "right"]:
-                    panel_widget.setMinimumWidth(0)
-                    panel_widget.setMaximumWidth(final_target_size)
-                    panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-                else:
-                    panel_widget.setMinimumHeight(0)
-                    panel_widget.setMaximumHeight(final_target_size)
-                    panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-
-            panel_widget.setVisible(True)
-
-        if not animation:
-            # No animation: instantly set final state
-            if end_value == 0:
-                # Hiding
-                if ensure_max:
-                    # Reset after hide
-                    self._after_hide_reset(panel_widget, direction)
-                else:
-                    panel_widget.setVisible(False)
-            else:
-                # Showing
-                if ensure_max:
-                    # Already set fixed size
-                    if direction in ["left", "right"]:
-                        panel_widget.setFixedWidth(end_value)
-                    else:
-                        panel_widget.setFixedHeight(end_value)
-                else:
-                    # Just set maximum dimension
-                    if direction in ["left", "right"]:
-                        panel_widget.setMaximumWidth(end_value)
-                    else:
-                        panel_widget.setMaximumHeight(end_value)
-            return
-
-        # With animation
-        animation = QPropertyAnimation(animator if ensure_max else panel_widget, prop_name)
-        animation.setDuration(duration)
-        animation.setStartValue(start_value)
-        animation.setEndValue(end_value)
-        animation.setEasingCurve(easing_curve)
-
-        if end_value == 0 and finish_callback:
-            animation.finished.connect(finish_callback)
-        elif end_value == 0 and not finish_callback:
-            animation.finished.connect(lambda w=panel_widget: w.setVisible(False))
-
-        animation.start()
-        self.animations[panel_widget] = animation
-
-    @typechecked
-    def _after_hide_reset(
-        self, panel_widget: QWidget, direction: Literal["left", "right", "top", "bottom"]
-    ):
-        """
-        Reset the panel widget after hiding it in ensure_max mode.
-
-        Args:
-            panel_widget(QWidget): The panel widget to reset.
-            direction(Literal["left", "right", "top", "bottom"]): The direction of the panel.
-        """
-        # Called after hiding a panel in ensure_max mode
-        panel_widget.setVisible(False)
-        if direction in ["left", "right"]:
-            panel_widget.setMinimumWidth(0)
-            panel_widget.setMaximumWidth(0)
-            panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-        else:
-            panel_widget.setMinimumHeight(0)
-            panel_widget.setMaximumHeight(16777215)
-            panel_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-
-
-####################################################################################################
-# The following code is for the GUI control panel to interact with the CollapsiblePanelManager.
-# It is not covered by any tests as it serves only as an example for the CollapsiblePanelManager class.
-####################################################################################################
-
-
-class MainWindow(QMainWindow):  # pragma: no cover
-    def __init__(self):
-        super().__init__()
-        self.setWindowTitle("Panels with ensure_max, scale, and animation toggle")
-        self.resize(800, 600)
-
-        central_widget = QWidget()
-        self.setCentralWidget(central_widget)
-        main_layout = QVBoxLayout(central_widget)
-        main_layout.setContentsMargins(10, 10, 10, 10)
-        main_layout.setSpacing(10)
-
-        # Buttons
-        buttons_layout = QHBoxLayout()
-        self.btn_left = QPushButton("Toggle Left (ensure_max=True)")
-        self.btn_top = QPushButton("Toggle Top (scale=0.5, no animation)")
-        self.btn_right = QPushButton("Toggle Right (ensure_max=True, scale=0.3)")
-        self.btn_bottom = QPushButton("Toggle Bottom (no animation)")
-
-        buttons_layout.addWidget(self.btn_left)
-        buttons_layout.addWidget(self.btn_top)
-        buttons_layout.addWidget(self.btn_right)
-        buttons_layout.addWidget(self.btn_bottom)
-
-        main_layout.addLayout(buttons_layout)
-
-        self.layout_manager = LayoutManagerWidget()
-        main_layout.addWidget(self.layout_manager)
-
-        # Main widget
-        self.main_plot = pg.PlotWidget()
-        self.main_plot.plot([1, 2, 3, 4], [4, 3, 2, 1])
-        self.layout_manager.add_widget(self.main_plot, 0, 0)
-
-        self.panel_manager = CollapsiblePanelManager(self.layout_manager, self.main_plot)
-
-        # Panels
-        self.left_panel = pg.PlotWidget()
-        self.left_panel.plot([1, 2, 3], [3, 2, 1])
-        self.panel_manager.add_panel("left", self.left_panel, target_size=200)
-
-        self.right_panel = pg.PlotWidget()
-        self.right_panel.plot([10, 20, 30], [1, 10, 1])
-        self.panel_manager.add_panel("right", self.right_panel, target_size=200)
-
-        self.top_panel = pg.PlotWidget()
-        self.top_panel.plot([1, 2, 3], [1, 2, 3])
-        self.panel_manager.add_panel("top", self.top_panel, target_size=150)
-
-        self.bottom_panel = pg.PlotWidget()
-        self.bottom_panel.plot([2, 4, 6], [10, 5, 10])
-        self.panel_manager.add_panel("bottom", self.bottom_panel, target_size=150)
-
-        # Connect buttons
-        # Left with ensure_max
-        self.btn_left.clicked.connect(
-            lambda: self.panel_manager.toggle_panel("left", ensure_max=True)
-        )
-        # Top with scale=0.5 and no animation
-        self.btn_top.clicked.connect(
-            lambda: self.panel_manager.toggle_panel("top", scale=0.5, animation=False)
-        )
-        # Right with ensure_max, scale=0.3
-        self.btn_right.clicked.connect(
-            lambda: self.panel_manager.toggle_panel("right", ensure_max=True, scale=0.3)
-        )
-        # Bottom no animation
-        self.btn_bottom.clicked.connect(
-            lambda: self.panel_manager.toggle_panel("bottom", target_size=100, animation=False)
-        )
-
-
-if __name__ == "__main__":  # pragma: no cover
-    app = QApplication(sys.argv)
-    w = MainWindow()
-    w.show()
-    sys.exit(app.exec())

bec_widgets/utils/colors.py

@@ -1,55 +1,10 @@
-from __future__ import annotations
-
 import re
 from typing import Literal
 
 import numpy as np
 import pyqtgraph as pg
-from bec_qthemes import apply_theme as apply_theme_global
-from bec_qthemes._theme import AccentColors
 from pydantic_core import PydanticCustomError
-from qtpy.QtCore import QEvent, QEventLoop
 from qtpy.QtGui import QColor
-from qtpy.QtWidgets import QApplication
-
-
-def get_theme_name():
-    if QApplication.instance() is None or not hasattr(QApplication.instance(), "theme"):
-        return "dark"
-    else:
-        return QApplication.instance().theme.theme
-
-
-def get_theme_palette():
-    # FIXME this is legacy code, should be removed in the future
-    app = QApplication.instance()
-    palette = app.palette()
-    return palette
-
-
-def get_accent_colors() -> AccentColors:
-    """
-    Get the accent colors for the current theme. These colors are extensions of the color palette
-    and are used to highlight specific elements in the UI.
-    """
-    if QApplication.instance() is None or not hasattr(QApplication.instance(), "theme"):
-        accent_colors = AccentColors()
-        return accent_colors
-    return QApplication.instance().theme.accent_colors
-
-
-def process_all_deferred_deletes(qapp):
-    qapp.sendPostedEvents(None, QEvent.DeferredDelete)
-    qapp.processEvents(QEventLoop.AllEvents)
-
-
-def apply_theme(theme: Literal["dark", "light"]):
-    """
-    Apply the theme via the global theming API. This updates QSS, QPalette, and pyqtgraph globally.
-    """
-    process_all_deferred_deletes(QApplication.instance())
-    apply_theme_global(theme)
-    process_all_deferred_deletes(QApplication.instance())
 
 
 class Colors:
@@ -73,98 +28,9 @@ class Colors:
             angles.append(angle)
         return angles
 
-    @staticmethod
-    def set_theme_offset(theme: Literal["light", "dark"] | None = None, offset=0.2) -> tuple:
-        """
-        Set the theme offset to avoid colors too close to white or black with light or dark theme respectively for pyqtgraph plot background.
-
-        Args:
-            theme(str): The theme to be applied.
-            offset(float): Offset to avoid colors too close to white or black with light or dark theme respectively for pyqtgraph plot background.
-
-        Returns:
-            tuple: Tuple of min_pos and max_pos.
-
-        Raises:
-            ValueError: If theme_offset is not between 0 and 1.
-        """
-
-        if offset < 0 or offset > 1:
-            raise ValueError("theme_offset must be between 0 and 1")
-
-        if theme is None:
-            app = QApplication.instance()
-            if hasattr(app, "theme"):
-                theme = app.theme.theme
-
-        if theme == "light":
-            min_pos = 0.0
-            max_pos = 1 - offset
-        else:
-            min_pos = 0.0 + offset
-            max_pos = 1.0
-
-        return min_pos, max_pos
-
-    @staticmethod
-    def evenly_spaced_colors(
-        colormap: str,
-        num: int,
-        format: Literal["QColor", "HEX", "RGB"] = "QColor",
-        theme_offset=0.2,
-        theme: Literal["light", "dark"] | None = None,
-    ) -> list:
-        """
-        Extract `num` colors from the specified colormap, evenly spaced along its range,
-        and return them in the specified format.
-
-        Args:
-            colormap (str): Name of the colormap.
-            num (int): Number of requested colors.
-            format (Literal["QColor","HEX","RGB"]): The format of the returned colors ('RGB', 'HEX', 'QColor').
-            theme_offset (float): Has to be between 0-1. Offset to avoid colors too close to white or black with light or dark theme respectively for pyqtgraph plot background.
-            theme (Literal['light', 'dark'] | None): The theme to be applied. Overrides the QApplication theme if specified.
-
-        Returns:
-            list: List of colors in the specified format.
-
-        Raises:
-            ValueError: If theme_offset is not between 0 and 1.
-        """
-        if theme_offset < 0 or theme_offset > 1:
-            raise ValueError("theme_offset must be between 0 and 1")
-
-        cmap = pg.colormap.get(colormap)
-        min_pos, max_pos = Colors.set_theme_offset(theme, theme_offset)
-
-        # Generate positions that are evenly spaced within the acceptable range
-        if num == 1:
-            positions = np.array([(min_pos + max_pos) / 2])
-        else:
-            positions = np.linspace(min_pos, max_pos, num)
-
-        # Sample colors from the colormap at the calculated positions
-        colors = cmap.map(positions, mode="float")
-        color_list = []
-
-        for color in colors:
-            if format.upper() == "HEX":
-                color_list.append(QColor.fromRgbF(*color).name())
-            elif format.upper() == "RGB":
-                color_list.append(tuple((np.array(color) * 255).astype(int)))
-            elif format.upper() == "QCOLOR":
-                color_list.append(QColor.fromRgbF(*color))
-            else:
-                raise ValueError("Unsupported format. Please choose 'RGB', 'HEX', or 'QColor'.")
-        return color_list
-
     @staticmethod
     def golden_angle_color(
-        colormap: str,
-        num: int,
-        format: Literal["QColor", "HEX", "RGB"] = "QColor",
-        theme_offset=0.2,
-        theme: Literal["dark", "light"] | None = None,
+        colormap: str, num: int, format: Literal["QColor", "HEX", "RGB"] = "QColor"
     ) -> list:
         """
         Extract num colors from the specified colormap following golden angle distribution and return them in the specified format.
@@ -173,39 +39,33 @@ class Colors:
             colormap (str): Name of the colormap.
             num (int): Number of requested colors.
             format (Literal["QColor","HEX","RGB"]): The format of the returned colors ('RGB', 'HEX', 'QColor').
-            theme_offset (float): Has to be between 0-1. Offset to avoid colors too close to white or black with light or dark theme respectively for pyqtgraph plot background.
 
         Returns:
             list: List of colors in the specified format.
 
         Raises:
-            ValueError: If theme_offset is not between 0 and 1.
+            ValueError: If the number of requested colors is greater than the number of colors in the colormap.
         """
-
         cmap = pg.colormap.get(colormap)
-        phi = (1 + np.sqrt(5)) / 2  # Golden ratio
-        golden_angle_conjugate = 1 - (1 / phi)  # Approximately 0.38196601125
-
-        min_pos, max_pos = Colors.set_theme_offset(theme, theme_offset)
-
-        # Generate positions within the acceptable range
-        positions = np.mod(np.arange(num) * golden_angle_conjugate, 1)
-        positions = min_pos + positions * (max_pos - min_pos)
-
-        # Sample colors from the colormap at the calculated positions
-        colors = cmap.map(positions, mode="float")
-        color_list = []
-
-        for color in colors:
+        cmap_colors = cmap.getColors(mode="float")
+        if num > len(cmap_colors):
+            raise ValueError(
+                f"Number of colors requested ({num}) is greater than the number of colors in the colormap ({len(cmap_colors)})"
+            )
+        angles = Colors.golden_ratio(len(cmap_colors))
+        color_selection = np.round(np.interp(angles, (-np.pi, np.pi), (0, len(cmap_colors))))
+        colors = []
+        for ii in color_selection[:num]:
+            color = cmap_colors[int(ii)]
             if format.upper() == "HEX":
-                color_list.append(QColor.fromRgbF(*color).name())
+                colors.append(QColor.fromRgbF(*color).name())
             elif format.upper() == "RGB":
-                color_list.append(tuple((np.array(color) * 255).astype(int)))
+                colors.append(tuple((np.array(color) * 255).astype(int)))
             elif format.upper() == "QCOLOR":
-                color_list.append(QColor.fromRgbF(*color))
+                colors.append(QColor.fromRgbF(*color))
             else:
                 raise ValueError("Unsupported format. Please choose 'RGB', 'HEX', or 'QColor'.")
-        return color_list
+        return colors
 
     @staticmethod
     def hex_to_rgba(hex_color: str, alpha=255) -> tuple:
@@ -434,7 +294,7 @@ class Colors:
             return color
 
     @staticmethod
-    def validate_color_map(color_map: str, return_error: bool = True) -> str | bool:
+    def validate_color_map(color_map: str) -> str:
         """
         Validate the colormap input if it is supported by pyqtgraph. Can be used in any pydantic model as a field validator. If validation fails it prints all available colormaps from pyqtgraph instance.
 
@@ -442,24 +302,13 @@ class Colors:
             color_map(str): The colormap to be validated.
 
         Returns:
-            str: The validated colormap, if colormap is valid.
-            bool: False, if colormap is invalid.
-
-        Raises:
-            PydanticCustomError: If colormap is invalid.
+            str: The validated colormap.
         """
-        available_pg_maps = pg.colormap.listMaps()
-        available_mpl_maps = pg.colormap.listMaps("matplotlib")
-        available_mpl_colorcet = pg.colormap.listMaps("colorcet")
-
-        available_colormaps = available_pg_maps + available_mpl_maps + available_mpl_colorcet
+        available_colormaps = pg.colormap.listMaps()
         if color_map not in available_colormaps:
-            if return_error:
-                raise PydanticCustomError(
-                    "unsupported colormap",
-                    f"Colormap '{color_map}' not found in the current installation of pyqtgraph. Choose on the following: {available_colormaps}.",
-                    {"wrong_value": color_map},
-                )
-            else:
-                return False
+            raise PydanticCustomError(
+                "unsupported colormap",
+                f"Colormap '{color_map}' not found in the current installation of pyqtgraph. Choose on the following: {available_colormaps}.",
+                {"wrong_value": color_map},
+            )
         return color_map

bec_widgets/utils/compact_popup.py

@@ -1,261 +0,0 @@
-import time
-from types import SimpleNamespace
-
-from bec_qthemes import material_icon
-from qtpy.QtCore import Property, Qt, Signal
-from qtpy.QtGui import QColor
-from qtpy.QtWidgets import (
-    QDialog,
-    QHBoxLayout,
-    QLabel,
-    QPushButton,
-    QSizePolicy,
-    QSpacerItem,
-    QToolButton,
-    QVBoxLayout,
-    QWidget,
-)
-
-from bec_widgets.utils.colors import get_accent_colors
-
-
-class LedLabel(QLabel):
-    success_led = "color: white;border-radius: 10;background-color: qlineargradient(spread:pad, x1:0.145, y1:0.16, x2:1, y2:1, stop:0 %s, stop:1 %s);"
-    emergency_led = "color: white;border-radius: 10;background-color: qlineargradient(spread:pad, x1:0.145, y1:0.16, x2:0.92, y2:0.988636, stop:0 %s, stop:1 %s);"
-    warning_led = "color: white;border-radius: 10;background-color: qlineargradient(spread:pad, x1:0.232, y1:0.272, x2:0.98, y2:0.959773, stop:0 %s, stop:1 %s);"
-    default_led = "color: white;border-radius: 10;background-color: qlineargradient(spread:pad, x1:0.04, y1:0.0565909, x2:0.799, y2:0.795, stop:0 %s, stop:1 %s);"
-
-    def __init__(self, parent=None):
-        super().__init__(parent)
-
-        self.palette = get_accent_colors()
-        if self.palette is None:
-            # no theme!
-            self.palette = SimpleNamespace(
-                default=QColor("blue"),
-                success=QColor("green"),
-                warning=QColor("orange"),
-                emergency=QColor("red"),
-            )
-        self.setState("default")
-        self.setFixedSize(20, 20)
-
-    def setState(self, state: str):
-        match state:
-            case "success":
-                r, g, b, a = self.palette.success.getRgb()
-                self.setStyleSheet(
-                    LedLabel.success_led
-                    % (
-                        f"rgba({r},{g},{b},{a})",
-                        f"rgba({int(r*0.8)},{int(g*0.8)},{int(b*0.8)},{a})",
-                    )
-                )
-            case "default":
-                r, g, b, a = self.palette.default.getRgb()
-                self.setStyleSheet(
-                    LedLabel.default_led
-                    % (
-                        f"rgba({r},{g},{b},{a})",
-                        f"rgba({int(r*0.8)},{int(g*0.8)},{int(b*0.8)},{a})",
-                    )
-                )
-            case "warning":
-                r, g, b, a = self.palette.warning.getRgb()
-                self.setStyleSheet(
-                    LedLabel.warning_led
-                    % (
-                        f"rgba({r},{g},{b},{a})",
-                        f"rgba({int(r*0.8)},{int(g*0.8)},{int(b*0.8)},{a})",
-                    )
-                )
-            case "emergency":
-                r, g, b, a = self.palette.emergency.getRgb()
-                self.setStyleSheet(
-                    LedLabel.emergency_led
-                    % (
-                        f"rgba({r},{g},{b},{a})",
-                        f"rgba({int(r*0.8)},{int(g*0.8)},{int(b*0.8)},{a})",
-                    )
-                )
-            case unknown_state:
-                raise ValueError(
-                    f"Unknown state {repr(unknown_state)}, must be one of default, success, warning or emergency"
-                )
-
-
-class PopupDialog(QDialog):
-    def __init__(self, content_widget):
-        self.parent = content_widget.parent()
-        self.content_widget = content_widget
-
-        super().__init__(self.parent)
-
-        self.setAttribute(Qt.WA_DeleteOnClose)
-
-        self.content_widget.setParent(self)
-        QVBoxLayout(self)
-        self.layout().addWidget(self.content_widget)
-        self.content_widget.setVisible(True)
-
-    def closeEvent(self, event):
-        self.content_widget.setVisible(False)
-        self.content_widget.setParent(self.parent)
-        self.done(True)
-
-
-class CompactPopupWidget(QWidget):
-    """Container widget, that can display its content or have a compact form,
-    in this case clicking on a small button pops the contained widget up.
-
-    In the compact form, a LED-like indicator shows a status indicator.
-    """
-
-    expand = Signal(bool)
-
-    def __init__(self, parent=None, layout=QVBoxLayout):
-        super().__init__(parent)
-
-        self._popup_window = None
-        self._expand_popup = True
-
-        QVBoxLayout(self)
-        self.compact_view_widget = QWidget(self)
-        self.compact_view_widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
-        QHBoxLayout(self.compact_view_widget)
-        self.compact_view_widget.layout().setSpacing(5)
-        self.compact_view_widget.layout().setContentsMargins(0, 0, 0, 0)
-        self.compact_view_widget.layout().addSpacerItem(
-            QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Fixed)
-        )
-        self.compact_label = QLabel(self.compact_view_widget)
-        self.compact_status = LedLabel(self.compact_view_widget)
-        self.compact_show_popup = QToolButton(self.compact_view_widget)
-        self.compact_show_popup.setIcon(
-            material_icon(icon_name="expand_content", size=(10, 10), convert_to_pixmap=False)
-        )
-        self.compact_view_widget.layout().addWidget(self.compact_label)
-        self.compact_view_widget.layout().addWidget(self.compact_status)
-        self.compact_view_widget.layout().addWidget(self.compact_show_popup)
-        self.compact_view_widget.setVisible(False)
-        self.layout().addWidget(self.compact_view_widget)
-        self.container = QWidget(self)
-        self.layout().addWidget(self.container)
-        self.container.setVisible(True)
-        layout(self.container)
-        self.layout = self.container.layout()
-
-        self.compact_show_popup.clicked.connect(self.show_popup)
-
-    def set_global_state(self, state: str):
-        """Set the LED-indicator state
-
-        The LED indicator represents the 'global' state. State can be one of the
-        following: "default", "success", "warning", "emergency"
-        """
-        self.compact_status.setState(state)
-
-    def show_popup(self):
-        """Display the contained widgets in a popup dialog"""
-        if self._expand_popup:
-            # show popup
-            self._popup_window = PopupDialog(self.container)
-            self._popup_window.show()
-            self._popup_window.finished.connect(lambda: self.expand.emit(False))
-            self.expand.emit(True)
-        else:
-            if self.compact_view:
-                # expand in place
-                self.compact_view = False
-                self.compact_view_widget.setVisible(True)
-                self.compact_label.setVisible(False)
-                self.compact_status.setVisible(False)
-                self.compact_show_popup.setIcon(
-                    material_icon(
-                        icon_name="collapse_content", size=(10, 10), convert_to_pixmap=False
-                    )
-                )
-                self.expand.emit(True)
-            else:
-                # back to compact form
-                self.compact_label.setVisible(True)
-                self.compact_status.setVisible(True)
-                self.compact_show_popup.setIcon(
-                    material_icon(
-                        icon_name="expand_content", size=(10, 10), convert_to_pixmap=False
-                    )
-                )
-                self.compact_view = True
-                self.expand.emit(False)
-
-    def setSizePolicy(self, size_policy1, size_policy2=None):
-        # setting size policy on the compact popup widget will set
-        # the policy for the container, and for itself
-        if size_policy2 is None:
-            # assuming first form: setSizePolicy(QSizePolicy)
-            self.container.setSizePolicy(size_policy1)
-            QWidget.setSizePolicy(self, size_policy1)
-        else:
-            self.container.setSizePolicy(size_policy1, size_policy2)
-            QWidget.setSizePolicy(self, size_policy1, size_policy2)
-
-    def addWidget(self, widget):
-        """Add a widget to the popup container
-
-        The popup container corresponds to the "full view" (not compact)
-        The widget is reparented to the container, and added to the container layout
-        """
-        widget.setParent(self.container)
-        self.container.layout().addWidget(widget)
-
-    @Property(bool)
-    def compact_view(self):
-        return self.compact_label.isVisible()
-
-    @compact_view.setter
-    def compact_view(self, set_compact: bool):
-        """Sets the compact form
-
-        If set_compact is True, the compact view is displayed ; otherwise,
-        the full view is displayed. This is handled by toggling visibility of
-        the container widget or the compact view widget.
-        """
-        if set_compact:
-            self.compact_view_widget.setVisible(True)
-            self.container.setVisible(False)
-            QWidget.setSizePolicy(self, QSizePolicy.Fixed, QSizePolicy.Fixed)
-        else:
-            self.compact_view_widget.setVisible(False)
-            self.container.setVisible(True)
-            QWidget.setSizePolicy(self, self.container.sizePolicy())
-        if self.parentWidget():
-            self.parentWidget().adjustSize()
-        else:
-            self.adjustSize()
-
-    @Property(str)
-    def label(self):
-        return self.compact_label.text()
-
-    @label.setter
-    def label(self, compact_label_text: str):
-        """Set the label text associated to the compact view"""
-        self.compact_label.setText(compact_label_text)
-
-    @Property(str)
-    def tooltip(self):
-        return self.compact_label.toolTip()
-
-    @tooltip.setter
-    def tooltip(self, tooltip: str):
-        """Set the tooltip text associated to the compact view"""
-        self.compact_label.setToolTip(tooltip)
-        self.compact_status.setToolTip(tooltip)
-
-    @Property(bool)
-    def expand_popup(self):
-        return self._expand_popup
-
-    @expand_popup.setter
-    def expand_popup(self, popup: bool):
-        self._expand_popup = popup

bec_widgets/utils/container_utils.py

@@ -1,54 +1,28 @@
-from __future__ import annotations
-
-from typing import Any, Type
+import itertools
+from typing import Type
 
 from qtpy.QtWidgets import QWidget
 
-from bec_widgets.cli.client_utils import BECGuiClient
-
 
 class WidgetContainerUtils:
 
-    # We need one handler that checks if a WIDGET of a given name is already created for that DOCKAREA
-    # 1. If the name exists, then it depends whether the name was auto-generated -> add _1 to the name
-    #    or alternatively raise an error that it can't be added again ( just raise an error)
-    # 2. Dock names in between docks should also be unique
-
     @staticmethod
-    def has_name_valid_chars(name: str) -> bool:
-        """Check if the name is valid.
+    def generate_unique_widget_id(container: dict, prefix: str = "widget") -> str:
+        """
+        Generate a unique widget ID.
 
         Args:
-            name(str): The name to be checked.
+            container(dict): The container of widgets.
+            prefix(str): The prefix of the widget ID.
 
         Returns:
-            bool: True if the name is valid, False otherwise.
+            widget_id(str): The unique widget ID.
         """
-        if not name or len(name) > 256:
-            return False  # Don't accept empty names or names longer than 256 characters
-        check_value = name.replace("_", "").replace("-", "")
-        if not check_value.isalnum() or not check_value.isascii():
-            return False
-        return True
-
-    @staticmethod
-    def generate_unique_name(name: str, list_of_names: list[str] | None = None) -> str:
-        """Generate a unique ID.
-
-        Args:
-            name(str): The name of the widget.
-        Returns:
-            tuple (str): The unique name
-        """
-        if list_of_names is None:
-            list_of_names = []
-        ii = 0
-        while ii < 1000:  # 1000 is arbritrary!
-            name_candidate = f"{name}_{ii}"
-            if name_candidate not in list_of_names:
-                return name_candidate
-            ii += 1
-        raise ValueError("Could not generate a unique name after within 1000 attempts.")
+        existing_ids = set(container.keys())
+        for i in itertools.count(1):
+            widget_id = f"{prefix}_{i}"
+            if widget_id not in existing_ids:
+                return widget_id
 
     @staticmethod
     def find_first_widget_by_class(
@@ -72,36 +46,3 @@ class WidgetContainerUtils:
             return None
         else:
             raise ValueError(f"No widget of class {widget_class} found.")
-
-    @staticmethod
-    def name_is_protected(name: str, container: Any = None) -> bool:
-        """
-        Check if the name is not protected.
-
-        Args:
-            name(str): The name to be checked.
-
-        Returns:
-            bool: True if the name is not protected, False otherwise.
-        """
-        if container is None:
-            container = BECGuiClient
-        gui_client_methods = set(filter(lambda x: not x.startswith("_"), dir(container)))
-        return name in gui_client_methods
-
-    @staticmethod
-    def raise_for_invalid_name(name: str, container: Any = None) -> None:
-        """
-        Check if the name is valid. If not, raise a ValueError.
-
-        Args:
-            name(str): The name to be checked.
-        Raises:
-            ValueError: If the name is not valid.
-        """
-        if not WidgetContainerUtils.has_name_valid_chars(name):
-            raise ValueError(
-                f"Name '{name}' contains invalid characters. Only alphanumeric characters, underscores, and dashes are allowed."
-            )
-        if WidgetContainerUtils.name_is_protected(name, container):
-            raise ValueError(f"Name '{name}' is protected. Please choose another name.")

bec_widgets/utils/crosshair.py

@@ -1,342 +1,110 @@
-from __future__ import annotations
-
-from collections import defaultdict
-from typing import Any
-
 import numpy as np
 import pyqtgraph as pg
-from qtpy.QtCore import QObject, QPointF, Qt, Signal
-from qtpy.QtGui import QCursor, QTransform
-from qtpy.QtWidgets import QApplication
 
-from bec_widgets.utils.error_popups import SafeSlot
-from bec_widgets.widgets.plots.image.image_item import ImageItem
-
-
-class CrosshairScatterItem(pg.ScatterPlotItem):
-    def setDownsampling(self, ds=None, auto=None, method=None):
-        pass
-
-    def setClipToView(self, state):
-        pass
-
-    def setAlpha(self, *args, **kwargs):
-        pass
+# from qtpy.QtCore import QObject, pyqtSignal
+from qtpy.QtCore import QObject
+from qtpy.QtCore import Signal as pyqtSignal
 
 
 class Crosshair(QObject):
-    # QT Position of mouse cursor
-    positionChanged = Signal(tuple)
-    positionClicked = Signal(tuple)
-    # Plain crosshair position signals mapped to real coordinates
-    crosshairChanged = Signal(tuple)
-    crosshairClicked = Signal(tuple)
     # Signal for 1D plot
-    coordinatesChanged1D = Signal(tuple)
-    coordinatesClicked1D = Signal(tuple)
+    coordinatesChanged1D = pyqtSignal(tuple)
+    coordinatesClicked1D = pyqtSignal(tuple)
     # Signal for 2D plot
-    coordinatesChanged2D = Signal(tuple)
-    coordinatesClicked2D = Signal(tuple)
+    coordinatesChanged2D = pyqtSignal(tuple)
+    coordinatesClicked2D = pyqtSignal(tuple)
 
-    def __init__(
-        self,
-        plot_item: pg.PlotItem,
-        precision: int | None = None,
-        *,
-        min_precision: int = 2,
-        parent=None,
-    ):
+    def __init__(self, plot_item: pg.PlotItem, precision: int = 3, parent=None):
         """
         Crosshair for 1D and 2D plots.
 
         Args:
             plot_item (pyqtgraph.PlotItem): The plot item to which the crosshair will be attached.
-            precision (int | None, optional): Fixed number of decimal places to display. If *None*, precision is chosen dynamically from the current view range.
-            min_precision (int, optional): The lower bound (in decimal places) used when dynamic precision is enabled. Defaults to 2.
+            precision (int, optional): Number of decimal places to round the coordinates to. Defaults to None.
             parent (QObject, optional): Parent object for the QObject. Defaults to None.
         """
         super().__init__(parent)
         self.is_log_y = None
         self.is_log_x = None
-        self.is_derivative = None
         self.plot_item = plot_item
-        self._precision = precision
-        self._min_precision = max(0, int(min_precision))  # ensure non‑negative
-
+        self.precision = precision
         self.v_line = pg.InfiniteLine(angle=90, movable=False)
-        self.v_line.skip_auto_range = True
         self.h_line = pg.InfiniteLine(angle=0, movable=False)
-        self.h_line.skip_auto_range = True
-        # Add custom attribute to identify crosshair lines
-        self.v_line.is_crosshair = True
-        self.h_line.is_crosshair = True
         self.plot_item.addItem(self.v_line, ignoreBounds=True)
         self.plot_item.addItem(self.h_line, ignoreBounds=True)
-
-        # Initialize highlighted curve in a case of multiple curves
-        self.highlighted_curve_index = None
-
-        # Add TextItem to display coordinates
-        self.coord_label = pg.TextItem("", anchor=(1, 1), fill=(0, 0, 0, 100))
-        self.coord_label.setVisible(False)  # Hide initially
-        self.coord_label.skip_auto_range = True
-        self.plot_item.addItem(self.coord_label)
-
-        # Signals to connect
         self.proxy = pg.SignalProxy(
             self.plot_item.scene().sigMouseMoved, rateLimit=60, slot=self.mouse_moved
         )
-        self.positionChanged.connect(self.update_coord_label)
         self.plot_item.scene().sigMouseClicked.connect(self.mouse_clicked)
 
-        # Connect signals from pyqtgraph right click menu
-        self.plot_item.ctrl.derivativeCheck.checkStateChanged.connect(self.check_derivatives)
-        self.plot_item.ctrl.logXCheck.checkStateChanged.connect(self.check_log)
-        self.plot_item.ctrl.logYCheck.checkStateChanged.connect(self.check_log)
-        self.plot_item.ctrl.downsampleSpin.valueChanged.connect(self.clear_markers)
-
         # Initialize markers
-        self.items = []
-        self.marker_moved_1d = {}
-        self.marker_clicked_1d = {}
-        self.marker_2d_row = None
-        self.marker_2d_col = None
-        self.update_markers()
-        self.check_log()
-        self.check_derivatives()
-
-        self._connect_to_theme_change()
-
-    @property
-    def precision(self) -> int | None:
-        """Fixed number of decimals; ``None`` enables dynamic mode."""
-        return self._precision
-
-    @precision.setter
-    def precision(self, value: int | None):
-        """
-        Set the fixed number of decimals to display.
-
-        Args:
-            value(int | None): The number of decimals to display. If `None`, dynamic precision is used based on the view range.
-        """
-        self._precision = value
-
-    @property
-    def min_precision(self) -> int:
-        """Lower bound on decimals when dynamic precision is used."""
-        return self._min_precision
-
-    @min_precision.setter
-    def min_precision(self, value: int):
-        """
-        Set the lower bound on decimals when dynamic precision is used.
-
-        Args:
-            value(int): The minimum number of decimals to display. Must be non-negative.
-        """
-        self._min_precision = max(0, int(value))
-
-    def _current_precision(self) -> int:
-        """
-        Get the current precision based on the view range or fixed precision.
-        """
-        if self._precision is not None:
-            return self._precision
-
-        # Dynamically choose precision from the smaller visible span
-        view_range = self.plot_item.vb.viewRange()
-        x_span = abs(view_range[0][1] - view_range[0][0])
-        y_span = abs(view_range[1][1] - view_range[1][0])
-
-        # Ignore zero spans that can appear during initialisation
-        spans = [s for s in (x_span, y_span) if s > 0]
-        span = min(spans) if spans else 1.0
-
-        exponent = np.floor(np.log10(span))  # order of magnitude
-        decimals = max(0, int(-exponent) + 1)
-        return max(self._min_precision, decimals)
-
-    def _connect_to_theme_change(self):
-        """Connect to the theme change signal."""
-        qapp = QApplication.instance()
-        if hasattr(qapp, "theme_signal"):
-            qapp.theme_signal.theme_updated.connect(self._update_theme)
-            self._update_theme()
-
-    @SafeSlot(str)
-    def _update_theme(self, theme: str | None = None):
-        """Update the theme."""
-        if theme is None:
-            qapp = QApplication.instance()
-            if hasattr(qapp, "theme"):
-                theme = qapp.theme.theme
-            else:
-                theme = "dark"
-        self.apply_theme(theme)
-
-    def apply_theme(self, theme: str):
-        """Apply the theme to the plot."""
-        if theme == "dark":
-            text_color = "w"
-            label_bg_color = (50, 50, 50, 150)
-        elif theme == "light":
-            text_color = "k"
-            label_bg_color = (240, 240, 240, 150)
-        else:
-            text_color = "w"
-            label_bg_color = (50, 50, 50, 150)
-
-        self.coord_label.setColor(text_color)
-        self.coord_label.fill = pg.mkBrush(label_bg_color)
-        self.coord_label.border = pg.mkPen(None)
-
-    @SafeSlot(int)
-    def update_highlighted_curve(self, curve_index: int):
-        """
-        Update the highlighted curve in the case of multiple curves in a plot item.
-
-        Args:
-            curve_index(int): The index of curve to highlight
-        """
-        self.highlighted_curve_index = curve_index
-        self.clear_markers()
+        self.marker_moved_1d = []
+        self.marker_clicked_1d = []
+        self.marker_2d = None
         self.update_markers()
 
     def update_markers(self):
         """Update the markers for the crosshair, creating new ones if necessary."""
 
-        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]]
-        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
+        # Clear existing markers
+        for marker in self.marker_moved_1d + self.marker_clicked_1d:
+            self.plot_item.removeItem(marker)
+        if self.marker_2d:
+            self.plot_item.removeItem(self.marker_2d)
 
-        # Create or update markers
-        for item in self.items:
+        # Create new markers
+        self.marker_moved_1d = []
+        self.marker_clicked_1d = []
+        self.marker_2d = None
+        for item in self.plot_item.items:
             if isinstance(item, pg.PlotDataItem):  # 1D plot
                 pen = item.opts["pen"]
                 color = pen.color() if hasattr(pen, "color") else pg.mkColor(pen)
-                name = item.name() or str(id(item))
-                if name in self.marker_moved_1d:
-                    # Update existing markers
-                    marker_moved = self.marker_moved_1d[name]
-                    marker_moved.setPen(pg.mkPen(color))
-                    # Update clicked markers' brushes
-                    for marker_clicked in self.marker_clicked_1d[name]:
-                        alpha = marker_clicked.opts["brush"].color().alpha()
-                        marker_clicked.setBrush(
-                            pg.mkBrush(color.red(), color.green(), color.blue(), alpha)
-                        )
-                    # Update z-values
-                    marker_moved.setZValue(item.zValue() + 1)
-                    for marker_clicked in self.marker_clicked_1d[name]:
-                        marker_clicked.setZValue(item.zValue() + 1)
-                else:
-                    # Create new markers
-                    marker_moved = CrosshairScatterItem(
-                        size=10, pen=pg.mkPen(color), brush=pg.mkBrush(None)
+                marker_moved = pg.ScatterPlotItem(
+                    size=10, pen=pg.mkPen(color), brush=pg.mkBrush(None)
+                )
+                marker_clicked = pg.ScatterPlotItem(
+                    size=10, pen=pg.mkPen(None), brush=pg.mkBrush(color)
+                )
+                self.marker_moved_1d.append(marker_moved)
+                self.plot_item.addItem(marker_moved)
+                # Create glowing effect markers for clicked events
+                marker_clicked_list = []
+                for size, alpha in [(18, 64), (14, 128), (10, 255)]:
+                    marker_clicked = pg.ScatterPlotItem(
+                        size=size,
+                        pen=pg.mkPen(None),
+                        brush=pg.mkBrush(color.red(), color.green(), color.blue(), alpha),
                     )
-                    marker_moved.skip_auto_range = True
-                    marker_moved.is_crosshair = True
-                    self.marker_moved_1d[name] = marker_moved
-                    self.plot_item.addItem(marker_moved)
-                    # Set marker z-value higher than the curve
-                    marker_moved.setZValue(item.zValue() + 1)
+                    marker_clicked_list.append(marker_clicked)
+                    self.plot_item.addItem(marker_clicked)
 
-                    # Create glowing effect markers for clicked events
-                    marker_clicked_list = []
-                    for size, alpha in [(18, 64), (14, 128), (10, 255)]:
-                        marker_clicked = CrosshairScatterItem(
-                            size=size,
-                            pen=pg.mkPen(None),
-                            brush=pg.mkBrush(color.red(), color.green(), color.blue(), alpha),
-                        )
-                        marker_clicked.skip_auto_range = True
-                        marker_clicked.is_crosshair = True
-                        self.plot_item.addItem(marker_clicked)
-                        marker_clicked.setZValue(item.zValue() + 1)
-                        marker_clicked_list.append(marker_clicked)
-                    self.marker_clicked_1d[name] = marker_clicked_list
+                self.marker_clicked_1d.append(marker_clicked_list)
             elif isinstance(item, pg.ImageItem):  # 2D plot
-                if self.marker_2d_row is not None and self.marker_2d_col is not None:
-                    continue
-                # Create horizontal ROI for row highlighting
-                if item.image is None:
-                    continue
-                self.marker_2d_row = pg.ROI(
-                    [0, 0], size=[item.image.shape[0], 1], pen=pg.mkPen("r", width=2), movable=False
+                self.marker_2d = pg.ROI(
+                    [0, 0], size=[1, 1], pen=pg.mkPen("r", width=2), movable=False
                 )
-                self.marker_2d_row.skip_auto_range = True
-                if item.image_transform is not None:
-                    self.marker_2d_row.setTransform(item.image_transform)
-                self.plot_item.addItem(self.marker_2d_row)
+                self.plot_item.addItem(self.marker_2d)
 
-                # Create vertical ROI for column highlighting
-                self.marker_2d_col = pg.ROI(
-                    [0, 0], size=[1, item.image.shape[1]], pen=pg.mkPen("r", width=2), movable=False
-                )
-                if item.image_transform is not None:
-                    self.marker_2d_col.setTransform(item.image_transform)
-                self.marker_2d_col.skip_auto_range = True
-                self.plot_item.addItem(self.marker_2d_col)
-
-    @SafeSlot()
-    def update_markers_on_image_change(self):
-        """
-        Update markers when the image changes, e.g. when the
-        image shape or transformation changes.
-        """
-        for item in self.items:
-            if not isinstance(item, pg.ImageItem):
-                continue
-            if self.marker_2d_row is not None:
-                self.marker_2d_row.setSize([item.image.shape[0], 1])
-                self.marker_2d_row.setTransform(item.image_transform)
-            if self.marker_2d_col is not None:
-                self.marker_2d_col.setSize([1, item.image.shape[1]])
-                self.marker_2d_col.setTransform(item.image_transform)
-            # Get the current mouse position
-            views = self.plot_item.vb.scene().views()
-            if not views:
-                return
-            view = views[0]
-            global_pos = QCursor.pos()
-            view_pos = view.mapFromGlobal(global_pos)
-            scene_pos = view.mapToScene(view_pos)
-
-            if self.plot_item.vb.sceneBoundingRect().contains(scene_pos):
-                plot_pt = self.plot_item.vb.mapSceneToView(scene_pos)
-                self.mouse_moved(manual_pos=(plot_pt.x(), plot_pt.y()))
-
-    def snap_to_data(
-        self, x: float, y: float
-    ) -> tuple[None, None] | tuple[defaultdict[Any, list], defaultdict[Any, list]]:
+    def snap_to_data(self, x, y) -> tuple:
         """
         Finds the nearest data points to the given x and y coordinates.
 
         Args:
-            x(float): The x-coordinate of the mouse cursor
-            y(float): The y-coordinate of the mouse cursor
+            x: The x-coordinate
+            y: The y-coordinate
 
         Returns:
-            tuple: x and y values snapped to the nearest data
+            tuple: The nearest x and y values
         """
-        y_values = defaultdict(list)
-        x_values = defaultdict(list)
+        y_values_1d = []
+        x_values_1d = []
+        image_2d = None
 
         # Iterate through items in the plot
-        for item in self.items:
+        for item in self.plot_item.items:
             if isinstance(item, pg.PlotDataItem):  # 1D plot
-                name = item.name() or str(id(item))
-                plot_data = item._getDisplayDataset()
-                if plot_data is None:
-                    continue
-                x_data, y_data = plot_data.x, plot_data.y
+                x_data, y_data = item.xData, item.yData
                 if x_data is not None and y_data is not None:
                     if self.is_log_x:
                         min_x_data = np.min(x_data[x_data > 0])
@@ -344,143 +112,83 @@ class Crosshair(QObject):
                         min_x_data = np.min(x_data)
                     max_x_data = np.max(x_data)
                     if x < min_x_data or x > max_x_data:
-                        y_values[name] = None
-                        x_values[name] = None
-                        continue
+                        return None, None
                     closest_x, closest_y = self.closest_x_y_value(x, x_data, y_data)
-                    y_values[name] = closest_y
-                    x_values[name] = closest_x
+                    y_values_1d.append(closest_y)
+                    x_values_1d.append(closest_x)
             elif isinstance(item, pg.ImageItem):  # 2D plot
-                name = item.objectName() or str(id(item))
                 image_2d = item.image
-                if image_2d is None:
-                    continue
-                # Map scene coordinates (plot units) back to image pixel coordinates
-                if item.image_transform is not None:
-                    inv_transform, _ = item.image_transform.inverted()
-                    xy_trans = inv_transform.map(QPointF(x, y))
-                else:
-                    xy_trans = QPointF(x, y)
 
-                # Define valid pixel coordinate bounds
-                min_x_px, min_y_px = 0, 0
-                max_x_px = image_2d.shape[0] - 1  # columns
-                max_y_px = image_2d.shape[1] - 1  # rows
-
-                # Clip the mapped coordinates to the image bounds
-                px = int(np.clip(xy_trans.x(), min_x_px, max_x_px))
-                py = int(np.clip(xy_trans.y(), min_y_px, max_y_px))
-
-                # Store snapped pixel positions
-                x_values[name] = px
-                y_values[name] = py
-
-        if x_values and y_values:
-            if all(v is None for v in x_values.values()) or all(
-                v is None for v in y_values.values()
-            ):
+        # Handle 1D plot
+        if y_values_1d:
+            if all(v is None for v in x_values_1d) or all(v is None for v in y_values_1d):
                 return None, None
-            return x_values, y_values
+            closest_x = min(x_values_1d, key=lambda xi: abs(xi - x))  # Snap x to closest data point
+            return closest_x, y_values_1d
+
+        # Handle 2D plot
+        if image_2d is not None:
+            x_idx = int(np.clip(x, 0, image_2d.shape[0] - 1))
+            y_idx = int(np.clip(y, 0, image_2d.shape[1] - 1))
+            return x_idx, y_idx
 
         return None, None
 
-    def closest_x_y_value(self, input_x: float, list_x: list, list_y: list) -> tuple:
+    def closest_x_y_value(self, input_value: float, list_x: list, list_y: list) -> tuple:
         """
         Find the closest x and y value to the input value.
 
         Args:
-            input_x (float): Input value
+            input_value (float): Input value
             list_x (list): List of x values
             list_y (list): List of y values
 
         Returns:
             tuple: Closest x and y value
         """
-        # Convert lists to NumPy arrays
-        arr_x = np.asarray(list_x)
+        arr = np.asarray(list_x)
+        i = (np.abs(arr - input_value)).argmin()
+        return list_x[i], list_y[i]
 
-        # Get the indices where x is not NaN
-        valid_indices = ~np.isnan(arr_x)
-
-        # Filter x array to exclude NaN values
-        filtered_x = arr_x[valid_indices]
-
-        # Find the index of the closest value in the filtered x array
-        closest_index = np.abs(filtered_x - input_x).argmin()
-
-        # Map back to the original index in the list_x and list_y arrays
-        original_index = np.where(valid_indices)[0][closest_index]
-
-        return list_x[original_index], list_y[original_index]
-
-    @SafeSlot(object, tuple)
-    def mouse_moved(self, event=None, manual_pos=None):
-        """
-        Handles the mouse moved event, updating the crosshair position and emitting signals.
+    def mouse_moved(self, event):
+        """Handles the mouse moved event, updating the crosshair position and emitting signals.
 
         Args:
-            event(object): The mouse moved event, which contains the scene position.
-            manual_pos(tuple, optional): A tuple containing the (x, y) coordinates to manually set the crosshair position.
+            event: The mouse moved event
         """
-        # Determine target (x, y) in *plot* coordinates
-        if manual_pos is not None:
-            x, y = manual_pos
-        else:
-            if event is None:
-                return  # nothing to do
-            scene_pos = event[0]  # SignalProxy bundle
-            if not self.plot_item.vb.sceneBoundingRect().contains(scene_pos):
-                return
-            view_pos = self.plot_item.vb.mapSceneToView(scene_pos)
-            x, y = view_pos.x(), view_pos.y()
+        self.check_log()
+        pos = event[0]
+        if self.plot_item.vb.sceneBoundingRect().contains(pos):
+            mouse_point = self.plot_item.vb.mapSceneToView(pos)
+            self.v_line.setPos(mouse_point.x())
+            self.h_line.setPos(mouse_point.y())
 
-        # Update cross‑hair visuals
-        self.v_line.setPos(x)
-        self.h_line.setPos(y)
+            x, y = mouse_point.x(), mouse_point.y()
+            if self.is_log_x:
+                x = 10**x
+            if self.is_log_y:
+                y = 10**y
+            x, y_values = self.snap_to_data(x, y)
 
-        self.update_markers()
-        scaled_x, scaled_y = self.scale_emitted_coordinates(x, y)
-        self.crosshairChanged.emit((scaled_x, scaled_y))
-        self.positionChanged.emit((x, y))
-
-        snap_x_vals, snap_y_vals = self.snap_to_data(x, y)
-        if snap_x_vals is None or snap_y_vals is None:
-            return
-        if all(v is None for v in snap_x_vals.values()) or all(
-            v is None for v in snap_y_vals.values()
-        ):
-            return
-
-        precision = self._current_precision()
-
-        for item in self.items:
-            if isinstance(item, pg.PlotDataItem):
-                name = item.name() or str(id(item))
-                sx, sy = snap_x_vals[name], snap_y_vals[name]
-                if sx is None or sy is None:
-                    continue
-                self.marker_moved_1d[name].setData([sx], [sy])
-                sx_s, sy_s = self.scale_emitted_coordinates(sx, sy)
-                self.coordinatesChanged1D.emit(
-                    (name, round(sx_s, precision), round(sy_s, precision))
-                )
-
-            elif isinstance(item, pg.ImageItem):
-                name = item.objectName() or str(id(item))
-                px, py = snap_x_vals[name], snap_y_vals[name]
-                if px is None or py is None:
-                    continue
-
-                # Respect image transforms
-                if isinstance(item, ImageItem) and item.image_transform is not None:
-                    row, col = self._get_transformed_position(px, py, item.image_transform)
-                    self.marker_2d_row.setPos(row)
-                    self.marker_2d_col.setPos(col)
-                else:
-                    self.marker_2d_row.setPos([0, py])
-                    self.marker_2d_col.setPos([px, 0])
-
-                self.coordinatesChanged2D.emit((name, px, py))
+            for item in self.plot_item.items:
+                if isinstance(item, pg.PlotDataItem):
+                    if x is None or all(v is None for v in y_values):
+                        return
+                    coordinate_to_emit = (
+                        round(x, self.precision),
+                        [round(y_val, self.precision) for y_val in y_values],
+                    )
+                    self.coordinatesChanged1D.emit(coordinate_to_emit)
+                    for i, y_val in enumerate(y_values):
+                        self.marker_moved_1d[i].setData(
+                            [x if not self.is_log_x else np.log10(x)],
+                            [y_val if not self.is_log_y else np.log10(y_val)],
+                        )
+                elif isinstance(item, pg.ImageItem):
+                    if x is None or y_values is None:
+                        return
+                    coordinate_to_emit = (x, y_values)
+                    self.coordinatesChanged2D.emit(coordinate_to_emit)
 
     def mouse_clicked(self, event):
         """Handles the mouse clicked event, updating the crosshair position and emitting signals.
@@ -488,163 +196,40 @@ class Crosshair(QObject):
         Args:
             event: The mouse clicked event
         """
-
-        # we only accept left mouse clicks
-        if event.button() != Qt.MouseButton.LeftButton:
-            return
-        self.update_markers()
+        self.check_log()
         if self.plot_item.vb.sceneBoundingRect().contains(event._scenePos):
             mouse_point = self.plot_item.vb.mapSceneToView(event._scenePos)
             x, y = mouse_point.x(), mouse_point.y()
-            scaled_x, scaled_y = self.scale_emitted_coordinates(mouse_point.x(), mouse_point.y())
-            self.crosshairClicked.emit((scaled_x, scaled_y))
-            self.positionClicked.emit((x, y))
 
-            x_snap_values, y_snap_values = self.snap_to_data(x, y)
+            if self.is_log_x:
+                x = 10**x
+            if self.is_log_y:
+                y = 10**y
+            x, y_values = self.snap_to_data(x, y)
 
-            if x_snap_values is None or y_snap_values is None:
-                return
-            if all(v is None for v in x_snap_values.values()) or all(
-                v is None for v in y_snap_values.values()
-            ):
-                # not sure how we got here, but just to be safe...
-                return
-
-            precision = self._current_precision()
-            for item in self.items:
+            for item in self.plot_item.items:
                 if isinstance(item, pg.PlotDataItem):
-                    name = item.name() or str(id(item))
-                    x, y = x_snap_values[name], y_snap_values[name]
-                    if x is None or y is None:
-                        continue
-                    for marker_clicked in self.marker_clicked_1d[name]:
-                        marker_clicked.setData([x], [y])
-                    x_snapped_scaled, y_snapped_scaled = self.scale_emitted_coordinates(x, y)
+                    if x is None or all(v is None for v in y_values):
+                        return
                     coordinate_to_emit = (
-                        name,
-                        round(x_snapped_scaled, precision),
-                        round(y_snapped_scaled, precision),
+                        round(x, self.precision),
+                        [round(y_val, self.precision) for y_val in y_values],
                     )
                     self.coordinatesClicked1D.emit(coordinate_to_emit)
+                    for i, y_val in enumerate(y_values):
+                        for marker in self.marker_clicked_1d[i]:
+                            marker.setData(
+                                [x if not self.is_log_x else np.log10(x)],
+                                [y_val if not self.is_log_y else np.log10(y_val)],
+                            )
                 elif isinstance(item, pg.ImageItem):
-                    name = item.objectName() or str(id(item))
-                    x, y = x_snap_values[name], y_snap_values[name]
-                    if x is None or y is None:
-                        continue
-
-                    if isinstance(item, ImageItem) and item.image_transform is not None:
-                        row, col = self._get_transformed_position(x, y, item.image_transform)
-                        self.marker_2d_row.setPos(row)
-                        self.marker_2d_col.setPos(col)
-                    else:
-                        self.marker_2d_row.setPos([0, y])
-                        self.marker_2d_col.setPos([x, 0])
-
-                    coordinate_to_emit = (name, x, y)
+                    if x is None or y_values is None:
+                        return
+                    coordinate_to_emit = (x, y_values)
                     self.coordinatesClicked2D.emit(coordinate_to_emit)
-                else:
-                    continue
-
-    def _get_transformed_position(
-        self, x: float, y: float, transform: QTransform
-    ) -> tuple[QPointF, QPointF]:
-        """
-        Maps the given x and y coordinates to the transformed position using the provided transform.
-        Args:
-            x (float): The x-coordinate to transform.
-            y (float): The y-coordinate to transform.
-            transform (QTransform): The transformation to apply.
-        """
-        origin = transform.map(QPointF(0, 0))
-        row = transform.map(QPointF(0, y)) - origin
-        col = transform.map(QPointF(x, 0)) - origin
-        return row, col
-
-    def clear_markers(self):
-        """Clears the markers from the plot."""
-        for marker in self.marker_moved_1d.values():
-            self.plot_item.removeItem(marker)
-        for markers in self.marker_clicked_1d.values():
-            for marker in markers:
-                self.plot_item.removeItem(marker)
-        self.marker_moved_1d.clear()
-        self.marker_clicked_1d.clear()
-
-    def scale_emitted_coordinates(self, x, y):
-        """Scales the emitted coordinates if the axes are in log scale.
-
-        Args:
-            x (float): The x-coordinate
-            y (float): The y-coordinate
-
-        Returns:
-            tuple: The scaled x and y coordinates
-        """
-        if self.is_log_x:
-            x = 10**x
-        if self.is_log_y:
-            y = 10**y
-        return x, y
-
-    def update_coord_label(self, pos: tuple):
-        """Updates the coordinate label based on the crosshair position and axis scales.
-
-        Args:
-            pos (tuple): The (x, y) position of the crosshair.
-        """
-        x, y = pos
-        x_scaled, y_scaled = self.scale_emitted_coordinates(x, y)
-        precision = self._current_precision()
-        text = f"({x_scaled:.{precision}f}, {y_scaled:.{precision}f})"
-        for item in self.items:
-            if isinstance(item, pg.ImageItem):
-                image = item.image
-                if image is None:
-                    continue
-
-                if item.image_transform is not None:
-                    inv_transform, _ = item.image_transform.inverted()
-                    pt = inv_transform.map(QPointF(x, y))
-                    px, py = pt.x(), pt.y()
-                else:
-                    px, py = x, y
-
-                # Clip to valid pixel indices
-                ix = int(np.clip(px, 0, image.shape[0] - 1))  # column
-                iy = int(np.clip(py, 0, image.shape[1] - 1))  # row
-
-                intensity = image[ix, iy]
-                text += f"\nIntensity: {intensity:.{precision}f}"
-                break
-        # Update coordinate label
-        self.coord_label.setText(text)
-        self.coord_label.setPos(x, y)
-        self.coord_label.setVisible(True)
+                    self.marker_2d.setPos([x, y_values])
 
     def check_log(self):
         """Checks if the x or y axis is in log scale and updates the internal state accordingly."""
-        self.is_log_x = self.plot_item.axes["bottom"]["item"].logMode
-        self.is_log_y = self.plot_item.axes["left"]["item"].logMode
-        self.clear_markers()
-
-    def check_derivatives(self):
-        """Checks if the derivatives are enabled and updates the internal state accordingly."""
-        self.is_derivative = self.plot_item.ctrl.derivativeCheck.isChecked()
-        self.clear_markers()
-
-    @SafeSlot()
-    def reset(self):
-        """Resets the crosshair to its initial state."""
-        if self.marker_2d_row is not None:
-            self.plot_item.removeItem(self.marker_2d_row)
-            self.marker_2d_row = None
-        if self.marker_2d_col is not None:
-            self.plot_item.removeItem(self.marker_2d_col)
-            self.marker_2d_col = None
-        self.clear_markers()
-
-    def cleanup(self):
-        self.reset()
-        self.plot_item.removeItem(self.v_line)
-        self.plot_item.removeItem(self.h_line)
-        self.plot_item.removeItem(self.coord_label)
+        self.is_log_x = self.plot_item.ctrl.logXCheck.isChecked()
+        self.is_log_y = self.plot_item.ctrl.logYCheck.isChecked()

bec_widgets/utils/entry_validator.py

@@ -17,28 +17,12 @@ class EntryValidator:
             raise ValueError(f"Device '{name}' not found in current BEC session")
 
         device = self.devices[name]
+        description = device.describe()
 
-        # Build list of available signal entries from device._info['signals']
-        signals_dict = getattr(device, "_info", {}).get("signals", {})
-        available_entries = [
-            sig.get("obj_name") for sig in signals_dict.values() if sig.get("obj_name")
-        ]
-
-        # If no signals are found, means device is a signal, use the device name as the entry
-        if not available_entries:
-            available_entries = [name]
-
-        # edge case for if name is passed instead of full_name, should not happen
-        if entry in signals_dict:
-            entry = signals_dict[entry].get("obj_name", entry)
-
-        if entry is None or entry == "":
+        if entry is None:
             entry = next(iter(device._hints), name) if hasattr(device, "_hints") else name
-        if entry not in available_entries:
-            raise ValueError(
-                f"Entry '{entry}' not found in device '{name}' signals. "
-                f"Available signals: '{available_entries}'"
-            )
+        if entry not in description:
+            raise ValueError(f"Entry '{entry}' not found in device '{name}' signals")
 
         return entry
 

bec_widgets/utils/error_popups.py

@@ -1,392 +0,0 @@
-import functools
-import sys
-import traceback
-
-import shiboken6
-from bec_lib.logger import bec_logger
-from louie.saferef import safe_ref
-from qtpy.QtCore import Property, QObject, Qt, Signal, Slot
-from qtpy.QtWidgets import QApplication, QMessageBox, QPushButton, QVBoxLayout, QWidget
-
-logger = bec_logger.logger
-
-
-def SafeProperty(prop_type, *prop_args, popup_error: bool = False, default=None, **prop_kwargs):
-    """
-    Decorator to create a Qt Property with safe getter and setter so that
-    Qt Designer won't crash if an exception occurs in either method.
-
-    Args:
-        prop_type: The property type (e.g., str, bool, int, custom classes, etc.)
-        popup_error (bool): If True, show a popup for any error; otherwise, ignore or log silently.
-        default: Any default/fallback value to return if the getter raises an exception.
-        *prop_args, **prop_kwargs: Passed along to the underlying Qt Property constructor.
-
-    Usage:
-        @SafeProperty(int, default=-1)
-        def some_value(self) -> int:
-            # your getter logic
-            return ...   # if an exception is raised, returns -1
-
-        @some_value.setter
-        def some_value(self, val: int):
-            # your setter logic
-            ...
-    """
-
-    def decorator(py_getter):
-        """Decorator for the user's property getter function."""
-
-        @functools.wraps(py_getter)
-        def safe_getter(self_):
-            try:
-                return py_getter(self_)
-            except Exception:
-                # Identify which property function triggered error
-                prop_name = f"{py_getter.__module__}.{py_getter.__qualname__}"
-                error_msg = traceback.format_exc()
-
-                if popup_error:
-                    ErrorPopupUtility().custom_exception_hook(*sys.exc_info(), popup_error=True)
-                logger.error(f"SafeProperty error in GETTER of '{prop_name}':\n{error_msg}")
-                return default
-
-        class PropertyWrapper:
-            """
-            Intermediate wrapper used so that the user can optionally chain .setter(...).
-            """
-
-            def __init__(self, getter_func):
-                # We store only our safe_getter in the wrapper
-                self.getter_func = safe_getter
-
-            def setter(self, setter_func):
-                """Wraps the user-defined setter to handle errors safely."""
-
-                @functools.wraps(setter_func)
-                def safe_setter(self_, value):
-                    try:
-                        return setter_func(self_, value)
-                    except Exception:
-                        prop_name = f"{setter_func.__module__}.{setter_func.__qualname__}"
-                        error_msg = traceback.format_exc()
-
-                        if popup_error:
-                            ErrorPopupUtility().custom_exception_hook(
-                                *sys.exc_info(), popup_error=True
-                            )
-                        logger.error(f"SafeProperty error in SETTER of '{prop_name}':\n{error_msg}")
-                        return
-
-                # Return the full read/write Property
-                return Property(prop_type, self.getter_func, safe_setter, *prop_args, **prop_kwargs)
-
-            def __call__(self):
-                """
-                If user never calls `.setter(...)`, produce a read-only property.
-                """
-                return Property(prop_type, self.getter_func, None, *prop_args, **prop_kwargs)
-
-        return PropertyWrapper(py_getter)
-
-    return decorator
-
-
-def _safe_connect_slot(weak_instance, weak_slot, *connect_args):
-    """Internal function used by SafeConnect to handle weak references to slots."""
-    instance = weak_instance()
-    slot_func = weak_slot()
-
-    # Check if the python object has already been garbage collected
-    if instance is None or slot_func is None:
-        return
-
-    # Check if the python object has already been marked for deletion
-    if getattr(instance, "_destroyed", False):
-        return
-
-    # Check if the C++ object is still valid
-    if not shiboken6.isValid(instance):
-        return
-
-    if connect_args:
-        slot_func(*connect_args)
-    slot_func()
-
-
-def SafeConnect(instance, signal, slot):  # pylint: disable=invalid-name
-    """
-    Method to safely handle Qt signal-slot connections. The python object is only forwarded
-    as a weak reference to avoid stale objects.
-
-    Args:
-        instance: The instance to connect.
-        signal: The signal to connect to.
-        slot: The slot to connect.
-
-    Example:
-        >>> SafeConnect(self, qapp.theme.theme_changed, self._update_theme)
-
-    """
-    weak_instance = safe_ref(instance)
-    weak_slot = safe_ref(slot)
-
-    # Create a partial function that will check weak references before calling the actual slot
-    safe_slot = functools.partial(_safe_connect_slot, weak_instance, weak_slot)
-
-    # Connect the signal to the safe connect slot wrapper
-    return signal.connect(safe_slot)
-
-
-def SafeSlot(*slot_args, **slot_kwargs):  # pylint: disable=invalid-name
-    """Function with args, acting like a decorator, applying "error_managed" decorator + Qt Slot
-    to the passed function, to display errors instead of potentially raising an exception
-
-    'popup_error' keyword argument can be passed with boolean value if a dialog should pop up,
-    otherwise error display is left to the original exception hook
-    'verify_sender' keyword argument can be passed with boolean value if the sender should be verified
-    before executing the slot. If True, the slot will only execute if the sender is a QObject. This is
-    useful to prevent function calls from already deleted objects.
-    'raise_error' keyword argument can be passed with boolean value if the error should be raised
-    after the error is displayed. This is useful to propagate the error to the caller but should be used
-    with great care to avoid segfaults.
-
-    The keywords above are stored in a container which can be overridden by passing
-    '_override_slot_params' keyword argument with a dictionary containing the keywords to override.
-    This is useful to override the default behavior of the decorator for a specific function call.
-
-    """
-    _slot_params = {
-        "popup_error": bool(slot_kwargs.pop("popup_error", False)),
-        "verify_sender": bool(slot_kwargs.pop("verify_sender", False)),
-        "raise_error": bool(slot_kwargs.pop("raise_error", False)),
-    }
-
-    def error_managed(method):
-        @Slot(*slot_args, **slot_kwargs)
-        @functools.wraps(method)
-        def wrapper(*args, **kwargs):
-
-            _override_slot_params = kwargs.pop("_override_slot_params", {})
-            _slot_params.update(_override_slot_params)
-            try:
-                if not _slot_params["verify_sender"] or len(args) == 0:
-                    return method(*args, **kwargs)
-
-                _instance = args[0]
-                if not isinstance(_instance, QObject):
-                    return method(*args, **kwargs)
-                sender = _instance.sender()
-                if sender is None:
-                    logger.info(
-                        f"Sender is None for {method.__module__}.{method.__qualname__}, "
-                        "skipping method call."
-                    )
-                    return
-                return method(*args, **kwargs)
-
-            except Exception:
-                slot_name = f"{method.__module__}.{method.__qualname__}"
-                error_msg = traceback.format_exc()
-                if _slot_params["popup_error"]:
-                    ErrorPopupUtility().custom_exception_hook(*sys.exc_info(), popup_error=True)
-                logger.error(f"SafeSlot error in slot '{slot_name}':\n{error_msg}")
-                if _slot_params["raise_error"]:
-                    raise
-
-        return wrapper
-
-    return error_managed
-
-
-class WarningPopupUtility(QObject):
-    """
-    Utility class to show warning popups in the application.
-    """
-
-    @SafeSlot(str, str, str, QWidget)
-    def show_warning_message(self, title, message, detailed_text, widget):
-        msg = QMessageBox(widget)
-        msg.setIcon(QMessageBox.Warning)
-        msg.setWindowTitle(title)
-        msg.setText(message)
-        msg.setStandardButtons(QMessageBox.Ok)
-        msg.setDetailedText(detailed_text)
-        msg.exec_()
-
-    def show_warning(self, title: str, message: str, detailed_text: str, widget: QWidget = None):
-        """
-        Show a warning message with the given title, message, and detailed text.
-
-        Args:
-            title (str): The title of the warning message.
-            message (str): The main text of the warning message.
-            detailed_text (str): The detailed text to show when the user expands the message.
-            widget (QWidget): The parent widget for the message box.
-        """
-        self.show_warning_message(title, message, detailed_text, widget)
-
-
-_popup_utility_instance = None
-
-
-class _ErrorPopupUtility(QObject):
-    """
-    Utility class to manage error popups in the application to show error messages to the users.
-    This class is singleton and the error popup can be enabled or disabled globally or attach to widget methods with decorator @error_managed.
-    """
-
-    error_occurred = Signal(str, str, QWidget)
-
-    def __init__(self, parent=None):
-        super().__init__(parent=parent)
-        self.error_occurred.connect(self.show_error_message)
-        self.enable_error_popup = False
-        self._initialized = True
-        sys.excepthook = self.custom_exception_hook
-
-    @SafeSlot(str, str, QWidget)
-    def show_error_message(self, title, message, widget):
-        detailed_text = self.format_traceback(message)
-        error_message = self.parse_error_message(detailed_text)
-
-        msg = QMessageBox(widget)
-        msg.setIcon(QMessageBox.Critical)
-        msg.setWindowTitle(title)
-        msg.setText(error_message)
-        msg.setStandardButtons(QMessageBox.Ok)
-        msg.setDetailedText(detailed_text)
-        msg.setTextInteractionFlags(Qt.TextSelectableByMouse)
-        msg.setMinimumWidth(600)
-        msg.setMinimumHeight(400)
-        msg.exec_()
-
-    def show_property_error(self, title, message, widget):
-        """
-        Show a property-specific error message.
-        """
-        self.error_occurred.emit(title, message, widget)
-
-    def format_traceback(self, traceback_message: str) -> str:
-        """
-        Format the traceback message to be displayed in the error popup by adding indentation to each line.
-
-        Args:
-            traceback_message(str): The traceback message to be formatted.
-
-        Returns:
-            str: The formatted traceback message.
-        """
-        formatted_lines = []
-        lines = traceback_message.split("\n")
-        for line in lines:
-            formatted_lines.append("    " + line)  # Add indentation to each line
-        return "\n".join(formatted_lines)
-
-    def parse_error_message(self, traceback_message):
-        lines = traceback_message.split("\n")
-        error_message = "Error occurred. See details."
-        capture = False
-        captured_message = []
-
-        for line in lines:
-            if "raise" in line:
-                capture = True
-                continue
-            if capture:
-                if line.strip() and not line.startswith("  File "):
-                    captured_message.append(line.strip())
-                else:
-                    break
-
-        if captured_message:
-            error_message = " ".join(captured_message)
-        return error_message
-
-    def get_error_message(self, exctype, value, tb):
-        return "".join(traceback.format_exception(exctype, value, tb))
-
-    def custom_exception_hook(self, exctype, value, tb, popup_error=False):
-        if popup_error or self.enable_error_popup:
-            self.error_occurred.emit(
-                "Method error" if popup_error else "Application Error",
-                self.get_error_message(exctype, value, tb),
-                self.parent(),
-            )
-        else:
-            sys.__excepthook__(exctype, value, tb)  # Call the original excepthook
-
-    def enable_global_error_popups(self, state: bool):
-        """
-        Enable or disable global error popups for all applications.
-
-        Args:
-            state(bool): True to enable error popups, False to disable error popups.
-        """
-        self.enable_error_popup = bool(state)
-
-
-def ErrorPopupUtility():
-    global _popup_utility_instance
-    if not _popup_utility_instance:
-        _popup_utility_instance = _ErrorPopupUtility()
-    return _popup_utility_instance
-
-
-class ExampleWidget(QWidget):  # pragma: no cover
-    """
-    Example widget to demonstrate error handling with the ErrorPopupUtility.
-
-    Warnings -> This example works properly only with PySide6, PyQt6 has a bug with the error handling.
-    """
-
-    def __init__(self, parent=None):
-        super().__init__(parent=parent)
-        self.init_ui()
-        self.warning_utility = WarningPopupUtility(self)
-
-    def init_ui(self):
-        self.layout = QVBoxLayout(self)
-
-        # Button to trigger method with error handling
-        self.error_button = QPushButton("Trigger Handled Error", self)
-        self.error_button.clicked.connect(self.method_with_error_handling)
-        self.layout.addWidget(self.error_button)
-
-        # Button to trigger method without error handling
-        self.normal_button = QPushButton("Trigger Normal Error", self)
-        self.normal_button.clicked.connect(self.method_without_error_handling)
-        self.layout.addWidget(self.normal_button)
-
-        # Button to trigger warning popup
-        self.warning_button = QPushButton("Trigger Warning", self)
-        self.warning_button.clicked.connect(self.trigger_warning)
-        self.layout.addWidget(self.warning_button)
-
-    @SafeSlot(popup_error=True)
-    def method_with_error_handling(self):
-        """This method raises an error and the exception is handled by the decorator."""
-        raise ValueError("This is a handled error.")
-
-    @SafeSlot()
-    def method_without_error_handling(self):
-        """This method raises an error and the exception is not handled here."""
-        raise ValueError("This is an unhandled error.")
-
-    @SafeSlot()
-    def trigger_warning(self):
-        """Trigger a warning using the WarningPopupUtility."""
-        self.warning_utility.show_warning(
-            title="Warning",
-            message="This is a warning message.",
-            detailed_text="This is the detailed text of the warning message.",
-            widget=self,
-        )
-
-
-if __name__ == "__main__":  # pragma: no cover
-
-    app = QApplication(sys.argv)
-    widget = ExampleWidget()
-    widget.show()
-    sys.exit(app.exec_())

bec_widgets/utils/expandable_frame.py

@@ -1,128 +0,0 @@
-from __future__ import annotations
-
-from bec_qthemes import material_icon
-from qtpy.QtCore import Signal
-from qtpy.QtWidgets import (
-    QApplication,
-    QFrame,
-    QHBoxLayout,
-    QLabel,
-    QLayout,
-    QSizePolicy,
-    QToolButton,
-    QVBoxLayout,
-    QWidget,
-)
-
-from bec_widgets.utils.clickable_label import ClickableLabel
-from bec_widgets.utils.error_popups import SafeProperty, SafeSlot
-
-
-class ExpandableGroupFrame(QFrame):
-
-    expansion_state_changed = Signal()
-
-    EXPANDED_ICON_NAME: str = "collapse_all"
-    COLLAPSED_ICON_NAME: str = "expand_all"
-
-    def __init__(
-        self, parent: QWidget | None = None, title: str = "", expanded: bool = True, icon: str = ""
-    ) -> None:
-        super().__init__(parent=parent)
-        self._expanded = expanded
-
-        self.setFrameStyle(QFrame.Shape.StyledPanel | QFrame.Shadow.Plain)
-        self.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum)
-        self._layout = QVBoxLayout()
-        self._layout.setContentsMargins(0, 0, 0, 0)
-        self.setLayout(self._layout)
-
-        self._create_title_layout(title, icon)
-
-        self._contents = QWidget(self)
-        self._layout.addWidget(self._contents)
-
-        self._expansion_button.clicked.connect(self.switch_expanded_state)
-        self.expanded = self._expanded  # type: ignore
-        self.expansion_state_changed.emit()
-
-    def _create_title_layout(self, title: str, icon: str):
-        self._title_layout = QHBoxLayout()
-        self._layout.addLayout(self._title_layout)
-
-        self._title = ClickableLabel(f"<b>{title}</b>")
-        self._title_icon = ClickableLabel()
-        self._title_layout.addWidget(self._title_icon)
-        self._title_layout.addWidget(self._title)
-        self.icon_name = icon
-        self._title.clicked.connect(self.switch_expanded_state)
-        self._title_icon.clicked.connect(self.switch_expanded_state)
-
-        self._title_layout.addStretch(1)
-
-        self._expansion_button = QToolButton()
-        self._update_expansion_icon()
-        self._title_layout.addWidget(self._expansion_button, stretch=1)
-
-    def set_layout(self, layout: QLayout) -> None:
-        self._contents.setLayout(layout)
-        self._contents.layout().setContentsMargins(0, 0, 0, 0)  # type: ignore
-
-    @SafeSlot()
-    def switch_expanded_state(self):
-        self.expanded = not self.expanded  # type: ignore
-        self._update_expansion_icon()
-        self.expansion_state_changed.emit()
-
-    @SafeProperty(bool)
-    def expanded(self):  # type: ignore
-        return self._expanded
-
-    @expanded.setter
-    def expanded(self, expanded: bool):
-        self._expanded = expanded
-        self._contents.setVisible(expanded)
-        self.updateGeometry()
-        self.adjustSize()
-
-    def _update_expansion_icon(self):
-        self._expansion_button.setIcon(
-            material_icon(icon_name=self.EXPANDED_ICON_NAME, size=(10, 10), convert_to_pixmap=False)
-            if self.expanded
-            else material_icon(
-                icon_name=self.COLLAPSED_ICON_NAME, size=(10, 10), convert_to_pixmap=False
-            )
-        )
-
-    @SafeProperty(str)
-    def icon_name(self):  # type: ignore
-        return self._title_icon_name
-
-    @icon_name.setter
-    def icon_name(self, icon_name: str):
-        self._title_icon_name = icon_name
-        self._set_title_icon(self._title_icon_name)
-
-    def _set_title_icon(self, icon_name: str):
-        if icon_name:
-            self._title_icon.setVisible(True)
-            self._title_icon.setPixmap(
-                material_icon(icon_name=icon_name, size=(20, 20), convert_to_pixmap=True)
-            )
-        else:
-            self._title_icon.setVisible(False)
-
-
-# Application example
-if __name__ == "__main__":  # pragma: no cover
-
-    app = QApplication([])
-    frame = ExpandableGroupFrame()
-    layout = QVBoxLayout()
-    frame.set_layout(layout)
-    layout.addWidget(QLabel("test1"))
-    layout.addWidget(QLabel("test2"))
-    layout.addWidget(QLabel("test3"))
-
-    frame.show()
-    app.exec()

bec_widgets/utils/filter_io.py

@@ -1,272 +0,0 @@
-"""Module for handling filter I/O operations in BEC Widgets for input fields.
-These operations include filtering device/signal names and/or device types.
-"""
-
-from abc import ABC, abstractmethod
-
-from bec_lib.logger import bec_logger
-from qtpy.QtCore import QStringListModel
-from qtpy.QtWidgets import QComboBox, QCompleter, QLineEdit
-
-from bec_widgets.utils.ophyd_kind_util import Kind
-
-logger = bec_logger.logger
-
-
-class WidgetFilterHandler(ABC):
-    """Abstract base class for widget filter handlers"""
-
-    @abstractmethod
-    def set_selection(self, widget, selection: list[str | tuple]) -> None:
-        """Set the filtered_selection for the widget
-
-        Args:
-            widget: Widget instance
-            selection (list[str | tuple]): Filtered selection of items.
-                If tuple, it contains (text, data) pairs.
-        """
-
-    @abstractmethod
-    def check_input(self, widget, text: str) -> bool:
-        """Check if the input text is in the filtered selection
-
-        Args:
-            widget: Widget instance
-            text (str): Input text
-
-        Returns:
-            bool: True if the input text is in the filtered selection
-        """
-
-    @abstractmethod
-    def update_with_kind(
-        self, kind: Kind, signal_filter: set, device_info: dict, device_name: str
-    ) -> list[str | tuple]:
-        """Update the selection based on the kind of signal.
-
-        Args:
-            kind (Kind): The kind of signal to filter.
-            signal_filter (set): Set of signal kinds to filter.
-            device_info (dict): Dictionary containing device information.
-            device_name (str): Name of the device.
-
-        Returns:
-            list[str | tuple]: A list of filtered signals based on the kind.
-        """
-        # This method should be implemented in subclasses or extended as needed
-
-
-class LineEditFilterHandler(WidgetFilterHandler):
-    """Handler for QLineEdit widget"""
-
-    def set_selection(self, widget: QLineEdit, selection: list[str | tuple]) -> None:
-        """Set the selection for the widget to the completer model
-
-        Args:
-            widget (QLineEdit): The QLineEdit widget
-            selection (list[str | tuple]): Filtered selection of items. If tuple, it contains (text, data) pairs.
-        """
-        if isinstance(selection, tuple):
-            # If selection is a tuple, it contains (text, data) pairs
-            selection = [text for text, _ in selection]
-        if not isinstance(widget.completer, QCompleter):
-            completer = QCompleter(widget)
-            widget.setCompleter(completer)
-        widget.completer.setModel(QStringListModel(selection, widget))
-
-    def check_input(self, widget: QLineEdit, text: str) -> bool:
-        """Check if the input text is in the filtered selection
-
-        Args:
-            widget (QLineEdit): The QLineEdit widget
-            text (str): Input text
-
-        Returns:
-            bool: True if the input text is in the filtered selection
-        """
-        model = widget.completer.model()
-        model_data = [model.data(model.index(i)) for i in range(model.rowCount())]
-        return text in model_data
-
-    def update_with_kind(
-        self, kind: Kind, signal_filter: set, device_info: dict, device_name: str
-    ) -> list[str | tuple]:
-        """Update the selection based on the kind of signal.
-
-        Args:
-            kind (Kind): The kind of signal to filter.
-            signal_filter (set): Set of signal kinds to filter.
-            device_info (dict): Dictionary containing device information.
-            device_name (str): Name of the device.
-
-        Returns:
-            list[str | tuple]: A list of filtered signals based on the kind.
-        """
-
-        return [
-            signal
-            for signal, signal_info in device_info.items()
-            if kind in signal_filter and (signal_info.get("kind_str", None) == str(kind.name))
-        ]
-
-
-class ComboBoxFilterHandler(WidgetFilterHandler):
-    """Handler for QComboBox widget"""
-
-    def set_selection(self, widget: QComboBox, selection: list[str | tuple]) -> None:
-        """Set the selection for the widget to the completer model
-
-        Args:
-            widget (QComboBox): The QComboBox widget
-            selection (list[str | tuple]): Filtered selection of items. If tuple, it contains (text, data) pairs.
-        """
-        widget.clear()
-        if len(selection) == 0:
-            return
-        for element in selection:
-            if isinstance(element, str):
-                widget.addItem(element)
-            elif isinstance(element, tuple):
-                # If element is a tuple, it contains (text, data) pairs
-                widget.addItem(*element)
-
-    def check_input(self, widget: QComboBox, text: str) -> bool:
-        """Check if the input text is in the filtered selection
-
-        Args:
-            widget (QComboBox): The QComboBox widget
-            text (str): Input text
-
-        Returns:
-            bool: True if the input text is in the filtered selection
-        """
-        return text in [widget.itemText(i) for i in range(widget.count())]
-
-    def update_with_kind(
-        self, kind: Kind, signal_filter: set, device_info: dict, device_name: str
-    ) -> list[str | tuple]:
-        """Update the selection based on the kind of signal.
-
-        Args:
-            kind (Kind): The kind of signal to filter.
-            signal_filter (set): Set of signal kinds to filter.
-            device_info (dict): Dictionary containing device information.
-            device_name (str): Name of the device.
-
-        Returns:
-            list[str | tuple]: A list of filtered signals based on the kind.
-        """
-        out = []
-        for signal, signal_info in device_info.items():
-            if kind not in signal_filter or (signal_info.get("kind_str", None) != str(kind.name)):
-                continue
-            obj_name = signal_info.get("obj_name", "")
-            component_name = signal_info.get("component_name", "")
-            signal_wo_device = obj_name.removeprefix(f"{device_name}_")
-            if not signal_wo_device:
-                signal_wo_device = obj_name
-
-            if signal_wo_device != signal and component_name.replace(".", "_") != signal_wo_device:
-                # If the object name is not the same as the signal name, we use the object name
-                # to display in the combobox.
-                out.append((f"{signal_wo_device} ({signal})", signal_info))
-            else:
-                # If the object name is the same as the signal name, we do not change it.
-                out.append((signal, signal_info))
-
-        return out
-
-
-class FilterIO:
-    """Public interface to set filters for input widgets.
-    It supports the list of widgets stored in class attribute _handlers.
-    """
-
-    _handlers = {QLineEdit: LineEditFilterHandler, QComboBox: ComboBoxFilterHandler}
-
-    @staticmethod
-    def set_selection(widget, selection: list[str | tuple], ignore_errors=True):
-        """
-        Retrieve value from the widget instance.
-
-        Args:
-            widget: Widget instance.
-            selection (list[str | tuple]): Filtered selection of items.
-                If tuple, it contains (text, data) pairs.
-            ignore_errors(bool, optional): Whether to ignore if no handler is found.
-        """
-        handler_class = FilterIO._find_handler(widget)
-        if handler_class:
-            return handler_class().set_selection(widget=widget, selection=selection)
-        if not ignore_errors:
-            raise ValueError(
-                f"No matching handler for widget type: {type(widget)} in handler list {FilterIO._handlers}"
-            )
-        return None
-
-    @staticmethod
-    def check_input(widget, text: str, ignore_errors=True):
-        """
-        Check if the input text is in the filtered selection.
-
-        Args:
-            widget: Widget instance.
-            text(str): Input text.
-            ignore_errors(bool, optional): Whether to ignore if no handler is found.
-
-        Returns:
-            bool: True if the input text is in the filtered selection.
-        """
-        handler_class = FilterIO._find_handler(widget)
-        if handler_class:
-            return handler_class().check_input(widget=widget, text=text)
-        if not ignore_errors:
-            raise ValueError(
-                f"No matching handler for widget type: {type(widget)} in handler list {FilterIO._handlers}"
-            )
-        return None
-
-    @staticmethod
-    def update_with_kind(
-        widget, kind: Kind, signal_filter: set, device_info: dict, device_name: str
-    ) -> list[str | tuple]:
-        """
-        Update the selection based on the kind of signal.
-
-        Args:
-            widget: Widget instance.
-            kind (Kind): The kind of signal to filter.
-            signal_filter (set): Set of signal kinds to filter.
-            device_info (dict): Dictionary containing device information.
-            device_name (str): Name of the device.
-
-        Returns:
-            list[str | tuple]: A list of filtered signals based on the kind.
-        """
-        handler_class = FilterIO._find_handler(widget)
-        if handler_class:
-            return handler_class().update_with_kind(
-                kind=kind,
-                signal_filter=signal_filter,
-                device_info=device_info,
-                device_name=device_name,
-            )
-        raise ValueError(
-            f"No matching handler for widget type: {type(widget)} in handler list {FilterIO._handlers}"
-        )
-
-    @staticmethod
-    def _find_handler(widget):
-        """
-        Find the appropriate handler for the widget by checking its base classes.
-
-        Args:
-            widget: Widget instance.
-
-        Returns:
-            handler_class: The handler class if found, otherwise None.
-        """
-        for base in type(widget).__mro__:
-            if base in FilterIO._handlers:
-                return FilterIO._handlers[base]
-        return None

bec_widgets/utils/forms_from_types/forms.py

@@ -1,282 +0,0 @@
-from __future__ import annotations
-
-from types import NoneType
-from typing import NamedTuple
-
-from bec_lib.logger import bec_logger
-from bec_qthemes import material_icon
-from pydantic import BaseModel, ValidationError
-from qtpy.QtCore import Signal  # type: ignore
-from qtpy.QtWidgets import QApplication, QGridLayout, QLabel, QSizePolicy, QVBoxLayout, QWidget
-
-from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.compact_popup import CompactPopupWidget
-from bec_widgets.utils.error_popups import SafeProperty
-from bec_widgets.utils.forms_from_types import styles
-from bec_widgets.utils.forms_from_types.items import (
-    DynamicFormItem,
-    DynamicFormItemType,
-    FormItemSpec,
-    widget_from_type,
-)
-
-logger = bec_logger.logger
-
-
-class GridRow(NamedTuple):
-    i: int
-    label: QLabel
-    widget: DynamicFormItem
-
-
-class TypedForm(BECWidget, QWidget):
-    PLUGIN = True
-    ICON_NAME = "list_alt"
-
-    value_changed = Signal()
-
-    RPC = True
-    USER_ACCESS = ["enabled", "enabled.setter"]
-
-    def __init__(
-        self,
-        parent=None,
-        items: list[tuple[str, type]] | None = None,
-        form_item_specs: list[FormItemSpec] | None = None,
-        enabled: bool = True,
-        pretty_display: bool = False,
-        client=None,
-        **kwargs,
-    ):
-        """Widget with a list of form items based on a list of types.
-
-        Args:
-            items (list[tuple[str, type]]):         list of tuples of a name for the field and its type.
-                                                    Should be a type supported by the logic in items.py
-            form_item_specs (list[FormItemSpec]):   list of form item specs, equivalent to items.
-                                                    only one of items or form_item_specs should be
-                                                    supplied.
-            enabled (bool, optional):               whether fields are enabled for editing.
-            pretty_display (bool, optional): Whether to use a pretty display for the widget. Defaults to False. If True, disables the widget, doesn't add a clear button, and adapts the stylesheet for non-editable display.
-        """
-        if items is not None and form_item_specs is not None:
-            logger.error(
-                "Must specify one and only one of items and form_item_specs! Ignoring `items`."
-            )
-            items = None
-        if items is None and form_item_specs is None:
-            logger.error("Must specify one and only one of items and form_item_specs!")
-            items = []
-        super().__init__(parent=parent, client=client, **kwargs)
-        self._items = form_item_specs or [
-            FormItemSpec(name=name, item_type=item_type, pretty_display=pretty_display)
-            for name, item_type in items  # type: ignore
-        ]
-        self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)
-        self._layout = QVBoxLayout()
-        self._layout.setContentsMargins(0, 0, 0, 0)
-        self.setLayout(self._layout)
-
-        self._enabled: bool = enabled
-
-        self._form_grid_container = QWidget(parent=self)
-        self._form_grid_container.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)
-        self._form_grid = QWidget(parent=self._form_grid_container)
-        self._form_grid.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)
-        self._layout.addWidget(self._form_grid_container)
-        self._form_grid_container.setLayout(QVBoxLayout())
-        self._form_grid.setLayout(self._new_grid_layout())
-
-        self._widget_types: dict | None = None
-        self._widget_from_type = widget_from_type
-        self._post_init()
-
-    def _post_init(self):
-        """Override this if a subclass should do things after super().__init__ and before populate()"""
-        self.populate()
-        self.enabled = self._enabled  # type: ignore # QProperty
-
-    def populate(self):
-        self._clear_grid()
-        for r, item in enumerate(self._items):
-            self._add_griditem(item, r)
-        gl: QGridLayout = self._form_grid.layout()
-        gl.setRowStretch(gl.rowCount(), 1)
-
-    def _add_griditem(self, item: FormItemSpec, row: int):
-        grid = self._form_grid.layout()
-        label = QLabel(item.name)
-        label.setProperty("_model_field_name", item.name)
-        label.setToolTip(item.info.description or item.name)
-        grid.addWidget(label, row, 0)
-        widget = self._widget_from_type(item, self._widget_types)(parent=self, spec=item)
-        widget.valueChanged.connect(self.value_changed)
-        widget.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)
-        grid.addWidget(widget, row, 1)
-
-    def enumerate_form_widgets(self):
-        """Return a generator over the rows of the form, with the row number, the label widget (to
-        which the field name is attached as a property "_model_field_name"), and the entry widget"""
-        grid: QGridLayout = self._form_grid.layout()  # type: ignore
-        for i in range(grid.rowCount() - 1):  # One extra row for stretch
-            yield GridRow(i, grid.itemAtPosition(i, 0).widget(), grid.itemAtPosition(i, 1).widget())
-
-    def _dict_from_grid(self) -> dict[str, DynamicFormItemType]:
-        return {
-            row.label.property("_model_field_name"): row.widget.getValue()
-            for row in self.enumerate_form_widgets()
-        }
-
-    def _clear_grid(self):
-        if (old_layout := self._form_grid.layout()) is not None:
-            while old_layout.count():
-                item = old_layout.takeAt(0)
-                widget = item.widget()
-                if widget is not None:
-                    widget.deleteLater()
-            old_layout.deleteLater()
-            self._form_grid.deleteLater()
-        self._form_grid = QWidget()
-        self._form_grid.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)
-        self._form_grid.setLayout(self._new_grid_layout())
-        self._form_grid_container.layout().addWidget(self._form_grid)
-
-        self.update_size()
-
-    def update_size(self):
-        self._form_grid.adjustSize()
-        self._form_grid_container.adjustSize()
-        self.adjustSize()
-
-    def _new_grid_layout(self):
-        new_grid = QGridLayout()
-        new_grid.setContentsMargins(0, 0, 0, 0)
-        return new_grid
-
-    @property
-    def widget_dict(self):
-        return {
-            row.label.property("_model_field_name"): row.widget
-            for row in self.enumerate_form_widgets()
-        }
-
-    @SafeProperty(bool)
-    def enabled(self):
-        return self._enabled
-
-    @enabled.setter
-    def enabled(self, value: bool):
-        self._enabled = value
-        self.setEnabled(value)
-
-
-class PydanticModelForm(TypedForm):
-    form_data_updated = Signal(dict)
-    form_data_cleared = Signal(NoneType)
-    validity_proc = Signal(bool)
-
-    def __init__(
-        self,
-        parent=None,
-        data_model: type[BaseModel] | None = None,
-        enabled: bool = True,
-        pretty_display: bool = False,
-        client=None,
-        **kwargs,
-    ):
-        """
-        A form generated from a pydantic model.
-
-        Args:
-            data_model (type[BaseModel]): the model class for which to generate a form.
-            enabled (bool, optional): whether fields are enabled for editing.
-            pretty_display (bool, optional): Whether to use a pretty display for the widget. Defaults to False. If True, disables the widget, doesn't add a clear button, and adapts the stylesheet for non-editable display.
-
-        """
-        self._pretty_display = pretty_display
-        self._md_schema = data_model
-        super().__init__(
-            parent=parent,
-            form_item_specs=self._form_item_specs(),
-            enabled=enabled,
-            client=client,
-            **kwargs,
-        )
-
-        self._validity = CompactPopupWidget()
-        self._validity.compact_view = True  # type: ignore
-        self._validity.label = "Validity"  # type: ignore
-        self._validity.compact_show_popup.setIcon(
-            material_icon(icon_name="info", size=(10, 10), convert_to_pixmap=False)
-        )
-        self._validity_message = QLabel("Not yet validated")
-        self._validity.addWidget(self._validity_message)
-        self._layout.addWidget(self._validity)
-        self.value_changed.connect(self.validate_form)
-
-        self._connect_to_theme_change()
-
-    def set_pretty_display_theme(self, theme: str = "dark"):
-        if self._pretty_display:
-            self.setStyleSheet(styles.pretty_display_theme(theme))
-
-    def _connect_to_theme_change(self):
-        """Connect to the theme change signal."""
-        qapp = QApplication.instance()
-        if hasattr(qapp, "theme_signal"):
-            qapp.theme_signal.theme_updated.connect(self.set_pretty_display_theme)  # type: ignore
-
-    def set_schema(self, schema: type[BaseModel]):
-        self._md_schema = schema
-        self.populate()
-
-    def set_data(self, data: BaseModel):
-        """Fill the data for the form.
-
-        Args:
-            data (BaseModel):   the data to enter into the form. Must be the same type as the
-                                currently set schema, raises TypeError otherwise."""
-        if not self._md_schema:
-            raise ValueError("Schema not set - can't set data")
-        if not isinstance(data, self._md_schema):
-            raise TypeError(f"Supplied data {data} not of type {self._md_schema}")
-        for form_item in self.enumerate_form_widgets():
-            form_item.widget.setValue(getattr(data, form_item.label.property("_model_field_name")))
-
-    def _form_item_specs(self):
-        return [
-            FormItemSpec(
-                name=name, info=info, item_type=info.annotation, pretty_display=self._pretty_display
-            )
-            for name, info in self._md_schema.model_fields.items()
-        ]
-
-    def update_items_from_schema(self):
-        self._items = self._form_item_specs()
-
-    def populate(self):
-        self.update_items_from_schema()
-        super().populate()
-
-    def get_form_data(self):
-        """Get the entered metadata as a dict."""
-        return self._dict_from_grid()
-
-    def validate_form(self, *_) -> bool:
-        """validate the currently entered metadata against the pydantic schema.
-        If successful, returns on metadata_emitted and returns true.
-        Otherwise, emits on form_data_cleared and returns false."""
-        try:
-            metadata_dict = self.get_form_data()
-            self._md_schema.model_validate(metadata_dict)
-            self._validity.set_global_state("success")
-            self._validity_message.setText("No errors!")
-            self.form_data_updated.emit(metadata_dict)
-            self.validity_proc.emit(True)
-            return True
-        except ValidationError as e:
-            self._validity.set_global_state("emergency")
-            self._validity_message.setText(str(e))
-            self.form_data_cleared.emit(None)
-            self.validity_proc.emit(False)
-            return False

bec_widgets/utils/forms_from_types/items.py

@@ -1,636 +0,0 @@
-from __future__ import annotations
-
-import typing
-from abc import abstractmethod
-from decimal import Decimal
-from types import GenericAlias, UnionType
-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
-from pydantic import BaseModel, ConfigDict, Field, field_validator
-from pydantic.fields import FieldInfo
-from pydantic_core import PydanticUndefined
-from qtpy import QtCore
-from qtpy.QtCore import QSize, Qt, Signal  # type: ignore
-from qtpy.QtGui import QFontMetrics
-from qtpy.QtWidgets import (
-    QApplication,
-    QButtonGroup,
-    QCheckBox,
-    QComboBox,
-    QDoubleSpinBox,
-    QGridLayout,
-    QHBoxLayout,
-    QLabel,
-    QLayout,
-    QLineEdit,
-    QListWidget,
-    QListWidgetItem,
-    QPushButton,
-    QRadioButton,
-    QSizePolicy,
-    QSpinBox,
-    QToolButton,
-    QVBoxLayout,
-    QWidget,
-)
-
-from bec_widgets.utils.error_popups import SafeSlot
-from bec_widgets.utils.widget_io import WidgetIO
-from bec_widgets.widgets.editors.dict_backed_table import DictBackedTable
-from bec_widgets.widgets.editors.scan_metadata._util import (
-    clearable_required,
-    field_default,
-    field_limits,
-    field_maxlen,
-    field_minlen,
-    field_precision,
-)
-from bec_widgets.widgets.utility.toggle.toggle import ToggleSwitch
-
-logger = bec_logger.logger
-
-
-class FormItemSpec(BaseModel):
-    """
-    The specification for an item in a dynamically generated form. Uses a pydantic FieldInfo
-    to store most annotation info, since one of the main purposes is to store data for
-    forms genrated from pydantic models, but can also be composed from other sources or by hand.
-    """
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    item_type: type | UnionType | GenericAlias
-    name: str
-    info: FieldInfo = FieldInfo()
-    pretty_display: bool = Field(
-        default=False,
-        description="Whether to use a pretty display for the widget. Defaults to False. If True, disables the widget, doesn't add a clear button, and adapts the stylesheet for non-editable display.",
-    )
-
-    @field_validator("item_type", mode="before")
-    @classmethod
-    def _validate_type(cls, v):
-        allowed_primitives = [str, int, float, bool]
-        if isinstance(v, (type, UnionType)):
-            return v
-        if isinstance(v, GenericAlias):
-            if v.__origin__ in [list, dict, set] and all(
-                arg in allowed_primitives for arg in v.__args__
-            ):
-                return v
-            raise ValueError(
-                f"Generics of type {v} are not supported - only lists, dicts and sets of primitive types {allowed_primitives}"
-            )
-        if type(v) is type(Literal[""]):  # _LiteralGenericAlias is not exported from typing
-            arg_types = set(type(arg) for arg in v.__args__)
-            if len(arg_types) != 1:
-                raise ValueError("Mixtures of literal types are not supported!")
-            if (t := arg_types.pop()) in allowed_primitives:
-                return t
-            raise ValueError(f"Literals of type {t} are not supported")
-
-
-class ClearableBoolEntry(QWidget):
-    stateChanged = Signal()
-
-    def __init__(self, parent: QWidget | None = None) -> None:
-        super().__init__(parent)
-        self._layout = QHBoxLayout()
-        self._layout.setContentsMargins(0, 0, 0, 0)
-        self.setLayout(self._layout)
-        self._layout.setSizeConstraint(QLayout.SizeConstraint.SetFixedSize)
-        self._entry = QButtonGroup()
-        self._true = QRadioButton("true", parent=self)
-        self._false = QRadioButton("false", parent=self)
-        for button in [self._true, self._false]:
-            self._layout.addWidget(button)
-            self._entry.addButton(button)
-            button.toggled.connect(self.stateChanged)
-
-    def clear(self):
-        self._entry.setExclusive(False)
-        self._true.setChecked(False)
-        self._false.setChecked(False)
-        self._entry.setExclusive(True)
-
-    def isChecked(self) -> bool | None:
-        if not self._true.isChecked() and not self._false.isChecked():
-            return None
-        return self._true.isChecked()
-
-    def setChecked(self, value: bool | None):
-        if value is None:
-            self.clear()
-        elif value:
-            self._true.setChecked(True)
-            self._false.setChecked(False)
-        else:
-            self._true.setChecked(False)
-            self._false.setChecked(True)
-
-    def setToolTip(self, tooltip: str):
-        self._true.setToolTip(tooltip)
-        self._false.setToolTip(tooltip)
-
-
-DynamicFormItemType = str | int | float | Decimal | bool | dict | list | None
-
-
-class DynamicFormItem(QWidget):
-    valueChanged = Signal()
-
-    def __init__(self, parent: QWidget | None = None, *, spec: FormItemSpec) -> None:
-        """
-        Initializes the form item widget.
-
-        Args:
-            parent (QWidget | None, optional): The parent widget. Defaults to None.
-            spec (FormItemSpec): The specification for the form item.
-        """
-        super().__init__(parent)
-        self._spec = spec
-        self._layout = QHBoxLayout()
-        self._layout.setContentsMargins(0, 0, 0, 0)
-        self._layout.setSizeConstraint(QLayout.SizeConstraint.SetMaximumSize)
-        self._default = field_default(self._spec.info)
-        self._desc = self._spec.info.description
-        self.setLayout(self._layout)
-        self._add_main_widget()
-        assert isinstance(self._main_widget, QWidget), "Please set a widget in _add_main_widget()"  # type: ignore
-        self._main_widget.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
-        self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
-        if not spec.pretty_display:
-            if clearable_required(spec.info):
-                self._add_clear_button()
-        else:
-            self._set_pretty_display()
-
-    @abstractmethod
-    def getValue(self) -> DynamicFormItemType: ...
-
-    @abstractmethod
-    def setValue(self, value): ...
-
-    @abstractmethod
-    def _add_main_widget(self) -> None:
-        """Add the main data entry widget to self._main_widget and appply any
-        constraints from the field info"""
-
-    def _set_pretty_display(self):
-        self.setEnabled(False)
-        if button := getattr(self, "_clear_button", None):
-            button.setVisible(False)
-
-    def _describe(self, pad=" "):
-        return pad + (self._desc if self._desc else "")
-
-    def _add_clear_button(self):
-        self._clear_button = QToolButton()
-        self._clear_button.setIcon(
-            material_icon(icon_name="close", size=(10, 10), convert_to_pixmap=False)
-        )
-        self._layout.addWidget(self._clear_button)
-        # the widget added in _add_main_widget must implement .clear() if value is not required
-        self._clear_button.setToolTip("Clear value or reset to default.")
-        self._clear_button.clicked.connect(self._main_widget.clear)  # type: ignore
-
-    def _value_changed(self, *_, **__):
-        self.valueChanged.emit()
-
-
-class StrFormItem(DynamicFormItem):
-    def __init__(self, parent: QWidget | None = None, *, spec: FormItemSpec) -> None:
-        super().__init__(parent=parent, spec=spec)
-        self._main_widget.textChanged.connect(self._value_changed)
-
-    def _add_main_widget(self) -> None:
-        self._main_widget = QLineEdit()
-        self._layout.addWidget(self._main_widget)
-        min_length, max_length = (field_minlen(self._spec.info), field_maxlen(self._spec.info))
-        if max_length:
-            self._main_widget.setMaxLength(max_length)
-        self._main_widget.setToolTip(
-            f"(length min: {min_length} max: {max_length}){self._describe()}"
-        )
-        if self._default:
-            self._main_widget.setText(self._default)
-            self._add_clear_button()
-
-    def getValue(self):
-        if self._main_widget.text() == "":
-            return self._default
-        return self._main_widget.text()
-
-    def setValue(self, value: str):
-        if value is None:
-            return self._main_widget.setText("")
-        self._main_widget.setText(str(value))
-
-
-class IntFormItem(DynamicFormItem):
-    def __init__(self, parent: QWidget | None = None, *, spec: FormItemSpec) -> None:
-        super().__init__(parent=parent, spec=spec)
-        self._main_widget.textChanged.connect(self._value_changed)
-
-    def _add_main_widget(self) -> None:
-        self._main_widget = QSpinBox()
-        self._layout.addWidget(self._main_widget)
-        min_, max_ = field_limits(self._spec.info, int)
-        self._main_widget.setMinimum(min_)
-        self._main_widget.setMaximum(max_)
-        self._main_widget.setToolTip(f"(range {min_} to {max_}){self._describe()}")
-        if self._default is not None:
-            self._main_widget.setValue(self._default)
-            self._add_clear_button()
-        else:
-            self._main_widget.clear()
-
-    def getValue(self):
-        if self._main_widget.text() == "":
-            return self._default
-        return self._main_widget.value()
-
-    def setValue(self, value: int):
-        if value is None:
-            self._main_widget.clear()
-        self._main_widget.setValue(value)
-
-
-class FloatDecimalFormItem(DynamicFormItem):
-    def __init__(self, parent: QWidget | None = None, *, spec: FormItemSpec) -> None:
-        super().__init__(parent=parent, spec=spec)
-        self._main_widget.textChanged.connect(self._value_changed)
-
-    def _add_main_widget(self) -> None:
-        precision = field_precision(self._spec.info)
-        self._main_widget = QDoubleSpinBox()
-        self._layout.addWidget(self._main_widget)
-        min_, max_ = field_limits(self._spec.info, float, precision)
-        self._main_widget.setMinimum(min_)
-        self._main_widget.setMaximum(max_)
-        if precision:
-            self._main_widget.setDecimals(precision)
-        minstr = f"{float(min_):.3f}" if abs(min_) <= 1000 else f"{float(min_):.3e}"
-        maxstr = f"{float(max_):.3f}" if abs(max_) <= 1000 else f"{float(max_):.3e}"
-        self._main_widget.setToolTip(f"(range {minstr} to {maxstr}){self._describe()}")
-        if self._default is not None:
-            self._main_widget.setValue(self._default)
-            self._add_clear_button()
-        else:
-            self._main_widget.clear()
-
-    def getValue(self):
-        if self._main_widget.text() == "":
-            return self._default
-        return self._main_widget.value()
-
-    def setValue(self, value: float | Decimal):
-        if value is None:
-            self._main_widget.clear()
-        self._main_widget.setValue(float(value))
-
-
-class BoolFormItem(DynamicFormItem):
-    def __init__(self, *, parent: QWidget | None = None, spec: FormItemSpec) -> None:
-        super().__init__(parent=parent, spec=spec)
-        self._main_widget.stateChanged.connect(self._value_changed)
-
-    def _add_main_widget(self) -> None:
-        if clearable_required(self._spec.info):
-            self._main_widget = ClearableBoolEntry()
-        else:
-            self._main_widget = QCheckBox()
-        self._layout.addWidget(self._main_widget)
-        self._main_widget.setToolTip(self._describe(""))
-        self._main_widget.setChecked(self._default)  # type: ignore # if there is no default then it will be ClearableBoolEntry and can be set with None
-
-    def getValue(self):
-        return self._main_widget.isChecked()
-
-    def setValue(self, value):
-        self._main_widget.setChecked(value)
-
-
-class BoolToggleFormItem(BoolFormItem):
-    def __init__(self, *, parent: QWidget | None = None, spec: FormItemSpec) -> None:
-        if spec.info.default is PydanticUndefined:
-            spec.info.default = False
-        super().__init__(parent=parent, spec=spec)
-
-    def _add_main_widget(self) -> None:
-        self._main_widget = ToggleSwitch()
-        self._layout.addWidget(self._main_widget)
-        self._main_widget.setToolTip(self._describe(""))
-        if self._default is not None:
-            self._main_widget.setChecked(self._default)
-
-
-class DictFormItem(DynamicFormItem):
-    def __init__(self, *, parent: QWidget | None = None, spec: FormItemSpec) -> None:
-        super().__init__(parent=parent, spec=spec)
-        self._main_widget.data_changed.connect(self._value_changed)
-        if spec.info.default is not PydanticUndefined:
-            self._main_widget.set_default(spec.info.default)
-
-    def _set_pretty_display(self):
-        self._main_widget.set_button_visibility(False)
-        super()._set_pretty_display()
-
-    def _add_main_widget(self) -> None:
-        self._main_widget = DictBackedTable(self, [])
-        self._layout.addWidget(self._main_widget)
-        self._main_widget.setToolTip(self._describe(""))
-
-    def getValue(self):
-        return self._main_widget.dump_dict()
-
-    def setValue(self, value):
-        self._main_widget.replace_data(value)
-
-
-_IW = TypeVar("_IW", bound=int | float | str)
-
-
-class _ItemAndWidgetType(NamedTuple, Generic[_IW]):
-    item: type[_IW]
-    widget: type[QWidget]
-    default: _IW
-
-
-class ListFormItem(DynamicFormItem):
-    def __init__(self, *, parent: QWidget | None = None, spec: FormItemSpec) -> None:
-        if spec.info.annotation is list:
-            self._types = _ItemAndWidgetType(str, QLineEdit, "")
-        elif isinstance(spec.info.annotation, GenericAlias):
-            args = set(typing.get_args(spec.info.annotation))
-            if args == {str}:
-                self._types = _ItemAndWidgetType(str, QLineEdit, "")
-            if args == {int}:
-                self._types = _ItemAndWidgetType(int, QSpinBox, 0)
-            if args == {float} or args == {int, float}:
-                self._types = _ItemAndWidgetType(float, QDoubleSpinBox, 0.0)
-        else:
-            self._types = _ItemAndWidgetType(str, QLineEdit, "")
-        super().__init__(parent=parent, spec=spec)
-        self.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
-        self._main_widget: QListWidget
-        self._data = []
-        self._min_lines = 2 if spec.pretty_display else 4
-        self._repop(self._data)
-
-    def sizeHint(self):
-        default = super().sizeHint()
-        return QSize(default.width(), QFontMetrics(self.font()).height() * 6)
-
-    def _add_main_widget(self) -> None:
-        self._main_widget = QListWidget()
-        self._layout.addWidget(self._main_widget)
-        self._layout.setAlignment(Qt.AlignmentFlag.AlignTop)
-        self._add_buttons()
-
-    def _add_buttons(self):
-        self._button_holder = QWidget()
-        self._button_holder.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
-        self._buttons = QVBoxLayout()
-        self._buttons.setContentsMargins(0, 0, 0, 0)
-        self._button_holder.setLayout(self._buttons)
-        self._layout.addWidget(self._button_holder)
-
-        self._add_remove_button_holder = QWidget()
-        self._add_remove_button_layout = QHBoxLayout()
-        self._add_remove_button_layout.setContentsMargins(0, 0, 0, 0)
-        self._add_remove_button_holder.setLayout(self._add_remove_button_layout)
-
-        self._add_button = QPushButton("+")
-        self._add_button.setMinimumHeight(15)
-        self._add_button.setToolTip("add a new row")
-        self._remove_button = QPushButton("-")
-        self._remove_button.setMinimumHeight(15)
-        self._remove_button.setToolTip("delete the focused row (if any)")
-        self._add_button.clicked.connect(self._add_row)
-        self._remove_button.clicked.connect(self._delete_row)
-
-        self._buttons.addWidget(self._add_remove_button_holder)
-        self._add_remove_button_layout.addWidget(self._add_button)
-        self._add_remove_button_layout.addWidget(self._remove_button)
-
-    def _set_pretty_display(self):
-        super()._set_pretty_display()
-        self._button_holder.setHidden(True)
-
-    def _repop(self, data):
-        self._main_widget.clear()
-        for val in data:
-            self._add_list_item(val)
-        self.scale_to_data()
-
-    def _add_data_item(self, val=None):
-        val = val or self._types.default
-        self._data.append(val)
-        self._add_list_item(val)
-        self._repop(self._data)
-
-    def _add_list_item(self, val):
-        item = QListWidgetItem(self._main_widget)
-        item.setFlags(item.flags() | QtCore.Qt.ItemIsEditable | QtCore.Qt.ItemIsEditable)
-        item_widget = self._types.widget(parent=self)
-        WidgetIO.set_value(item_widget, val)
-        self._main_widget.setItemWidget(item, item_widget)
-        self._main_widget.addItem(item)
-        WidgetIO.connect_widget_change_signal(item_widget, self._update)
-        return item_widget
-
-    def _update(self, _, value, *args):
-        self._data[self._main_widget.currentRow()] = value
-
-    @SafeSlot()
-    def _add_row(self):
-        self._add_data_item(self._types.default)
-        self._repop(self._data)
-
-    @SafeSlot()
-    def _delete_row(self):
-        if selected := self._main_widget.currentItem():
-            self._main_widget.removeItemWidget(selected)
-            row = self._main_widget.currentRow()
-            self._main_widget.takeItem(row)
-            self._data.pop(row)
-        self._repop(self._data)
-
-    @SafeSlot()
-    def clear(self):
-        self._repop([])
-
-    def getValue(self):
-        return self._data
-
-    def setValue(self, value: Iterable):
-        if set(map(type, value)) | {self._types.item} != {self._types.item}:
-            raise ValueError(f"This widget only accepts items of type {self._types.item}")
-        self._data = list(value)
-        self._repop(self._data)
-
-    def _line_height(self):
-        return QFontMetrics(self._main_widget.font()).height()
-
-    def set_max_height_in_lines(self, lines: int):
-        outer_inc = 1 if self._spec.pretty_display else 3
-        self._main_widget.setFixedHeight(self._line_height() * max(lines, self._min_lines))
-        self._button_holder.setFixedHeight(self._line_height() * (max(lines, self._min_lines) + 1))
-        self.setFixedHeight(self._line_height() * (max(lines, self._min_lines) + outer_inc))
-
-    def scale_to_data(self, *_):
-        self.set_max_height_in_lines(self._main_widget.count() + 1)
-
-
-class SetFormItem(ListFormItem):
-    def _add_main_widget(self) -> None:
-        super()._add_main_widget()
-        self._add_item_field = self._types.widget()
-        self._buttons.addWidget(QLabel("Add new:"))
-        self._buttons.addWidget(self._add_item_field)
-        self.setSizePolicy(QSizePolicy.Policy.MinimumExpanding, QSizePolicy.Policy.Minimum)
-
-    @SafeSlot()
-    def _add_row(self):
-        self._add_data_item(WidgetIO.get_value(self._add_item_field))
-        self._repop(self._data)
-
-    def _update(self, _, value, *args):
-        if value in self._data:
-            return
-        return super()._update(_, value, *args)
-
-    def _add_data_item(self, val=None):
-        val = val or self._types.default
-        if val == self._types.default or val in self._data:
-            return
-        self._data.append(val)
-        self._add_list_item(val)
-
-    def _add_list_item(self, val):
-        item_widget = super()._add_list_item(val)
-        if isinstance(item_widget, QLineEdit):
-            item_widget.setReadOnly(True)
-        return item_widget
-
-    def getValue(self):
-        return set(self._data)
-
-    def setValue(self, value: set):
-        return super().setValue(set(value))
-
-
-class StrLiteralFormItem(DynamicFormItem):
-    def _add_main_widget(self) -> None:
-        self._main_widget = QComboBox()
-        self._options = get_args(self._spec.info.annotation)
-        for opt in self._options:
-            self._main_widget.addItem(opt)
-        self._layout.addWidget(self._main_widget)
-
-    def getValue(self):
-        return self._main_widget.currentText()
-
-    def setValue(self, value: str | None):
-        if value is None:
-            self.clear()
-        for i in range(self._main_widget.count()):
-            if self._main_widget.itemText(i) == value:
-                self._main_widget.setCurrentIndex(i)
-                return
-        raise ValueError(f"Cannot set value: {value}, options are: {self._options}")
-
-    def clear(self):
-        self._main_widget.setCurrentIndex(-1)
-
-
-WidgetTypeRegistry = OrderedDict[str, tuple[Callable[[FormItemSpec], bool], type[DynamicFormItem]]]
-
-DEFAULT_WIDGET_TYPES: Final[WidgetTypeRegistry] = OrderedDict() | {
-    # dict literals are ordered already but TypedForm subclasses may modify coppies of this dict
-    # and delete/insert keys or change the order
-    "literal_str": (
-        lambda spec: type(spec.info.annotation) is type(Literal[""])
-        and set(type(arg) for arg in get_args(spec.info.annotation)) == {str},
-        StrLiteralFormItem,
-    ),
-    "str": (lambda spec: spec.item_type in [str, str | None, None], StrFormItem),
-    "int": (lambda spec: spec.item_type in [int, int | None], IntFormItem),
-    "float_decimal": (
-        lambda spec: spec.item_type in [float, float | None, Decimal, Decimal | None],
-        FloatDecimalFormItem,
-    ),
-    "bool": (lambda spec: spec.item_type in [bool, bool | None], BoolFormItem),
-    "dict": (
-        lambda spec: spec.item_type in [dict, dict | None]
-        or (isinstance(spec.item_type, GenericAlias) and spec.item_type.__origin__ is dict),
-        DictFormItem,
-    ),
-    "list": (
-        lambda spec: spec.item_type in [list, list | None]
-        or (isinstance(spec.item_type, GenericAlias) and spec.item_type.__origin__ is list),
-        ListFormItem,
-    ),
-    "set": (
-        lambda spec: spec.item_type in [set, set | None]
-        or (isinstance(spec.item_type, GenericAlias) and spec.item_type.__origin__ is set),
-        SetFormItem,
-    ),
-}
-
-
-def widget_from_type(
-    spec: FormItemSpec, widget_types: WidgetTypeRegistry | None = None
-) -> type[DynamicFormItem]:
-    widget_types = widget_types or DEFAULT_WIDGET_TYPES
-    for predicate, widget_type in widget_types.values():
-        if predicate(spec):
-            return widget_type
-    logger.warning(
-        f"Type {spec.item_type=} / {spec.info.annotation=} is not (yet) supported in dynamic form creation."
-    )
-    return StrFormItem
-
-
-if __name__ == "__main__":  # pragma: no cover
-
-    class TestModel(BaseModel):
-        value0: set = Field(set(["a", "b"]))
-        value1: str | None = Field(None)
-        value2: bool | None = Field(None)
-        value3: bool = Field(True)
-        value4: int = Field(123)
-        value5: int | None = Field()
-        value6: list[int] = Field()
-        value7: list = Field()
-
-    app = QApplication([])
-    w = QWidget()
-    layout = QGridLayout()
-    w.setLayout(layout)
-    items = []
-    for i, (field_name, info) in enumerate(TestModel.model_fields.items()):
-        spec = spec = FormItemSpec(item_type=info.annotation, name=field_name, info=info)
-        layout.addWidget(QLabel(field_name), i, 0)
-        widg = widget_from_type(spec)(spec=spec)
-        items.append(widg)
-        layout.addWidget(widg, i, 1)
-
-    items[6].setValue([1, 2, 3, 4])
-    items[7].setValue(["1", "2", "asdfg", "qwerty"])
-
-    w.show()
-    app.exec()

bec_widgets/utils/forms_from_types/styles.py

@@ -1,21 +0,0 @@
-import bec_qthemes
-
-
-def pretty_display_theme(theme: str = "dark"):
-    palette = bec_qthemes.load_palette(theme)
-    foreground = palette.text().color().name()
-    background = palette.base().color().name()
-    border = palette.shadow().color().name()
-    accent = palette.accent().color().name()
-    return f"""
-QWidget {{color: {foreground}; background-color: {background}}}
-QLabel {{ font-weight: bold; }}
-QLineEdit,QLabel,QTreeView {{ border-style: solid; border-width: 2px; border-color: {border} }}
-QRadioButton {{ color: {foreground}; }}
-QRadioButton::indicator::checked {{ color: {accent}; }}
-QCheckBox {{ color: {accent}; }}
-"""
-
-
-if __name__ == "__main__":
-    print(pretty_display_theme())

bec_widgets/utils/fps_counter.py

@@ -1,84 +0,0 @@
-"""
-This module provides a utility class for counting and reporting frames per second (FPS) in a PyQtGraph application.
-
-Classes:
-    FPSCounter: A class that monitors the paint events of a `ViewBox` to calculate and emit FPS values.
-
-Usage:
-    The `FPSCounter` class can be used to monitor the rendering performance of a `ViewBox` in a PyQtGraph application.
-    It connects to the `ViewBox`'s paint event and calculates the FPS over a specified interval, emitting the FPS value
-    at regular intervals.
-
-Example:
-    from qtpy import QtWidgets, QtCore
-    import pyqtgraph as pg
-    from fps_counter import FPSCounter
-
-    app = pg.mkQApp("FPS Counter Example")
-    win = pg.GraphicsLayoutWidget()
-    win.show()
-
-    vb = pg.ViewBox()
-    plot_item = pg.PlotItem(viewBox=vb)
-    win.addItem(plot_item)
-
-    fps_counter = FPSCounter(vb)
-    fps_counter.sigFpsUpdate.connect(lambda fps: print(f"FPS: {fps:.2f}"))
-
-    sys.exit(app.exec_())
-"""
-
-from time import perf_counter
-
-import pyqtgraph as pg
-from qtpy import QtCore
-
-
-class FPSCounter(QtCore.QObject):
-    """
-    A utility class for counting and reporting frames per second (FPS).
-
-    This class connects to a `ViewBox`'s paint event to count the number of
-    frames rendered and calculates the FPS over a specified interval. It emits
-    a signal with the FPS value at regular intervals.
-
-    Attributes:
-        sigFpsUpdate (QtCore.Signal): Signal emitted with the FPS value.
-        view_box (pg.ViewBox): The `ViewBox` instance to monitor.
-    """
-
-    sigFpsUpdate = QtCore.Signal(float)
-
-    def __init__(self, view_box):
-        super().__init__()
-        self.view_box = view_box
-        self.view_box.sigPaint.connect(self.increment_count)
-        self.count = 0
-        self.last_update = perf_counter()
-        self.timer = QtCore.QTimer()
-        self.timer.timeout.connect(self.calculate_fps)
-        self.timer.start(1000)
-
-    def increment_count(self):
-        """
-        Increment the frame count when the `ViewBox` is painted.
-        """
-        self.count += 1
-
-    def calculate_fps(self):
-        """
-        Calculate the frames per second (FPS) based on the number of frames
-        """
-        now = perf_counter()
-        elapsed = now - self.last_update
-        fps = self.count / elapsed if elapsed > 0 else 0.0
-        self.last_update = now
-        self.count = 0
-        self.sigFpsUpdate.emit(fps)
-
-    def cleanup(self):
-        """
-        Clean up the FPS counter by stopping the timer and disconnecting the signal.
-        """
-        self.timer.stop()
-        self.timer.timeout.disconnect(self.calculate_fps)

bec_widgets/utils/generate_designer_plugin.py

@@ -1,33 +1,17 @@
 import inspect
 import os
 import re
-from typing import NamedTuple
 
 from qtpy.QtCore import QObject
 
-from bec_widgets.utils.name_utils import pascal_to_snake
-
-EXCLUDED_PLUGINS = ["BECConnector", "BECDock"]
-_PARENT_ARG_REGEX = r".__init__\(\s*(?:parent\)|parent=parent,?|parent,?)"
-_SELF_PARENT_ARG_REGEX = r".__init__\(\s*self,\s*(?:parent\)|parent=parent,?|parent,?)"
-SUPER_INIT_REGEX = re.compile(r"super\(\)" + _PARENT_ARG_REGEX, re.MULTILINE)
-
-
-class PluginFilenames(NamedTuple):
-    register: str
-    plugin: str
-    pyproj: str
-
-
-def plugin_filenames(name: str) -> PluginFilenames:
-    return PluginFilenames(f"register_{name}.py", f"{name}_plugin.py", f"{name}.pyproject")
+EXCLUDED_PLUGINS = ["BECConnector", "BECDockArea", "BECDock"]
 
 
 class DesignerPluginInfo:
     def __init__(self, plugin_class):
         self.plugin_class = plugin_class
         self.plugin_name_pascal = plugin_class.__name__
-        self.plugin_name_snake = pascal_to_snake(self.plugin_name_pascal)
+        self.plugin_name_snake = self.pascal_to_snake(self.plugin_name_pascal)
         self.widget_import = f"from {plugin_class.__module__} import {self.plugin_name_pascal}"
         plugin_module = (
             ".".join(plugin_class.__module__.split(".")[:-1]) + f".{self.plugin_name_snake}_plugin"
@@ -43,6 +27,21 @@ class DesignerPluginInfo:
 
         self.base_path = os.path.dirname(inspect.getfile(plugin_class))
 
+    @staticmethod
+    def pascal_to_snake(name: str) -> str:
+        """
+        Convert PascalCase to snake_case.
+
+        Args:
+            name (str): The name to be converted.
+
+        Returns:
+            str: The converted name.
+        """
+        s1 = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", name)
+        s2 = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", s1)
+        return s2.lower()
+
 
 class DesignerPluginGenerator:
     def __init__(self, widget: type):
@@ -54,21 +53,16 @@ class DesignerPluginGenerator:
             self._excluded = True
             return
 
-        self.templates: dict[str, str] = {}
+        self.templates = {}
         self.template_path = os.path.join(
             os.path.dirname(os.path.abspath(__file__)), "plugin_templates"
         )
 
-    @property
-    def filenames(self):
-        return plugin_filenames(self.info.plugin_name_snake)
-
-    def run(self, validate=True):
+    def run(self):
         if self._excluded:
             print(f"Plugin {self.widget.__name__} is excluded from generation.")
             return
-        if validate:
-            self._check_class_validity()
+        self._check_class_validity()
         self._load_templates()
         self._write_templates()
 
@@ -93,38 +87,50 @@ class DesignerPluginGenerator:
 
         # Check if the widget class calls the super constructor with parent argument
         init_source = inspect.getsource(self.widget.__init__)
-        class_re = re.compile(base_cls[0].__name__ + _SELF_PARENT_ARG_REGEX, re.MULTILINE)
-        cls_init_found = class_re.search(init_source) is not None
-        super_self_re = re.compile(
-            rf"super\({base_cls[0].__name__}, self\)" + _PARENT_ARG_REGEX, re.MULTILINE
+        cls_init_found = (
+            bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent=parent") > 0)
+            or bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent)") > 0)
+            or bool(init_source.find(f"{base_cls[0].__name__}.__init__(self, parent,") > 0)
+        )
+        super_init_found = (
+            bool(
+                init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent=parent") > 0
+            )
+            or bool(init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent,") > 0)
+            or bool(init_source.find(f"super({base_cls[0].__name__}, self).__init__(parent)") > 0)
         )
-        super_init_found = super_self_re.search(init_source) is not None
         if issubclass(self.widget.__bases__[0], QObject) and not super_init_found:
-            super_init_found = SUPER_INIT_REGEX.search(init_source) is not None
-
-        # for the new style classes, we only have one super call. We can therefore check if the
-        # number of __init__ calls is 2 (the class itself and the super class)
-        num_inits = re.findall(r"__init__", init_source)
-        if len(num_inits) == 2 and not super_init_found:
-            super_init_found = SUPER_INIT_REGEX.search(init_source) is not None
+            super_init_found = (
+                bool(init_source.find("super().__init__(parent=parent") > 0)
+                or bool(init_source.find("super().__init__(parent,") > 0)
+                or bool(init_source.find("super().__init__(parent)") > 0)
+            )
 
         if not cls_init_found and not super_init_found:
             raise ValueError(
                 f"Widget class {self.widget.__name__} must call the super constructor with parent."
             )
 
-    def _write_file(self, name: str, contents: str):
-        with open(os.path.join(self.info.base_path, name), "w", encoding="utf-8") as f:
-            f.write(contents)
-
-    def _format(self, name: str):
-        return self.templates[name].format(**self.info.__dict__)
-
     def _write_templates(self):
-        self._write_file(self.filenames.register, self._format("register"))
-        self._write_file(self.filenames.plugin, self._format("plugin"))
-        pyproj = str({"files": [f"{self.info.plugin_class.__module__.split('.')[-1]}.py"]})
-        self._write_file(self.filenames.pyproj, pyproj)
+        self._write_register()
+        self._write_plugin()
+        self._write_pyproject()
+
+    def _write_register(self):
+        file_path = os.path.join(self.info.base_path, f"register_{self.info.plugin_name_snake}.py")
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(self.templates["register"].format(**self.info.__dict__))
+
+    def _write_plugin(self):
+        file_path = os.path.join(self.info.base_path, f"{self.info.plugin_name_snake}_plugin.py")
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(self.templates["plugin"].format(**self.info.__dict__))
+
+    def _write_pyproject(self):
+        file_path = os.path.join(self.info.base_path, f"{self.info.plugin_name_snake}.pyproject")
+        out = {"files": [f"{self.info.plugin_class.__module__.split('.')[-1]}.py"]}
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write(str(out))
 
     def _load_templates(self):
         for file in os.listdir(self.template_path):
@@ -136,7 +142,7 @@ class DesignerPluginGenerator:
 
 if __name__ == "__main__":  # pragma: no cover
     # from bec_widgets.widgets.bec_queue.bec_queue import BECQueue
-    from bec_widgets.widgets.utility.spinner import SpinnerWidget
+    from bec_widgets.widgets.dock import BECDockArea
 
-    generator = DesignerPluginGenerator(SpinnerWidget)
-    generator.run(validate=False)
+    generator = DesignerPluginGenerator(BECDockArea)
+    generator.run()

bec_widgets/utils/linear_region_selector.py

@@ -1,86 +0,0 @@
-"""Module for a thin wrapper (LinearRegionWrapper) around the LinearRegionItem in pyqtgraph.
-The class is mainly designed for usage with the BECWaveform and 1D plots."""
-
-from __future__ import annotations
-
-import pyqtgraph as pg
-from qtpy.QtCore import QObject, Signal, Slot
-from qtpy.QtGui import QColor
-
-
-class LinearRegionWrapper(QObject):
-    """Wrapper class for the LinearRegionItem in pyqtgraph for 1D plots (BECWaveform)
-
-    Args:
-        plot_item (pg.PlotItem): The plot item to add the region selector to.
-        parent (QObject): The parent object.
-        color (QColor): The color of the region selector.
-        hover_color (QColor): The color of the region selector when the mouse is over it.
-    """
-
-    # Signal with the region tuble (start, end)
-    region_changed = Signal(tuple)
-
-    def __init__(
-        self, plot_item: pg.PlotItem, color: QColor = None, hover_color: QColor = None, parent=None
-    ):
-        super().__init__(parent)
-        self.is_log_x = None
-        self._edge_width = 2
-        self.plot_item = plot_item
-        self.linear_region_selector = pg.LinearRegionItem()
-        self.proxy = None
-        self.change_roi_color((color, hover_color))
-        self.plot_item.ctrl.logXCheck.checkStateChanged.connect(self.check_log)
-        self.plot_item.ctrl.logYCheck.checkStateChanged.connect(self.check_log)
-
-    # Slot for changing the color of the region selector (edge and fill)
-    @Slot(tuple)
-    def change_roi_color(self, colors: tuple[QColor | str | tuple, QColor | str | tuple]):
-        """Change the color and hover color of the region selector.
-        Hover color means the color when the mouse is over the region.
-
-        Args:
-            colors (tuple): Tuple with the color and hover color
-        """
-        color, hover_color = colors
-        if color is not None:
-            self.linear_region_selector.setBrush(pg.mkBrush(color))
-        if hover_color is not None:
-            self.linear_region_selector.setHoverBrush(pg.mkBrush(hover_color))
-
-    @Slot()
-    def add_region_selector(self):
-        """Add the region selector to the plot item"""
-        self.plot_item.addItem(self.linear_region_selector)
-        # Use proxy to limit the update rate of the region change signal to 10Hz
-        self.proxy = pg.SignalProxy(
-            self.linear_region_selector.sigRegionChanged,
-            rateLimit=10,
-            slot=self._region_change_proxy,
-        )
-
-    @Slot()
-    def remove_region_selector(self):
-        """Remove the region selector from the plot item"""
-        self.proxy.disconnect()
-        self.proxy = None
-        self.plot_item.removeItem(self.linear_region_selector)
-
-    def _region_change_proxy(self):
-        """Emit the region change signal. If the plot is in log mode, convert the region to log."""
-        x_low, x_high = self.linear_region_selector.getRegion()
-        if self.is_log_x:
-            x_low = 10**x_low
-            x_high = 10**x_high
-        self.region_changed.emit((x_low, x_high))
-
-    @Slot()
-    def check_log(self):
-        """Check if the plot is in log mode."""
-        self.is_log_x = self.plot_item.ctrl.logXCheck.isChecked()
-        self.is_log_y = self.plot_item.ctrl.logYCheck.isChecked()
-
-    def cleanup(self):
-        """Cleanup the widget."""
-        self.remove_region_selector()

bec_widgets/utils/name_utils.py

@@ -1,16 +0,0 @@
-import re
-
-
-def pascal_to_snake(name: str) -> str:
-    """
-    Convert PascalCase to snake_case.
-
-    Args:
-        name (str): The name to be converted.
-
-    Returns:
-        str: The converted name.
-    """
-    s1 = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", name)
-    s2 = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", s1)
-    return s2.lower()

bec_widgets/utils/ophyd_kind_util.py

@@ -1,26 +0,0 @@
-from enum import IntFlag
-
-try:
-
-    from enum import KEEP
-
-    class IFBase(IntFlag, boundary=KEEP): ...
-
-except ImportError:
-
-    IFBase = IntFlag
-
-
-class Kind(IFBase):
-    """
-    This is used in the .kind attribute of all OphydObj (Signals, Devices).
-
-    A Device examines its components' .kind atttribute to decide whether to
-    traverse it in read(), read_configuration(), or neither. Additionally, if
-    decides whether to include its name in `hints['fields']`.
-    """
-
-    omitted = 0b000
-    normal = 0b001
-    config = 0b010
-    hinted = 0b101  # Notice that bool(hinted & normal) is True.

bec_widgets/utils/palette_viewer.py

@@ -1,183 +0,0 @@
-from qtpy.QtCore import Qt
-from qtpy.QtWidgets import (
-    QApplication,
-    QFrame,
-    QGridLayout,
-    QHBoxLayout,
-    QLabel,
-    QScrollArea,
-    QSizePolicy,
-    QVBoxLayout,
-    QWidget,
-)
-
-from bec_widgets.utils.bec_widget import BECWidget
-from bec_widgets.utils.colors import get_accent_colors, get_theme_palette
-from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
-
-
-class PaletteViewer(BECWidget, QWidget):
-    """
-    This class is a widget that displays current palette colors.
-    """
-
-    ICON_NAME = "palette"
-    RPC = False
-
-    def __init__(self, *args, parent=None, **kwargs):
-        super().__init__(parent=parent, theme_update=True, **kwargs)
-        self.setFixedSize(400, 600)
-        layout = QVBoxLayout(self)
-        dark_mode_button = DarkModeButton(self)
-        layout.addWidget(dark_mode_button)
-
-        # Create a scroll area to hold the color boxes
-        scroll_area = QScrollArea(self)
-        scroll_area.setWidgetResizable(True)
-        scroll_area.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-
-        # Create a frame to hold the color boxes
-        self.frame = QFrame(self)
-        self.frame_layout = QGridLayout(self.frame)
-        self.frame_layout.setSpacing(0)
-        self.frame_layout.setContentsMargins(0, 0, 0, 0)
-
-        scroll_area.setWidget(self.frame)
-        layout.addWidget(scroll_area)
-
-        self.setLayout(layout)
-
-        self.update_palette()
-
-    def apply_theme(self, theme) -> None:
-        """
-        Apply the theme to the widget.
-
-        Args:
-            theme (str): The theme to apply.
-        """
-        self.update_palette()
-
-    def clear_palette(self) -> None:
-        """
-        Clear the palette colors from the frame.
-        Recursively removes all widgets and layouts in the frame layout.
-        """
-        # Iterate over all items in the layout in reverse to safely remove them
-        for i in reversed(range(self.frame_layout.count())):
-            item = self.frame_layout.itemAt(i)
-
-            # If the item is a layout, clear its contents
-            if isinstance(item, QHBoxLayout):
-                # Recursively remove all widgets from the layout
-                for j in reversed(range(item.count())):
-                    widget = item.itemAt(j).widget()
-                    if widget:
-                        item.removeWidget(widget)
-                        widget.deleteLater()
-                self.frame_layout.removeItem(item)
-
-            # If the item is a widget, remove and delete it
-            elif item.widget():
-                widget = item.widget()
-                self.frame_layout.removeWidget(widget)
-                widget.deleteLater()
-
-    def update_palette(self) -> None:
-        """
-        Update the palette colors in the frame.
-        """
-        self.clear_palette()
-        palette_label = QLabel("Palette Colors (e.g. palette.windowText().color())")
-        palette_label.setStyleSheet("font-weight: bold;")
-        self.frame_layout.addWidget(palette_label, 0, 0)
-
-        palette = get_theme_palette()
-        # Add the palette colors (roles) to the frame
-        palette_roles = [
-            palette.windowText,
-            palette.toolTipText,
-            palette.placeholderText,
-            palette.text,
-            palette.buttonText,
-            palette.highlight,
-            palette.link,
-            palette.light,
-            palette.midlight,
-            palette.mid,
-            palette.shadow,
-            palette.button,
-            palette.brightText,
-            palette.toolTipBase,
-            palette.alternateBase,
-            palette.dark,
-            palette.base,
-            palette.window,
-            palette.highlightedText,
-            palette.linkVisited,
-        ]
-
-        offset = 1
-        for i, pal in enumerate(palette_roles):
-            i += offset
-            color = pal().color()
-            label_layout = QHBoxLayout()
-            color_label = QLabel(f"{pal().color().name()} ({pal.__name__})")
-            background_label = self.background_label_with_clipboard(color)
-            label_layout.addWidget(color_label)
-            label_layout.addWidget(background_label)
-            self.frame_layout.addLayout(label_layout, i, 0)
-
-        # add a horizontal spacer
-        spacer = QLabel()
-        spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
-        self.frame_layout.addWidget(spacer, i + 1, 0)
-
-        accent_colors_label = QLabel("Accent Colors (e.g. accent_colors.default)")
-        accent_colors_label.setStyleSheet("font-weight: bold;")
-        self.frame_layout.addWidget(accent_colors_label, i + 2, 0)
-
-        accent_colors = get_accent_colors()
-        items = [
-            (accent_colors.default, "default"),
-            (accent_colors.success, "success"),
-            (accent_colors.warning, "warning"),
-            (accent_colors.emergency, "emergency"),
-            (accent_colors.highlight, "highlight"),
-        ]
-
-        offset = len(palette_roles) + 2
-        for i, (color, name) in enumerate(items):
-            i += offset
-            label_layout = QHBoxLayout()
-            color_label = QLabel(f"{color.name()} ({name})")
-            background_label = self.background_label_with_clipboard(color)
-            label_layout.addWidget(color_label)
-            label_layout.addWidget(background_label)
-            self.frame_layout.addLayout(label_layout, i + 2, 0)
-
-    def background_label_with_clipboard(self, color) -> QLabel:
-        """
-        Create a label with a background color that copies the color to the clipboard when clicked.
-
-        Args:
-            color (QColor): The color to display in the background.
-
-        Returns:
-            QLabel: The label with the background color.
-        """
-        button = QLabel()
-        button.setStyleSheet(f"QLabel {{ background-color: {color.name()}; }}")
-        button.setToolTip("Click to copy color to clipboard")
-        button.setCursor(Qt.PointingHandCursor)
-        button.mousePressEvent = lambda event: QApplication.clipboard().setText(color.name())
-        return button
-
-
-if __name__ == "__main__":  # pragma: no cover
-    import sys
-
-    app = QApplication(sys.argv)
-    viewer = PaletteViewer()
-    viewer.show()
-    sys.exit(app.exec_())

bec_widgets/utils/plot_indicator_items.py

@@ -1,244 +0,0 @@
-"""Module to create an arrow item for a pyqtgraph plot"""
-
-import numpy as np
-import pyqtgraph as pg
-from bec_lib.logger import bec_logger
-from qtpy.QtCore import QObject, QPointF, Signal, Slot
-
-from bec_widgets.utils.colors import get_accent_colors
-
-logger = bec_logger.logger
-
-
-class BECIndicatorItem(QObject):
-
-    def __init__(self, plot_item: pg.PlotItem = None, parent=None):
-        super().__init__(parent=parent)
-        self.accent_colors = get_accent_colors()
-        self.plot_item = plot_item
-        self._item_on_plot = False
-        self._pos = None
-        self.is_log_x = False
-        self.is_log_y = False
-
-    @property
-    def item_on_plot(self) -> bool:
-        """Returns if the item is on the plot"""
-        return self._item_on_plot
-
-    @item_on_plot.setter
-    def item_on_plot(self, value: bool) -> None:
-        self._item_on_plot = value
-
-    def add_to_plot(self) -> None:
-        """Add the item to the plot"""
-        raise NotImplementedError("Method add_to_plot not implemented")
-
-    def remove_from_plot(self) -> None:
-        """Remove the item from the plot"""
-        raise NotImplementedError("Method remove_from_plot not implemented")
-
-    def set_position(self, pos) -> None:
-        """This method should implement the logic to set the position of the
-        item on the plot. Depending on the child class, the position can be
-        a tuple (x,y) or a single value, i.e. x position where y position is fixed.
-        """
-        raise NotImplementedError("Method set_position not implemented")
-
-    def check_log(self):
-        """Checks if the x or y axis is in log scale and updates the internal state accordingly."""
-        self.is_log_x = self.plot_item.ctrl.logXCheck.isChecked()
-        self.is_log_y = self.plot_item.ctrl.logYCheck.isChecked()
-        self.set_position(self._pos)
-
-
-class BECTickItem(BECIndicatorItem):
-    """Class to create a tick item which can be added to a pyqtgraph plot.
-    The tick item will be added to the layout of the plot item and can be used to indicate
-    a position"""
-
-    position_changed = Signal(float)
-    position_changed_str = Signal(str)
-
-    def __init__(self, plot_item: pg.PlotItem = None, parent=None):
-        super().__init__(plot_item=plot_item, parent=parent)
-        self.tick_item = pg.TickSliderItem(
-            parent=parent, allowAdd=False, allowRemove=False, orientation="bottom"
-        )
-        self.tick_item.skip_auto_range = True
-        self.tick = None
-        self._pos = 0.0
-        self._range = [0, 1]
-
-    @Slot(float)
-    def set_position(self, pos: float) -> None:
-        """Set the x position of the tick item
-
-        Args:
-            pos (float): The position of the tick item.
-        """
-        if self.is_log_x is True:
-            pos = pos if pos > 0 else 1e-10
-            pos = np.log10(pos)
-        self._pos = pos
-        view_box = self.plot_item.getViewBox()  # Ensure you're accessing the correct view box
-        view_range = view_box.viewRange()[0]
-        self.update_range(self.plot_item.vb, view_range)
-        self.position_changed.emit(pos)
-        self.position_changed_str.emit(str(pos))
-
-    @Slot()
-    def update_range(self, _, view_range: tuple[float, float]) -> None:
-        """Update the range of the tick item
-
-        Args:
-            vb (pg.ViewBox): The view box.
-            viewRange (tuple): The view range.
-        """
-        if self._pos < view_range[0] or self._pos > view_range[1]:
-            self.tick_item.setVisible(False)
-        else:
-            self.tick_item.setVisible(True)
-
-        if self.tick_item.isVisible():
-            origin = self.tick_item.tickSize / 2.0
-            length = self.tick_item.length
-
-            length_with_padding = length + self.tick_item.tickSize + 2
-
-            self._range = view_range
-            tick_with_padding = (self._pos - view_range[0]) / (view_range[1] - view_range[0])
-            tick_value = (tick_with_padding * length_with_padding - origin) / length
-            self.tick_item.setTickValue(self.tick, tick_value)
-
-    def add_to_plot(self):
-        """Add the tick item to the view box or plot item."""
-        if self.plot_item is None:
-            return
-
-        self.plot_item.layout.addItem(self.tick_item, 2, 1)
-        self.tick_item.setOrientation("top")
-        self.tick = self.tick_item.addTick(0, movable=False, color=self.accent_colors.highlight)
-        self.update_tick_pos_y()
-        self.plot_item.vb.sigXRangeChanged.connect(self.update_range)
-        self.plot_item.ctrl.logXCheck.checkStateChanged.connect(self.check_log)
-        self.plot_item.ctrl.logYCheck.checkStateChanged.connect(self.check_log)
-        self.plot_item.vb.geometryChanged.connect(self.update_tick_pos_y)
-        self.item_on_plot = True
-
-    @Slot()
-    def update_tick_pos_y(self):
-        """Update tick position, while respecting the tick_item coordinates"""
-        pos = self.tick.pos()
-        pos = self.tick_item.mapToParent(pos)
-        new_pos = self.plot_item.vb.geometry().bottom()
-        new_pos = self.tick_item.mapFromParent(QPointF(pos.x(), new_pos))
-        self.tick.setPos(new_pos)
-
-    def remove_from_plot(self):
-        """Remove the tick item from the view box or plot item."""
-        if self.plot_item is not None and self.item_on_plot is True:
-            self.plot_item.vb.sigXRangeChanged.disconnect(self.update_range)
-            self.plot_item.ctrl.logXCheck.checkStateChanged.disconnect(self.check_log)
-            self.plot_item.ctrl.logYCheck.checkStateChanged.disconnect(self.check_log)
-            if self.plot_item.layout is not None:
-                self.plot_item.layout.removeItem(self.tick_item)
-        self.item_on_plot = False
-
-    def cleanup(self) -> None:
-        """Cleanup the item"""
-        self.remove_from_plot()
-        self.tick_item = None
-
-
-class BECArrowItem(BECIndicatorItem):
-    """Class to create an arrow item which can be added to a pyqtgraph plot.
-    It can be either added directly to a view box or a plot item.
-    To add the arrow item to a view box or plot item, use the add_to_plot method.
-
-    Args:
-        view_box (pg.ViewBox | pg.PlotItem): The view box or plot item to which the arrow item should be added.
-        parent (QObject): The parent object.
-
-    Signals:
-        position_changed (tuple[float, float]): Signal emitted when the position of the arrow item has changed.
-        position_changed_str (tuple[str, str]): Signal emitted when the position of the arrow item has changed.
-    """
-
-    # Signal to emit if the position of the arrow item has changed
-    position_changed = Signal(tuple)
-    position_changed_str = Signal(tuple)
-
-    def __init__(self, plot_item: pg.PlotItem = None, parent=None):
-        super().__init__(plot_item=plot_item, parent=parent)
-        self.arrow_item = pg.ArrowItem()
-        self.arrow_item.skip_auto_range = True
-        self._pos = (0, 0)
-        self.arrow_item.setVisible(False)
-
-    @Slot(dict)
-    def set_style(self, style: dict) -> None:
-        """Set the style of the arrow item
-
-        Args:
-            style (dict): The style of the arrow item. Dictionary with key,
-                          value pairs which are accepted from the pg.ArrowItem.setStyle method.
-        """
-        self.arrow_item.setStyle(**style)
-
-    @Slot(tuple)
-    def set_position(self, pos: tuple[float, float]) -> None:
-        """Set the position of the arrow item
-
-        Args:
-            pos (tuple): The position of the arrow item as a tuple (x, y).
-        """
-        self._pos = pos
-        pos_x = pos[0]
-        pos_y = pos[1]
-        if self.is_log_x is True:
-            pos_x = np.log10(pos_x) if pos_x > 0 else 1e-10
-            view_box = self.plot_item.getViewBox()  # Ensure you're accessing the correct view box
-            view_range = view_box.viewRange()[0]
-            # Avoid values outside the view range in the negative direction. Otherwise, there is
-            # a buggy behaviour of the arrow item and it appears at the wrong position.
-            if pos_x < view_range[0]:
-                pos_x = view_range[0]
-        if self.is_log_y is True:
-            pos_y = np.log10(pos_y) if pos_y > 0 else 1e-10
-
-        self.arrow_item.setPos(pos_x, pos_y)
-        self.position_changed.emit(self._pos)
-        self.position_changed_str.emit((str(self._pos[0]), str(self._pos[1])))
-
-    def add_to_plot(self):
-        """Add the arrow item to the view box or plot item."""
-        if not self.arrow_item:
-            logger.warning(f"Arrow item was already destroyed, cannot be created")
-            return
-
-        self.arrow_item.setStyle(
-            angle=-90,
-            pen=pg.mkPen(self.accent_colors.emergency, width=1),
-            brush=pg.mkBrush(self.accent_colors.highlight),
-            headLen=20,
-        )
-        self.arrow_item.setVisible(True)
-        if self.plot_item is not None:
-            self.plot_item.addItem(self.arrow_item)
-            self.plot_item.ctrl.logXCheck.checkStateChanged.connect(self.check_log)
-            self.plot_item.ctrl.logYCheck.checkStateChanged.connect(self.check_log)
-            self.item_on_plot = True
-
-    def remove_from_plot(self):
-        """Remove the arrow item from the view box or plot item."""
-        if self.plot_item is not None and self.item_on_plot is True:
-            self.plot_item.ctrl.logXCheck.checkStateChanged.disconnect(self.check_log)
-            self.plot_item.ctrl.logYCheck.checkStateChanged.disconnect(self.check_log)
-            self.plot_item.removeItem(self.arrow_item)
-        self.item_on_plot = False
-
-    def cleanup(self) -> None:
-        """Cleanup the item"""
-        self.remove_from_plot()
-        self.arrow_item = None

bec_widgets/utils/plugin_templates/plugin.template

@@ -2,9 +2,8 @@
 # SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
 
 from qtpy.QtDesigner import QDesignerCustomWidgetInterface
-from qtpy.QtWidgets import QWidget
+from qtpy.QtGui import QIcon
 
-from bec_widgets.utils.bec_designer import designer_material_icon
 {widget_import}
 
 DOM_XML = """
@@ -21,8 +20,6 @@ class {plugin_name_pascal}Plugin(QDesignerCustomWidgetInterface):  # pragma: no
         self._form_editor = None
 
     def createWidget(self, parent):
-        if parent is None:
-           return QWidget()
         t = {plugin_name_pascal}(parent)
         return t
 
@@ -33,7 +30,7 @@ class {plugin_name_pascal}Plugin(QDesignerCustomWidgetInterface):  # pragma: no
         return ""
 
     def icon(self):
-        return designer_material_icon({plugin_name_pascal}.ICON_NAME)
+        return QIcon()
 
     def includeFile(self):
         return "{plugin_name_snake}"

bec_widgets/utils/plugin_utils.py

@@ -1,19 +1,12 @@
-from __future__ import annotations
-
 import importlib
 import inspect
 import os
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Iterable
+from typing import Literal
 
 from bec_lib.plugin_helper import _get_available_plugins
 from qtpy.QtWidgets import QGraphicsWidget, QWidget
 
 from bec_widgets.utils import BECConnector
-from bec_widgets.utils.bec_widget import BECWidget
-
-if TYPE_CHECKING:  # pragma: no cover
-    from bec_widgets.widgets.containers.auto_update.auto_updates import AutoUpdates
 
 
 def get_plugin_widgets() -> dict[str, BECConnector]:
@@ -51,122 +44,9 @@ def _filter_plugins(obj):
     return inspect.isclass(obj) and issubclass(obj, BECConnector)
 
 
-def get_plugin_auto_updates() -> dict[str, type[AutoUpdates]]:
-    """
-    Get all available auto update classes from the plugin directory. AutoUpdates must inherit from AutoUpdate and be
-    placed in the plugin repository's bec_widgets/auto_updates directory. The entry point for the auto updates is
-    specified in the respective pyproject.toml file using the following key:
-        [project.entry-points."bec.widgets.auto_updates"]
-        plugin_widgets_update = "<beamline_name>.bec_widgets.auto_updates"
-
-    e.g.
-        [project.entry-points."bec.widgets.auto_updates"]
-        plugin_widgets_update = "pxiii_bec.bec_widgets.auto_updates"
-
-    Returns:
-        dict[str, AutoUpdates]: A dictionary of widget names and their respective classes.
-    """
-    modules = _get_available_plugins("bec.widgets.auto_updates")
-    loaded_plugins = {}
-    for module in modules:
-        mods = inspect.getmembers(module, predicate=_filter_auto_updates)
-        for name, mod_cls in mods:
-            if name in loaded_plugins:
-                print(f"Duplicated auto update {name}.")
-            loaded_plugins[name] = mod_cls
-    return loaded_plugins
-
-
-def _filter_auto_updates(obj):
-    from bec_widgets.widgets.containers.auto_update.auto_updates import AutoUpdates
-
-    return (
-        inspect.isclass(obj) and issubclass(obj, AutoUpdates) and not obj.__name__ == "AutoUpdates"
-    )
-
-
-@dataclass
-class BECClassInfo:
-    name: str
-    module: str
-    file: str
-    obj: type[BECWidget]
-    is_connector: bool = False
-    is_widget: bool = False
-    is_plugin: bool = False
-
-
-class BECClassContainer:
-    def __init__(self, initial: Iterable[BECClassInfo] = []):
-        self._collection: list[BECClassInfo] = list(initial)
-
-    def __repr__(self):
-        return str(list(cl.name for cl in self.collection))
-
-    def __iter__(self):
-        return self._collection.__iter__()
-
-    def __add__(self, other: BECClassContainer):
-        return BECClassContainer((*self, *(c for c in other if c.name not in self.names)))
-
-    def as_dict(self, ignores: list[str] = []) -> dict[str, type[BECWidget]]:
-        """get a dict of {name: Type} for all the entries in the collection.
-
-        Args:
-            ignores(list[str]): a list of class names to exclude from the dictionary."""
-        return {c.name: c.obj for c in self if c.name not in ignores}
-
-    def add_class(self, class_info: BECClassInfo):
-        """
-        Add a class to the collection.
-
-        Args:
-            class_info(BECClassInfo): The class information
-        """
-        self.collection.append(class_info)
-
-    @property
-    def names(self):
-        """Return a list of class names"""
-        return [c.name for c in self]
-
-    @property
-    def collection(self):
-        """Get the collection of classes."""
-        return self._collection
-
-    @property
-    def connector_classes(self):
-        """Get all connector classes."""
-        return [info.obj for info in self.collection if info.is_connector]
-
-    @property
-    def top_level_classes(self):
-        """Get all top-level classes."""
-        return [info.obj for info in self.collection if info.is_plugin]
-
-    @property
-    def plugins(self):
-        """Get all plugins. These are all classes that are on the top level and are widgets."""
-        return [info.obj for info in self.collection if info.is_widget and info.is_plugin]
-
-    @property
-    def widgets(self):
-        """Get all widgets. These are all classes inheriting from BECWidget."""
-        return [info.obj for info in self.collection if info.is_widget]
-
-    @property
-    def rpc_top_level_classes(self):
-        """Get all top-level classes that are RPC-enabled. These are all classes that users can choose from."""
-        return [info.obj for info in self.collection if info.is_plugin and info.is_connector]
-
-    @property
-    def classes(self):
-        """Get all classes."""
-        return [info.obj for info in self.collection]
-
-
-def get_custom_classes(repo_name: str) -> BECClassContainer:
+def get_rpc_classes(
+    repo_name: str,
+) -> dict[Literal["connector_classes", "top_level_classes"], list[type]]:
     """
     Get all RPC-enabled classes in the specified repository.
 
@@ -176,7 +56,8 @@ def get_custom_classes(repo_name: str) -> BECClassContainer:
     Returns:
         dict: A dictionary with keys "connector_classes" and "top_level_classes" and values as lists of classes.
     """
-    collection = BECClassContainer()
+    connector_classes = []
+    top_level_classes = []
     anchor_module = importlib.import_module(f"{repo_name}.widgets")
     directory = os.path.dirname(anchor_module.__file__)
     for root, _, files in sorted(os.walk(directory)):
@@ -197,18 +78,11 @@ def get_custom_classes(repo_name: str) -> BECClassContainer:
                 obj = getattr(module, name)
                 if not hasattr(obj, "__module__") or obj.__module__ != module.__name__:
                     continue
-                if isinstance(obj, type):
-                    class_info = BECClassInfo(name=name, module=module.__name__, file=path, obj=obj)
-                    if issubclass(obj, BECConnector):
-                        class_info.is_connector = True
-                    if issubclass(obj, QWidget) or issubclass(obj, BECWidget):
-                        class_info.is_widget = True
+                if isinstance(obj, type) and issubclass(obj, BECConnector):
+                    connector_classes.append(obj)
                     if len(subs) == 1 and (
                         issubclass(obj, QWidget) or issubclass(obj, QGraphicsWidget)
                     ):
-                        class_info.is_top_level = True
-                    if hasattr(obj, "PLUGIN") and obj.PLUGIN:
-                        class_info.is_plugin = True
-                    collection.add_class(class_info)
+                        top_level_classes.append(obj)
 
-    return collection
+    return {"connector_classes": connector_classes, "top_level_classes": top_level_classes}

bec_widgets/utils/property_editor.py

@@ -1,694 +0,0 @@
-from __future__ import annotations
-
-from qtpy.QtCore import QLocale, QMetaEnum, Qt, QTimer
-from qtpy.QtGui import QColor, QCursor, QFont, QIcon, QPalette
-from qtpy.QtWidgets import (
-    QCheckBox,
-    QColorDialog,
-    QComboBox,
-    QDoubleSpinBox,
-    QFileDialog,
-    QFontDialog,
-    QHBoxLayout,
-    QHeaderView,
-    QLabel,
-    QLineEdit,
-    QMenu,
-    QPushButton,
-    QSizePolicy,
-    QSpinBox,
-    QToolButton,
-    QTreeWidget,
-    QTreeWidgetItem,
-    QVBoxLayout,
-    QWidget,
-)
-
-
-class PropertyEditor(QWidget):
-    def __init__(self, target: QWidget, parent: QWidget | None = None, show_only_bec: bool = True):
-        super().__init__(parent)
-        self._target = target
-        self._bec_only = show_only_bec
-
-        layout = QVBoxLayout(self)
-        layout.setContentsMargins(0, 0, 0, 0)
-
-        # Name row
-        name_row = QHBoxLayout()
-        name_row.addWidget(QLabel("Name:"))
-        self.name_edit = QLineEdit(target.objectName())
-        self.name_edit.setEnabled(False)  # TODO implement with RPC broadcast
-        name_row.addWidget(self.name_edit)
-        layout.addLayout(name_row)
-
-        # BEC only checkbox
-        filter_row = QHBoxLayout()
-        self.chk_show_qt = QCheckBox("Show Qt properties")
-        self.chk_show_qt.setChecked(False)
-        filter_row.addWidget(self.chk_show_qt)
-        filter_row.addStretch(1)
-        layout.addLayout(filter_row)
-        self.chk_show_qt.toggled.connect(lambda checked: self.set_show_only_bec(not checked))
-
-        # Main tree widget
-        self.tree = QTreeWidget(self)
-        self.tree.setColumnCount(2)
-        self.tree.setHeaderLabels(["Property", "Value"])
-        self.tree.setAlternatingRowColors(True)
-        self.tree.setRootIsDecorated(False)
-        layout.addWidget(self.tree)
-        self._build()
-
-    def _class_chain(self):
-        chain = []
-        mo = self._target.metaObject()
-        while mo is not None:
-            chain.append(mo)
-            mo = mo.superClass()
-        return chain
-
-    def set_show_only_bec(self, flag: bool):
-        self._bec_only = flag
-        self._build()
-
-    def _set_equal_columns(self):
-        header = self.tree.header()
-        header.setSectionResizeMode(0, QHeaderView.Interactive)
-        header.setSectionResizeMode(1, QHeaderView.Interactive)
-        w = self.tree.viewport().width() or self.tree.width()
-        if w > 0:
-            half = max(1, w // 2)
-            self.tree.setColumnWidth(0, half)
-            self.tree.setColumnWidth(1, w - half)
-
-    def _build(self):
-        self.tree.clear()
-        for mo in self._class_chain():
-            class_name = mo.className()
-            if self._bec_only and not self._is_bec_metaobject(mo):
-                continue
-            group_item = QTreeWidgetItem(self.tree, [class_name])
-            group_item.setFirstColumnSpanned(True)
-            start = mo.propertyOffset()
-            end = mo.propertyCount()
-            for i in range(start, end):
-                prop = mo.property(i)
-                if (
-                    not prop.isReadable()
-                    or not prop.isWritable()
-                    or not prop.isStored()
-                    or not prop.isDesignable()
-                ):
-                    continue
-                name = prop.name()
-                if name == "objectName":
-                    continue
-                value = self._target.property(name)
-                self._add_property_row(group_item, name, value, prop)
-            if group_item.childCount() == 0:
-                idx = self.tree.indexOfTopLevelItem(group_item)
-                self.tree.takeTopLevelItem(idx)
-        self.tree.expandAll()
-        QTimer.singleShot(0, self._set_equal_columns)
-
-    def _enum_int(self, obj) -> int:
-        return int(getattr(obj, "value", obj))
-
-    def _make_sizepolicy_editor(self, name: str, sp):
-        if not isinstance(sp, QSizePolicy):
-            return None
-        wrap = QWidget(self)
-        row = QHBoxLayout(wrap)
-        row.setContentsMargins(0, 0, 0, 0)
-        row.setSpacing(4)
-        h_combo = QComboBox(wrap)
-        v_combo = QComboBox(wrap)
-        hs = QSpinBox(wrap)
-        vs = QSpinBox(wrap)
-        for b in (hs, vs):
-            b.setRange(0, 16777215)
-        policies = [
-            (QSizePolicy.Fixed, "Fixed"),
-            (QSizePolicy.Minimum, "Minimum"),
-            (QSizePolicy.Maximum, "Maximum"),
-            (QSizePolicy.Preferred, "Preferred"),
-            (QSizePolicy.Expanding, "Expanding"),
-            (QSizePolicy.MinimumExpanding, "MinExpanding"),
-            (QSizePolicy.Ignored, "Ignored"),
-        ]
-        for pol, text in policies:
-            h_combo.addItem(text, self._enum_int(pol))
-            v_combo.addItem(text, self._enum_int(pol))
-
-        def _set_current(combo, val):
-            idx = combo.findData(self._enum_int(val))
-            if idx >= 0:
-                combo.setCurrentIndex(idx)
-
-        _set_current(h_combo, sp.horizontalPolicy())
-        _set_current(v_combo, sp.verticalPolicy())
-        hs.setValue(sp.horizontalStretch())
-        vs.setValue(sp.verticalStretch())
-
-        def apply_changes():
-            hp = QSizePolicy.Policy(h_combo.currentData())
-            vp = QSizePolicy.Policy(v_combo.currentData())
-            nsp = QSizePolicy(hp, vp)
-            nsp.setHorizontalStretch(hs.value())
-            nsp.setVerticalStretch(vs.value())
-            self._target.setProperty(name, nsp)
-
-        h_combo.currentIndexChanged.connect(lambda _=None: apply_changes())
-        v_combo.currentIndexChanged.connect(lambda _=None: apply_changes())
-        hs.valueChanged.connect(lambda _=None: apply_changes())
-        vs.valueChanged.connect(lambda _=None: apply_changes())
-        row.addWidget(h_combo)
-        row.addWidget(v_combo)
-        row.addWidget(hs)
-        row.addWidget(vs)
-        return wrap
-
-    def _make_locale_editor(self, name: str, loc):
-        if not isinstance(loc, QLocale):
-            return None
-        wrap = QWidget(self)
-        row = QHBoxLayout(wrap)
-        row.setContentsMargins(0, 0, 0, 0)
-        row.setSpacing(4)
-        lang_combo = QComboBox(wrap)
-        country_combo = QComboBox(wrap)
-        for lang in QLocale.Language:
-            try:
-                lang_int = self._enum_int(lang)
-            except Exception:
-                continue
-            if lang_int < 0:
-                continue
-            name_txt = QLocale.languageToString(QLocale.Language(lang_int))
-            lang_combo.addItem(name_txt, lang_int)
-
-        def populate_countries():
-            country_combo.blockSignals(True)
-            country_combo.clear()
-            for terr in QLocale.Country:
-                try:
-                    terr_int = self._enum_int(terr)
-                except Exception:
-                    continue
-                if terr_int < 0:
-                    continue
-                text = QLocale.countryToString(QLocale.Country(terr_int))
-                country_combo.addItem(text, terr_int)
-            cur_country = self._enum_int(loc.country())
-            idx = country_combo.findData(cur_country)
-            if idx >= 0:
-                country_combo.setCurrentIndex(idx)
-            country_combo.blockSignals(False)
-
-        cur_lang = self._enum_int(loc.language())
-        idx = lang_combo.findData(cur_lang)
-        if idx >= 0:
-            lang_combo.setCurrentIndex(idx)
-        populate_countries()
-
-        def apply_locale():
-            lang = QLocale.Language(int(lang_combo.currentData()))
-            country = QLocale.Country(int(country_combo.currentData()))
-            self._target.setProperty(name, QLocale(lang, country))
-
-        lang_combo.currentIndexChanged.connect(lambda _=None: populate_countries())
-        lang_combo.currentIndexChanged.connect(lambda _=None: apply_locale())
-        country_combo.currentIndexChanged.connect(lambda _=None: apply_locale())
-        row.addWidget(lang_combo)
-        row.addWidget(country_combo)
-        return wrap
-
-    def _make_icon_editor(self, name: str, icon):
-        btn = QPushButton(self)
-        btn.setText("Choose…")
-        if isinstance(icon, QIcon) and not icon.isNull():
-            btn.setIcon(icon)
-
-        def pick():
-            path, _ = QFileDialog.getOpenFileName(
-                self, "Select Icon", "", "Images (*.png *.jpg *.jpeg *.bmp *.svg)"
-            )
-            if path:
-                ic = QIcon(path)
-                self._target.setProperty(name, ic)
-                btn.setIcon(ic)
-
-        btn.clicked.connect(pick)
-        return btn
-
-    def _spin_pair(self, ints: bool = True):
-        box1 = QSpinBox(self) if ints else QDoubleSpinBox(self)
-        box2 = QSpinBox(self) if ints else QDoubleSpinBox(self)
-        if ints:
-            box1.setRange(-10_000_000, 10_000_000)
-            box2.setRange(-10_000_000, 10_000_000)
-        else:
-            for b in (box1, box2):
-                b.setDecimals(6)
-                b.setRange(-1e12, 1e12)
-                b.setSingleStep(0.1)
-        row = QHBoxLayout()
-        row.setContentsMargins(0, 0, 0, 0)
-        row.setSpacing(4)
-        wrap = QWidget(self)
-        wrap.setLayout(row)
-        row.addWidget(box1)
-        row.addWidget(box2)
-        return wrap, box1, box2
-
-    def _spin_quad(self, ints: bool = True):
-        s = QSpinBox if ints else QDoubleSpinBox
-        boxes = [s(self) for _ in range(4)]
-        if ints:
-            for b in boxes:
-                b.setRange(-10_000_000, 10_000_000)
-        else:
-            for b in boxes:
-                b.setDecimals(6)
-                b.setRange(-1e12, 1e12)
-                b.setSingleStep(0.1)
-        row = QHBoxLayout()
-        row.setContentsMargins(0, 0, 0, 0)
-        row.setSpacing(4)
-        wrap = QWidget(self)
-        wrap.setLayout(row)
-        for b in boxes:
-            row.addWidget(b)
-        return wrap, boxes
-
-    def _make_font_editor(self, name: str, value):
-        btn = QPushButton(self)
-        if isinstance(value, QFont):
-            btn.setText(f"{value.family()}, {value.pointSize()}pt")
-        else:
-            btn.setText("Select font…")
-
-        def pick():
-            ok, font = QFontDialog.getFont(
-                value if isinstance(value, QFont) else QFont(), self, "Select Font"
-            )
-            if ok:
-                self._target.setProperty(name, font)
-                btn.setText(f"{font.family()}, {font.pointSize()}pt")
-
-        btn.clicked.connect(pick)
-        return btn
-
-    def _make_color_editor(self, initial: QColor, apply_cb):
-        btn = QPushButton(self)
-        if isinstance(initial, QColor):
-            btn.setText(initial.name())
-            btn.setStyleSheet(f"background:{initial.name()};")
-        else:
-            btn.setText("Select color…")
-
-        def pick():
-            col = QColorDialog.getColor(
-                initial if isinstance(initial, QColor) else QColor(), self, "Select Color"
-            )
-            if col.isValid():
-                apply_cb(col)
-                btn.setText(col.name())
-                btn.setStyleSheet(f"background:{col.name()};")
-
-        btn.clicked.connect(pick)
-        return btn
-
-    def _apply_palette_color(
-        self,
-        name: str,
-        pal: QPalette,
-        group: QPalette.ColorGroup,
-        role: QPalette.ColorRole,
-        col: QColor,
-    ):
-        pal.setColor(group, role, col)
-        self._target.setProperty(name, pal)
-
-    def _make_palette_editor(self, name: str, pal: QPalette):
-        if not isinstance(pal, QPalette):
-            return None
-        wrap = QWidget(self)
-        row = QHBoxLayout(wrap)
-        row.setContentsMargins(0, 0, 0, 0)
-        group_combo = QComboBox(wrap)
-        role_combo = QComboBox(wrap)
-        pick_btn = self._make_color_editor(
-            pal.color(QPalette.Active, QPalette.WindowText),
-            lambda col: self._apply_palette_color(
-                name, pal, QPalette.Active, QPalette.WindowText, col
-            ),
-        )
-        groups = [
-            (QPalette.Active, "Active"),
-            (QPalette.Inactive, "Inactive"),
-            (QPalette.Disabled, "Disabled"),
-        ]
-        for g, label in groups:
-            group_combo.addItem(label, int(getattr(g, "value", g)))
-        roles = [
-            (QPalette.WindowText, "WindowText"),
-            (QPalette.Window, "Window"),
-            (QPalette.Base, "Base"),
-            (QPalette.AlternateBase, "AlternateBase"),
-            (QPalette.ToolTipBase, "ToolTipBase"),
-            (QPalette.ToolTipText, "ToolTipText"),
-            (QPalette.Text, "Text"),
-            (QPalette.Button, "Button"),
-            (QPalette.ButtonText, "ButtonText"),
-            (QPalette.BrightText, "BrightText"),
-            (QPalette.Highlight, "Highlight"),
-            (QPalette.HighlightedText, "HighlightedText"),
-        ]
-        for r, label in roles:
-            role_combo.addItem(label, int(getattr(r, "value", r)))
-
-        def rewire_button():
-            g = QPalette.ColorGroup(int(group_combo.currentData()))
-            r = QPalette.ColorRole(int(role_combo.currentData()))
-            col = pal.color(g, r)
-            while row.count() > 2:
-                w = row.takeAt(2).widget()
-                if w:
-                    w.deleteLater()
-            btn = self._make_color_editor(
-                col, lambda c: self._apply_palette_color(name, pal, g, r, c)
-            )
-            row.addWidget(btn)
-
-        group_combo.currentIndexChanged.connect(lambda _: rewire_button())
-        role_combo.currentIndexChanged.connect(lambda _: rewire_button())
-        row.addWidget(group_combo)
-        row.addWidget(role_combo)
-        row.addWidget(pick_btn)
-        return wrap
-
-    def _make_cursor_editor(self, name: str, value):
-        combo = QComboBox(self)
-        shapes = [
-            (Qt.ArrowCursor, "Arrow"),
-            (Qt.IBeamCursor, "IBeam"),
-            (Qt.WaitCursor, "Wait"),
-            (Qt.CrossCursor, "Cross"),
-            (Qt.UpArrowCursor, "UpArrow"),
-            (Qt.SizeAllCursor, "SizeAll"),
-            (Qt.PointingHandCursor, "PointingHand"),
-            (Qt.ForbiddenCursor, "Forbidden"),
-            (Qt.WhatsThisCursor, "WhatsThis"),
-            (Qt.BusyCursor, "Busy"),
-        ]
-        current_shape = None
-        if isinstance(value, QCursor):
-            try:
-                enum_val = value.shape()
-                current_shape = int(getattr(enum_val, "value", enum_val))
-            except Exception:
-                current_shape = None
-        for shape, text in shapes:
-            combo.addItem(text, int(getattr(shape, "value", shape)))
-        if current_shape is not None:
-            idx = combo.findData(current_shape)
-            if idx >= 0:
-                combo.setCurrentIndex(idx)
-
-        def apply_index(i):
-            shape_val = int(combo.itemData(i))
-            self._target.setProperty(name, QCursor(Qt.CursorShape(shape_val)))
-
-        combo.currentIndexChanged.connect(apply_index)
-        return combo
-
-    def _add_property_row(self, parent: QTreeWidgetItem, name: str, value, prop):
-        item = QTreeWidgetItem(parent, [name, ""])
-        editor = self._make_editor(name, value, prop)
-        if editor is not None:
-            self.tree.setItemWidget(item, 1, editor)
-        else:
-            item.setText(1, repr(value))
-
-    def _is_bec_metaobject(self, mo) -> bool:
-        cname = mo.className()
-        for cls in type(self._target).mro():
-            if getattr(cls, "__name__", None) == cname:
-                mod = getattr(cls, "__module__", "")
-                return mod.startswith("bec_widgets")
-        return False
-
-    def _enum_text(self, meta_enum: QMetaEnum, value_int: int) -> str:
-        if not meta_enum.isFlag():
-            key = meta_enum.valueToKey(value_int)
-            return key.decode() if isinstance(key, (bytes, bytearray)) else (key or str(value_int))
-        parts = []
-        for i in range(meta_enum.keyCount()):
-            k = meta_enum.key(i)
-            v = meta_enum.value(i)
-            if value_int & v:
-                k = k.decode() if isinstance(k, (bytes, bytearray)) else k
-                parts.append(k)
-        return " | ".join(parts) if parts else "0"
-
-    def _enum_value_to_int(self, meta_enum: QMetaEnum, value) -> int:
-        try:
-            return int(value)
-        except Exception:
-            pass
-        v = getattr(value, "value", None)
-        if isinstance(v, (int,)):
-            return int(v)
-        n = getattr(value, "name", None)
-        if isinstance(n, str):
-            res = meta_enum.keyToValue(n)
-            if res != -1:
-                return int(res)
-        s = str(value)
-        parts = [p.strip() for p in s.replace(",", "|").split("|")]
-        keys = []
-        for p in parts:
-            if "." in p:
-                p = p.split(".")[-1]
-            keys.append(p)
-        keystr = "|".join(keys)
-        try:
-            res = meta_enum.keysToValue(keystr)
-            if res != -1:
-                return int(res)
-        except Exception:
-            pass
-        return 0
-
-    def _make_enum_editor(self, name: str, value, prop):
-        meta_enum = prop.enumerator()
-        current = self._enum_value_to_int(meta_enum, value)
-
-        if not meta_enum.isFlag():
-            combo = QComboBox(self)
-            for i in range(meta_enum.keyCount()):
-                key = meta_enum.key(i)
-                key = key.decode() if isinstance(key, (bytes, bytearray)) else key
-                combo.addItem(key, meta_enum.value(i))
-            idx = combo.findData(current)
-            if idx < 0:
-                txt = self._enum_text(meta_enum, current)
-                idx = combo.findText(txt)
-            combo.setCurrentIndex(max(idx, 0))
-
-            def apply_index(i):
-                v = combo.itemData(i)
-                self._target.setProperty(name, int(v))
-
-            combo.currentIndexChanged.connect(apply_index)
-            return combo
-
-        btn = QToolButton(self)
-        btn.setText(self._enum_text(meta_enum, current))
-        btn.setPopupMode(QToolButton.InstantPopup)
-        menu = QMenu(btn)
-        actions = []
-        for i in range(meta_enum.keyCount()):
-            key = meta_enum.key(i)
-            key = key.decode() if isinstance(key, (bytes, bytearray)) else key
-            act = menu.addAction(key)
-            act.setCheckable(True)
-            act.setChecked(bool(current & meta_enum.value(i)))
-            actions.append(act)
-        btn.setMenu(menu)
-
-        def apply_flags():
-            flags = 0
-            for i, act in enumerate(actions):
-                if act.isChecked():
-                    flags |= meta_enum.value(i)
-            self._target.setProperty(name, int(flags))
-            btn.setText(self._enum_text(meta_enum, flags))
-
-        menu.triggered.connect(lambda _a: apply_flags())
-        return btn
-
-    def _make_editor(self, name: str, value, prop):
-        from qtpy.QtCore import QPoint, QPointF, QRect, QRectF, QSize, QSizeF
-
-        if prop.isEnumType():
-            return self._make_enum_editor(name, value, prop)
-        if isinstance(value, QColor):
-            return self._make_color_editor(value, lambda col: self._target.setProperty(name, col))
-        if isinstance(value, QFont):
-            return self._make_font_editor(name, value)
-        if isinstance(value, QPalette):
-            return self._make_palette_editor(name, value)
-        if isinstance(value, QCursor):
-            return self._make_cursor_editor(name, value)
-        if isinstance(value, QSizePolicy):
-            ed = self._make_sizepolicy_editor(name, value)
-            if ed is not None:
-                return ed
-        if isinstance(value, QLocale):
-            ed = self._make_locale_editor(name, value)
-            if ed is not None:
-                return ed
-        if isinstance(value, QIcon):
-            ed = self._make_icon_editor(name, value)
-            if ed is not None:
-                return ed
-        if isinstance(value, QSize):
-            wrap, w, h = self._spin_pair(ints=True)
-            w.setValue(value.width())
-            h.setValue(value.height())
-            w.valueChanged.connect(
-                lambda _: self._target.setProperty(name, QSize(w.value(), h.value()))
-            )
-            h.valueChanged.connect(
-                lambda _: self._target.setProperty(name, QSize(w.value(), h.value()))
-            )
-            return wrap
-        if isinstance(value, QSizeF):
-            wrap, w, h = self._spin_pair(ints=False)
-            w.setValue(value.width())
-            h.setValue(value.height())
-            w.valueChanged.connect(
-                lambda _: self._target.setProperty(name, QSizeF(w.value(), h.value()))
-            )
-            h.valueChanged.connect(
-                lambda _: self._target.setProperty(name, QSizeF(w.value(), h.value()))
-            )
-            return wrap
-        if isinstance(value, QPoint):
-            wrap, x, y = self._spin_pair(ints=True)
-            x.setValue(value.x())
-            y.setValue(value.y())
-            x.valueChanged.connect(
-                lambda _: self._target.setProperty(name, QPoint(x.value(), y.value()))
-            )
-            y.valueChanged.connect(
-                lambda _: self._target.setProperty(name, QPoint(x.value(), y.value()))
-            )
-            return wrap
-        if isinstance(value, QPointF):
-            wrap, x, y = self._spin_pair(ints=False)
-            x.setValue(value.x())
-            y.setValue(value.y())
-            x.valueChanged.connect(
-                lambda _: self._target.setProperty(name, QPointF(x.value(), y.value()))
-            )
-            y.valueChanged.connect(
-                lambda _: self._target.setProperty(name, QPointF(x.value(), y.value()))
-            )
-            return wrap
-        if isinstance(value, QRect):
-            wrap, boxes = self._spin_quad(ints=True)
-            for b, v in zip(boxes, (value.x(), value.y(), value.width(), value.height())):
-                b.setValue(v)
-
-            def apply_rect():
-                self._target.setProperty(
-                    name,
-                    QRect(boxes[0].value(), boxes[1].value(), boxes[2].value(), boxes[3].value()),
-                )
-
-            for b in boxes:
-                b.valueChanged.connect(lambda _=None: apply_rect())
-            return wrap
-        if isinstance(value, QRectF):
-            wrap, boxes = self._spin_quad(ints=False)
-            for b, v in zip(boxes, (value.x(), value.y(), value.width(), value.height())):
-                b.setValue(v)
-
-            def apply_rectf():
-                self._target.setProperty(
-                    name,
-                    QRectF(boxes[0].value(), boxes[1].value(), boxes[2].value(), boxes[3].value()),
-                )
-
-            for b in boxes:
-                b.valueChanged.connect(lambda _=None: apply_rectf())
-            return wrap
-        if isinstance(value, bool):
-            w = QCheckBox(self)
-            w.setChecked(bool(value))
-            w.toggled.connect(lambda v: self._target.setProperty(name, v))
-            return w
-        if isinstance(value, int) and not isinstance(value, bool):
-            w = QSpinBox(self)
-            w.setRange(-10_000_000, 10_000_000)
-            w.setValue(int(value))
-            w.valueChanged.connect(lambda v: self._target.setProperty(name, v))
-            return w
-        if isinstance(value, float):
-            w = QDoubleSpinBox(self)
-            w.setDecimals(6)
-            w.setRange(-1e12, 1e12)
-            w.setSingleStep(0.1)
-            w.setValue(float(value))
-            w.valueChanged.connect(lambda v: self._target.setProperty(name, v))
-            return w
-        if isinstance(value, str):
-            w = QLineEdit(self)
-            w.setText(value)
-            w.editingFinished.connect(lambda: self._target.setProperty(name, w.text()))
-            return w
-        return None
-
-
-class DemoApp(QWidget):  # pragma: no cover:
-    def __init__(self):
-        super().__init__()
-
-        layout = QHBoxLayout(self)
-
-        # Create a BECWidget instance example
-        waveform = self.create_waveform()
-
-        # property editor for the BECWidget
-        property_editor = PropertyEditor(waveform, show_only_bec=True)
-
-        layout.addWidget(waveform)
-        layout.addWidget(property_editor)
-
-    def create_waveform(self):
-        """Create a new waveform widget."""
-
-        from bec_widgets.widgets.plots.waveform.waveform import Waveform
-
-        waveform = Waveform(parent=self)
-        waveform.title = "New Waveform"
-        waveform.x_label = "X Axis"
-        waveform.y_label = "Y Axis"
-        return waveform
-
-
-if __name__ == "__main__":  # pragma: no cover:
-    import sys
-
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-    demo = DemoApp()
-    demo.setWindowTitle("Property Editor Demo")
-    demo.resize(1200, 800)
-    demo.show()
-    sys.exit(app.exec())

bec_widgets/utils/redis_message_waiter.py

@@ -1,47 +0,0 @@
-from bec_lib.serialization import MsgpackSerialization
-from bec_lib.utils import lazy_import_from
-from qtpy.QtCore import QEventLoop, QSocketNotifier, QTimer
-
-MessageObject = lazy_import_from("bec_lib.connector", ("MessageObject",))
-
-
-class QtRedisMessageWaiter:
-    def __init__(self, redis_connector, message_to_wait):
-        self.ev_loop = QEventLoop()
-        self.response = None
-        self.connector = redis_connector
-        self.message_to_wait = message_to_wait
-        self.pubsub = redis_connector._redis_conn.pubsub()
-        self.pubsub.subscribe(self.message_to_wait.endpoint)
-        fd = self.pubsub.connection._sock.fileno()
-        self.notifier = QSocketNotifier(fd, QSocketNotifier.Read)
-        self.notifier.activated.connect(self._pubsub_readable)
-
-    def _msg_received(self, msg_obj):
-        self.response = msg_obj.value
-        self.ev_loop.quit()
-
-    def wait(self, timeout=1):
-        timer = QTimer()
-        timer.singleShot(timeout * 1000, self.ev_loop.quit)
-        self.ev_loop.exec_()
-        timer.stop()
-        self.notifier.setEnabled(False)
-        self.pubsub.close()
-        return self.response
-
-    def _pubsub_readable(self, fd):
-        while True:
-            msg = self.pubsub.get_message()
-            if msg:
-                if msg["type"] == "subscribe":
-                    # get_message buffers, so we may already have the answer
-                    # let's check...
-                    continue
-                else:
-                    break
-            else:
-                return
-        channel = msg["channel"].decode()
-        msg = MessageObject(topic=channel, value=MsgpackSerialization.loads(msg["data"]))
-        self.connector._execute_callback(self._msg_received, msg, {})

bec_widgets/utils/reference_utils.py

@@ -1,92 +0,0 @@
-import os
-import sys
-
-from PIL import Image, ImageChops
-from qtpy.QtGui import QPixmap
-
-import bec_widgets
-
-REFERENCE_DIR = os.path.join(
-    os.path.dirname(os.path.dirname(bec_widgets.__file__)), "tests/references"
-)
-REFERENCE_DIR_FAILURES = os.path.join(
-    os.path.dirname(os.path.dirname(bec_widgets.__file__)), "tests/reference_failures"
-)
-
-
-def compare_images(image1_path: str, reference_image_path: str):
-    """
-    Load two images and compare them pixel by pixel
-
-    Args:
-        image1_path(str): The path to the first image
-        reference_image_path(str): The path to the reference image
-
-    Raises:
-        ValueError: If the images are different
-    """
-    image1 = Image.open(image1_path)
-    image2 = Image.open(reference_image_path)
-    if image1.size != image2.size:
-        raise ValueError("Image size has changed")
-    diff = ImageChops.difference(image1, image2)
-    if diff.getbbox():
-        # copy image1 to the reference directory to upload as artifact
-        os.makedirs(REFERENCE_DIR_FAILURES, exist_ok=True)
-        image_name = os.path.join(REFERENCE_DIR_FAILURES, os.path.basename(image1_path))
-        image1.save(image_name)
-        print(f"Image saved to {image_name}")
-
-        raise ValueError("Images are different")
-
-
-def snap_and_compare(widget: any, output_directory: str, suffix: str = ""):
-    """
-    Save a rendering of a widget and compare it to a reference image
-
-    Args:
-        widget(any): The widget to render
-        output_directory(str): The directory to save the image to
-        suffix(str): A suffix to append to the image name
-
-    Raises:
-        ValueError: If the images are different
-
-    Examples:
-        snap_and_compare(widget, tmpdir, suffix="started")
-
-    """
-
-    if not isinstance(output_directory, str):
-        output_directory = str(output_directory)
-
-    os_suffix = sys.platform
-
-    name = (
-        f"{widget.__class__.__name__}_{suffix}_{os_suffix}.png"
-        if suffix
-        else f"{widget.__class__.__name__}_{os_suffix}.png"
-    )
-
-    # Save the widget to a pixmap
-    test_image_path = os.path.join(output_directory, name)
-    pixmap = QPixmap(widget.size())
-    widget.render(pixmap)
-    pixmap.save(test_image_path)
-
-    try:
-        reference_path = os.path.join(REFERENCE_DIR, f"{widget.__class__.__name__}")
-        reference_image_path = os.path.join(reference_path, name)
-
-        if not os.path.exists(reference_image_path):
-            raise ValueError(f"Reference image not found: {reference_image_path}")
-
-        compare_images(test_image_path, reference_image_path)
-
-    except ValueError:
-        image = Image.open(test_image_path)
-        os.makedirs(REFERENCE_DIR_FAILURES, exist_ok=True)
-        image_name = os.path.join(REFERENCE_DIR_FAILURES, name)
-        image.save(image_name)
-        print(f"Image saved to {image_name}")
-        raise

bec_widgets/utils/round_frame.py

@@ -1,126 +0,0 @@
-import pyqtgraph as pg
-from qtpy.QtCore import Property, Qt
-from qtpy.QtWidgets import QApplication, QFrame, QHBoxLayout, QVBoxLayout, QWidget
-
-from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import DarkModeButton
-
-
-class RoundedFrame(QFrame):
-    # TODO this should be removed completely in favor of QSS styling, no time now
-    """
-    A custom QFrame with rounded corners and optional theme updates.
-    The frame can contain any QWidget, however it is mainly designed to wrap PlotWidgets to provide a consistent look and feel with other BEC Widgets.
-    """
-
-    def __init__(
-        self,
-        parent=None,
-        content_widget: QWidget = None,
-        background_color: str = None,
-        orientation: str = "horizontal",
-        radius: int = 10,
-    ):
-        QFrame.__init__(self, parent)
-
-        self.background_color = background_color
-        self._radius = radius
-
-        # Apply rounded frame styling
-        self.setProperty("skip_settings", True)
-        self.setObjectName("roundedFrame")
-
-        # Ensure QSS can paint background/border on this widget
-        self.setAttribute(Qt.WA_StyledBackground, True)
-
-        # Create a layout for the frame
-        if orientation == "vertical":
-            self.layout = QVBoxLayout(self)
-            self.layout.setContentsMargins(5, 5, 5, 5)
-        else:
-            self.layout = QHBoxLayout(self)
-            self.layout.setContentsMargins(5, 5, 5, 5)  # Set 5px margin
-
-        # Add the content widget to the layout
-        if content_widget:
-            self.layout.addWidget(content_widget)
-
-        # Store reference to the content widget
-        self.content_widget = content_widget
-
-        # Automatically apply initial styles to the GraphicalLayoutWidget if applicable
-        self.apply_plot_widget_style()
-        self.update_style()
-
-    def apply_theme(self, theme: str):
-        """Deprecated: RoundedFrame no longer handles theme; styling is QSS-driven."""
-        self.update_style()
-
-    @Property(int)
-    def radius(self):
-        """Radius of the rounded corners."""
-        return self._radius
-
-    @radius.setter
-    def radius(self, value: int):
-        self._radius = value
-        self.update_style()
-
-    def update_style(self):
-        """
-        Update the style of the frame based on the background color.
-        """
-        self.setStyleSheet(
-            f"""
-                QFrame#roundedFrame {{
-                    border-radius: {self._radius}px;
-                }}
-            """
-        )
-        self.apply_plot_widget_style()
-
-    def apply_plot_widget_style(self, border: str = "none"):
-        """
-        Let QSS/pyqtgraph handle plot styling; avoid overriding here.
-        """
-        if isinstance(self.content_widget, pg.GraphicsLayoutWidget):
-            self.content_widget.setStyleSheet("")
-
-
-class ExampleApp(QWidget):  # pragma: no cover
-    def __init__(self):
-        super().__init__()
-        self.setWindowTitle("Rounded Plots Example")
-
-        # Main layout
-        layout = QVBoxLayout(self)
-
-        dark_button = DarkModeButton()
-
-        # Create PlotWidgets
-        plot1 = pg.GraphicsLayoutWidget()
-        plot_item_1 = pg.PlotItem()
-        plot_item_1.plot([1, 3, 2, 4, 6, 5], pen="r")
-        plot1.plot_item = plot_item_1
-
-        plot2 = pg.GraphicsLayoutWidget()
-        plot_item_2 = pg.PlotItem()
-        plot_item_2.plot([1, 2, 4, 8, 16, 32], pen="r")
-        plot2.plot_item = plot_item_2
-
-        # Add to layout (no RoundedFrame wrapper; QSS styles plots)
-        layout.addWidget(dark_button)
-        layout.addWidget(plot1)
-        layout.addWidget(plot2)
-
-        self.setLayout(layout)
-
-        # Theme flip demo removed; global theming applies automatically
-
-
-if __name__ == "__main__":  # pragma: no cover
-    app = QApplication([])
-
-    window = ExampleApp()
-    window.show()
-
-    app.exec()

bec_widgets/utils/rpc_decorator.py

@@ -13,17 +13,3 @@ def register_rpc_methods(cls):
         if getattr(method, "rpc_public", False):
             cls.USER_ACCESS.add(name)
     return cls
-
-
-def rpc_timeout(timeout: float | None):
-    """
-    Decorator to set a timeout for RPC methods.
-    The actual implementation of timeout handling is within the cli module. This decorator
-    is solely to inform the generate-cli command about the timeout value.
-    """
-
-    def decorator(func):
-        func.__rpc_timeout__ = timeout  # Store the timeout value in the function
-        return func
-
-    return decorator