2.8.1

Automatically generated by python-semantic-release

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,41 @@
+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/ISSUE_TEMPLATE/documentation_update.md

@@ -1,3 +1,13 @@
+---
+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]

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,3 +1,13 @@
+---
+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]
@@ -37,4 +47,3 @@
 ## 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]
-

.github/actions/bw_install/action.yml

@@ -0,0 +1,64 @@
+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/pull_request_template.md

@@ -1,19 +1,24 @@
 ## Description
 
-[Provide a brief description of the changes introduced by this merge request.]
+[Provide a brief description of the changes introduced by this pull request.]
 
 ## Related Issues
 
-[Cite any related issues or feature requests that are addressed or resolved by this merge request. Use the gitlab syntax for linking issues, for example, `fixes #123` or `closes #123`.]
+[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`.]
 
 ## 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 MR.]
+[Describe any potential side effects or risks of merging this PR.]
 
 ## Screenshots / GIFs (if applicable)
 

.github/scripts/pr_issue_sync/pr_issue_sync.py

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

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

.github/workflows/check_pr.yml

@@ -0,0 +1,28 @@
+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/ci.yml

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

.github/workflows/end2end-conda.yml

@@ -0,0 +1,48 @@
+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
+      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
+          cd ./bec
+          conda create -q -n test-environment python=3.11
+          source ./bin/install_bec_dev.sh -t
+          cd ../
+          pip install -e ./ophyd_devices
+          pip install -e .[dev,pyside6]
+          pytest -v --files-path ./ --start-servers --random-order  ./tests/end-2-end

.github/workflows/formatter.yml

@@ -0,0 +1,61 @@
+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 black isort
+          pip install -e .[dev]
+          black --check --diff --color .
+          isort --check --diff ./
+  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

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

@@ -0,0 +1,59 @@
+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.10", "3.11", "3.12"]
+
+    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 --maxfail=2 --junitxml=report.xml --random-order ./tests/unit_tests

.github/workflows/pytest.yml

@@ -0,0 +1,64 @@
+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 coverage to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          slug: bec-project/bec_widgets

.github/workflows/semantic_release.yml

@@ -0,0 +1,103 @@
+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/sync-issues-pr.yml

@@ -0,0 +1,40 @@
+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,6 +64,9 @@ coverage.xml
 .pytest_cache/
 cover/
 
+# Output from end2end testing
+tests/reference_failures/
+
 # Translations
 *.mo
 *.pot

.gitlab-ci.yml

@@ -13,7 +13,7 @@ variables:
     value: main
   CHILD_PIPELINE_BRANCH: $CI_DEFAULT_BRANCH
   CHECK_PKG_VERSIONS:
-    description: Whether to run additional tests against min/max/random selection of dependencies. Set to 1 for running. 
+    description: Whether to run additional tests against min/max/random selection of dependencies. Set to 1 for running.
     value: 0
 
 workflow:
@@ -35,8 +35,7 @@ include:
       stage: test
       path: "."
       pytest_args: "-v,--random-order,tests/unit_tests"
-      ignore_dep_group: "pyqt6"
-      pip_args: ".[dev,pyside6]"
+      pip_args: ".[dev]"
 
 # different stages in the pipeline
 stages:
@@ -78,7 +77,7 @@ formatter:
   stage: Formatter
   needs: []
   script:
-    - pip install bec_lib[dev]
+    - pip install -e ./[dev]
     - isort --check --diff --line-length=100 --profile=black --multi-line=3 --trailing-comma ./
     - black --check --diff --color --line-length=100 --skip-magic-trailing-comma ./
   rules:
@@ -89,7 +88,7 @@ pylint:
   needs: []
   before_script:
     - pip install pylint pylint-exit anybadge
-    - pip install -e .[dev,pyqt6]
+    - pip install -e .[dev]
   script:
     - mkdir ./pylint
     - pylint ./bec_widgets --output-format=text --output=./pylint/pylint.log | tee ./pylint/pylint.log || pylint-exit $?
@@ -163,6 +162,20 @@ tests:
       - tests/reference_failures/
     when: always
 
+generate-client-check:
+  stage: test
+  needs: []
+  variables:
+    QT_QPA_PLATFORM: "offscreen"
+  script:
+    - *clone-repos
+    - *install-os-packages
+    - *install-repos
+    - pip install -e .[dev,pyside6]
+    - bw-generate-cli --target bec_widgets
+    # if there are changes in the generated files, fail the job
+    - git diff --exit-code
+
 test-matrix:
   parallel:
     matrix:
@@ -190,7 +203,7 @@ test-matrix:
 end-2-end-conda:
   stage: End2End
   needs: []
-  image: continuumio/miniconda3
+  image: continuumio/miniconda3:25.1.1-2
   allow_failure: false
   variables:
     QT_QPA_PLATFORM: "offscreen"
@@ -217,7 +230,7 @@ end-2-end-conda:
     - pip install -e ./ophyd_devices
 
     - pip install -e .[dev,pyside6]
-    - pytest -v --files-path ./ --start-servers --flush-redis --random-order  ./tests/end-2-end
+    - pytest -v --files-path ./ --start-servers --random-order  ./tests/end-2-end
 
   artifacts:
     when: on_failure
@@ -232,7 +245,7 @@ end-2-end-conda:
     - if: '$CI_PIPELINE_SOURCE == "parent_pipeline"'
     - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "main"'
     - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "production"'
-    - if: '$CI_MERGE_REQUEST_TARGET_BRANCH_NAME =~ /^pre_release.*$/'
+    - if: "$CI_MERGE_REQUEST_TARGET_BRANCH_NAME =~ /^pre_release.*$/"
 
 semver:
   stage: Deploy

.gitlab/issue_templates/bug_report_template.md

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

.readthedocs.yaml

@@ -7,13 +7,13 @@ version: 2
 
 # Set the version of Python and other tools you might need
 build:
-  os: ubuntu-20.04
+  os: ubuntu-22.04
   tools:
-    python: "3.10"
+    python: "3.11"
 
 # 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,5 +21,7 @@ sphinx:
 
 # Optionally declare the Python requirements required to build your docs
 python:
-   install:
-   - requirements: docs/requirements.txt
+  install:
+    - requirements: docs/requirements.txt
+    - method: pip
+      path: .[dev]

LICENSE

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

README.md

@@ -1,5 +1,16 @@
 # 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.10%20%7C%203.11%20%7C%203.12-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/applications/alignment/alignment_1d/alignment_1d.py

@@ -1,199 +0,0 @@
-""" This module contains the GUI for the 1D alignment application.
-It is a preliminary version of the GUI, which will be added to the main branch and steadily updated to be improved.
-"""
-
-import os
-from typing import Optional
-
-from bec_lib.device import Signal as BECSignal
-from bec_lib.endpoints import MessageEndpoints
-from bec_lib.logger import bec_logger
-from qtpy.QtCore import QSize
-from qtpy.QtGui import QIcon
-from qtpy.QtWidgets import QApplication
-
-import bec_widgets
-from bec_widgets.utils import UILoader
-from bec_widgets.utils.bec_dispatcher import BECDispatcher
-from bec_widgets.utils.colors import get_accent_colors
-from bec_widgets.utils.error_popups import SafeSlot as Slot
-from bec_widgets.widgets.control.buttons.stop_button.stop_button import StopButton
-from bec_widgets.widgets.control.device_control.positioner_group.positioner_group import (
-    PositionerGroup,
-)
-from bec_widgets.widgets.dap.lmfit_dialog.lmfit_dialog import LMFitDialog
-from bec_widgets.widgets.plots.waveform.waveform_widget import BECWaveformWidget
-from bec_widgets.widgets.progress.bec_progressbar.bec_progressbar import BECProgressBar
-
-MODULE_PATH = os.path.dirname(bec_widgets.__file__)
-logger = bec_logger.logger
-
-
-# FIXME BECWaveFormWidget is gone, this app will not work until adapted to new Waveform
-class Alignment1D:
-    """Alignment GUI to perform 1D scans"""
-
-    def __init__(self, client=None, gui_id: Optional[str] = None) -> None:
-        """Initialization
-
-        Args:
-            config: Configuration of the application.
-            client: BEC client object.
-            gui_id: GUI ID.
-        """
-        self.bec_dispatcher = BECDispatcher(client=client)
-        self.client = self.bec_dispatcher.client if client is None else client
-        QApplication.instance().aboutToQuit.connect(self.close)
-        self.dev = self.client.device_manager.devices
-
-        self._accent_colors = get_accent_colors()
-        self.ui_file = "alignment_1d.ui"
-        self.ui = None
-        self.progress_bar = None
-        self.waveform = None
-        self.init_ui()
-
-    def init_ui(self):
-        """Initialise the UI from QT Designer file"""
-        current_path = os.path.dirname(__file__)
-        self.ui = UILoader(None).loader(os.path.join(current_path, self.ui_file))
-        # Customize the plotting widget
-        self.waveform = self.ui.findChild(BECWaveformWidget, "bec_waveform_widget")
-        self._customise_bec_waveform_widget()
-        # Setup comboboxes for motor and signal selection
-        # FIXME after changing the filtering in the combobox
-        self._setup_signal_combobox()
-        # Setup motor indicator
-        self._setup_motor_indicator()
-        # Setup progress bar
-        self._setup_progress_bar()
-        # Add actions buttons
-        self._customise_buttons()
-        # Hook scaninfo updates
-        self.bec_dispatcher.connect_slot(self.scan_status_callback, MessageEndpoints.scan_status())
-
-    def show(self):
-        return self.ui.show()
-
-    ##############################
-    ############ SLOTS ###########
-    ##############################
-
-    @Slot(dict, dict)
-    def scan_status_callback(self, content: dict, _) -> None:
-        """This slot allows to enable/disable the UI critical components when a scan is running"""
-        if content["status"] in ["open"]:
-            self.enable_ui(False)
-        elif content["status"] in ["aborted", "halted", "closed"]:
-            self.enable_ui(True)
-
-    @Slot(tuple)
-    def move_to_center(self, move_request: tuple) -> None:
-        """Move the selected motor to the center"""
-        motor = self.ui.device_combobox.currentText()
-        if move_request[0] in ["center", "center1", "center2"]:
-            pos = move_request[1]
-        self.dev.get(motor).move(float(pos), relative=False)
-
-    @Slot()
-    def reset_progress_bar(self) -> None:
-        """Reset the progress bar"""
-        self.progress_bar.set_value(0)
-        self.progress_bar.set_minimum(0)
-
-    @Slot(dict, dict)
-    def update_progress_bar(self, content: dict, _) -> None:
-        """Hook to update the progress bar
-
-        Args:
-            content: Content of the scan progress message.
-            metadata: Metadata of the message.
-        """
-        if content["max_value"] == 0:
-            self.progress_bar.set_value(0)
-            return
-        self.progress_bar.set_maximum(content["max_value"])
-        self.progress_bar.set_value(content["value"])
-
-    @Slot()
-    def clear_queue(self) -> None:
-        """Clear the scan queue"""
-        self.queue.request_queue_reset()
-
-    ##############################
-    ######## END OF SLOTS ########
-    ##############################
-
-    def enable_ui(self, enable: bool) -> None:
-        """Enable or disable the UI components"""
-        # Enable/disable motor and signal selection
-        self.ui.device_combobox_2.setEnabled(enable)
-        # Enable/disable DAP selection
-        self.ui.dap_combo_box.setEnabled(enable)
-        # Enable/disable Scan Button
-        # self.ui.scan_button.setEnabled(enable)
-        # Disable move to buttons in LMFitDialog
-        self.ui.findChild(LMFitDialog).set_actions_enabled(enable)
-
-    def _customise_buttons(self) -> None:
-        """Add action buttons for the Action Control.
-        In addition, we are adding a callback to also clear the queue to the stop button
-        to ensure that upon clicking the button, no scans from another client may be queued
-        which would be confusing without the queue widget.
-        """
-        fit_dialog = self.ui.findChild(LMFitDialog)
-        fit_dialog.active_action_list = ["center", "center1", "center2"]
-        fit_dialog.move_action.connect(self.move_to_center)
-        stop_button = self.ui.findChild(StopButton)
-        stop_button.button.setText("Stop and Clear Queue")
-        stop_button.button.clicked.connect(self.clear_queue)
-
-    def _customise_bec_waveform_widget(self) -> None:
-        """Customise the BEC Waveform Widget, i.e. clear the toolbar"""
-        self.waveform.toolbar.clear()
-
-    def _setup_motor_indicator(self) -> None:
-        """Setup the arrow item"""
-        self.waveform.waveform.tick_item.add_to_plot()
-        positioner_box = self.ui.findChild(PositionerGroup)
-        positioner_box.position_update.connect(self.waveform.waveform.tick_item.set_position)
-        self.waveform.waveform.tick_item.set_position(0)
-
-    def _setup_signal_combobox(self) -> None:
-        """Setup signal selection"""
-        # FIXME after changing the filtering in the combobox
-        signals = [name for name in self.dev if isinstance(self.dev.get(name), BECSignal)]
-        self.ui.device_combobox_2.setCurrentText(signals[0])
-        self.ui.device_combobox_2.set_device_filter("Signal")
-
-    def _setup_progress_bar(self) -> None:
-        """Setup progress bar"""
-        # FIXME once the BECScanProgressBar is implemented
-        self.progress_bar = self.ui.findChild(BECProgressBar, "bec_progress_bar")
-        self.progress_bar.set_value(0)
-        self.ui.bec_waveform_widget.new_scan.connect(self.reset_progress_bar)
-        self.bec_dispatcher.connect_slot(self.update_progress_bar, MessageEndpoints.scan_progress())
-
-    def close(self):
-        logger.info("Disconnecting", repr(self.bec_dispatcher))
-        self.bec_dispatcher.disconnect_all()
-        logger.info("Shutting down BEC Client", repr(self.client))
-        self.client.shutdown()
-
-
-def main():
-    import sys
-
-    app = QApplication(sys.argv)
-    icon = QIcon()
-    icon.addFile(
-        os.path.join(MODULE_PATH, "assets", "app_icons", "alignment_1d.png"), size=QSize(48, 48)
-    )
-    app.setWindowIcon(icon)
-    window = Alignment1D()
-    window.show()
-    sys.exit(app.exec_())
-
-
-if __name__ == "__main__":  # pragma: no cover
-    main()

bec_widgets/applications/alignment/alignment_1d/alignment_1d.ui

@@ -1,615 +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>1611</width>
-    <height>1019</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Alignment tool</string>
-  </property>
-  <widget class="QWidget" name="widget">
-   <layout class="QVBoxLayout" name="verticalLayout_2">
-    <item>
-     <widget class="QWidget" name="widget" native="true">
-      <property name="sizePolicy">
-       <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
-        <horstretch>0</horstretch>
-        <verstretch>0</verstretch>
-       </sizepolicy>
-      </property>
-      <layout class="QHBoxLayout" name="horizontalLayout_5">
-       <item>
-        <widget class="DarkModeButton" name="dark_mode_button"/>
-       </item>
-       <item>
-        <spacer name="horizontalSpacer_6">
-         <property name="orientation">
-          <enum>Qt::Orientation::Horizontal</enum>
-         </property>
-         <property name="sizeHint" stdset="0">
-          <size>
-           <width>40</width>
-           <height>20</height>
-          </size>
-         </property>
-        </spacer>
-       </item>
-       <item>
-        <widget class="BECStatusBox" name="bec_status_box">
-         <property name="compact_view" stdset="0">
-          <bool>true</bool>
-         </property>
-         <property name="label" stdset="0">
-          <string>BEC Servers</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <spacer name="horizontalSpacer_3">
-         <property name="orientation">
-          <enum>Qt::Orientation::Horizontal</enum>
-         </property>
-         <property name="sizeHint" stdset="0">
-          <size>
-           <width>40</width>
-           <height>20</height>
-          </size>
-         </property>
-        </spacer>
-       </item>
-       <item>
-        <widget class="BECQueue" name="bec_queue">
-         <property name="compact_view" stdset="0">
-          <bool>true</bool>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <spacer name="horizontalSpacer_5">
-         <property name="orientation">
-          <enum>Qt::Orientation::Horizontal</enum>
-         </property>
-         <property name="sizeHint" stdset="0">
-          <size>
-           <width>40</width>
-           <height>20</height>
-          </size>
-         </property>
-        </spacer>
-       </item>
-       <item>
-        <widget class="QRadioButton" name="radioButton">
-         <property name="enabled">
-          <bool>false</bool>
-         </property>
-         <property name="text">
-          <string>SLS Light On</string>
-         </property>
-         <property name="checkable">
-          <bool>true</bool>
-         </property>
-         <property name="checked">
-          <bool>true</bool>
-         </property>
-         <property name="autoExclusive">
-          <bool>false</bool>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <spacer name="horizontalSpacer_7">
-         <property name="orientation">
-          <enum>Qt::Orientation::Horizontal</enum>
-         </property>
-         <property name="sizeHint" stdset="0">
-          <size>
-           <width>40</width>
-           <height>20</height>
-          </size>
-         </property>
-        </spacer>
-       </item>
-       <item>
-        <widget class="QRadioButton" name="radioButton_3">
-         <property name="enabled">
-          <bool>false</bool>
-         </property>
-         <property name="text">
-          <string>BEAMLINE Checks</string>
-         </property>
-         <property name="checkable">
-          <bool>true</bool>
-         </property>
-         <property name="checked">
-          <bool>true</bool>
-         </property>
-         <property name="autoExclusive">
-          <bool>false</bool>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <spacer name="horizontalSpacer_4">
-         <property name="orientation">
-          <enum>Qt::Orientation::Horizontal</enum>
-         </property>
-         <property name="sizeHint" stdset="0">
-          <size>
-           <width>40</width>
-           <height>20</height>
-          </size>
-         </property>
-        </spacer>
-       </item>
-       <item>
-        <widget class="StopButton" name="stop_button">
-         <property name="sizePolicy">
-          <sizepolicy hsizetype="MinimumExpanding" vsizetype="MinimumExpanding">
-           <horstretch>0</horstretch>
-           <verstretch>0</verstretch>
-          </sizepolicy>
-         </property>
-         <property name="minimumSize">
-          <size>
-           <width>200</width>
-           <height>40</height>
-          </size>
-         </property>
-         <property name="maximumSize">
-          <size>
-           <width>200</width>
-           <height>40</height>
-          </size>
-         </property>
-        </widget>
-       </item>
-      </layout>
-     </widget>
-    </item>
-    <item>
-     <widget class="BECProgressBar" name="bec_progress_bar">
-      <property name="minimumSize">
-       <size>
-        <width>0</width>
-        <height>25</height>
-       </size>
-      </property>
-      <property name="maximumSize">
-       <size>
-        <width>16777215</width>
-        <height>25</height>
-       </size>
-      </property>
-     </widget>
-    </item>
-    <item>
-     <widget class="QTabWidget" name="tabWidget">
-      <property name="sizePolicy">
-       <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
-        <horstretch>0</horstretch>
-        <verstretch>0</verstretch>
-       </sizepolicy>
-      </property>
-      <property name="currentIndex">
-       <number>0</number>
-      </property>
-      <widget class="QWidget" name="ControlTab">
-       <attribute name="title">
-        <string>Alignment Control</string>
-       </attribute>
-       <layout class="QHBoxLayout" name="horizontalLayout_6">
-        <item>
-         <widget class="QWidget" name="widget_4" native="true">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
-            <horstretch>1</horstretch>
-            <verstretch>0</verstretch>
-           </sizepolicy>
-          </property>
-          <layout class="QVBoxLayout" name="verticalLayout_3">
-           <item>
-            <widget class="ScanControl" name="scan_control">
-             <property name="current_scan" stdset="0">
-              <string>line_scan</string>
-             </property>
-             <property name="hide_arg_box" stdset="0">
-              <bool>false</bool>
-             </property>
-             <property name="hide_scan_selection_combobox" stdset="0">
-              <bool>true</bool>
-             </property>
-             <property name="hide_add_remove_buttons" stdset="0">
-              <bool>true</bool>
-             </property>
-            </widget>
-           </item>
-           <item>
-            <widget class="PositionerGroup" name="positioner_group"/>
-           </item>
-           <item>
-            <spacer name="verticalSpacer">
-             <property name="orientation">
-              <enum>Qt::Orientation::Vertical</enum>
-             </property>
-             <property name="sizeHint" stdset="0">
-              <size>
-               <width>20</width>
-               <height>40</height>
-              </size>
-             </property>
-            </spacer>
-           </item>
-          </layout>
-         </widget>
-        </item>
-        <item>
-         <widget class="QWidget" name="widget_3" native="true">
-          <property name="sizePolicy">
-           <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
-            <horstretch>4</horstretch>
-            <verstretch>0</verstretch>
-           </sizepolicy>
-          </property>
-          <layout class="QVBoxLayout" name="verticalLayout">
-           <item>
-            <widget class="QWidget" name="widget_2" native="true">
-             <property name="sizePolicy">
-              <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
-               <horstretch>0</horstretch>
-               <verstretch>0</verstretch>
-              </sizepolicy>
-             </property>
-             <layout class="QHBoxLayout" name="horizontalLayout_3">
-              <item>
-               <widget class="QLabel" name="label_2">
-                <property name="font">
-                 <font/>
-                </property>
-                <property name="text">
-                 <string>Monitor</string>
-                </property>
-               </widget>
-              </item>
-              <item>
-               <widget class="DeviceComboBox" name="device_combobox_2"/>
-              </item>
-              <item>
-               <widget class="QLabel" name="label_3">
-                <property name="font">
-                 <font/>
-                </property>
-                <property name="text">
-                 <string>LMFit Model</string>
-                </property>
-               </widget>
-              </item>
-              <item>
-               <widget class="DapComboBox" name="dap_combo_box"/>
-              </item>
-              <item>
-               <widget class="QLabel" name="label">
-                <property name="text">
-                 <string>Enable ROI</string>
-                </property>
-               </widget>
-              </item>
-              <item>
-               <widget class="ToggleSwitch" name="toggle_switch">
-                <property name="sizePolicy">
-                 <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
-                  <horstretch>3</horstretch>
-                  <verstretch>0</verstretch>
-                 </sizepolicy>
-                </property>
-                <property name="toolTip">
-                 <string>Activate linear region select for LMFit</string>
-                </property>
-                <property name="layoutDirection">
-                 <enum>Qt::LayoutDirection::LeftToRight</enum>
-                </property>
-                <property name="checked" stdset="0">
-                 <bool>false</bool>
-                </property>
-               </widget>
-              </item>
-              <item>
-               <spacer name="horizontalSpacer_8">
-                <property name="orientation">
-                 <enum>Qt::Orientation::Horizontal</enum>
-                </property>
-                <property name="sizeHint" stdset="0">
-                 <size>
-                  <width>40</width>
-                  <height>20</height>
-                 </size>
-                </property>
-               </spacer>
-              </item>
-             </layout>
-            </widget>
-           </item>
-           <item>
-            <widget class="BECWaveformWidget" name="bec_waveform_widget">
-             <property name="sizePolicy">
-              <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
-               <horstretch>0</horstretch>
-               <verstretch>1</verstretch>
-              </sizepolicy>
-             </property>
-             <property name="minimumSize">
-              <size>
-               <width>600</width>
-               <height>450</height>
-              </size>
-             </property>
-             <property name="clear_curves_on_plot_update" stdset="0">
-              <bool>true</bool>
-             </property>
-            </widget>
-           </item>
-           <item>
-            <widget class="LMFitDialog" name="lm_fit_dialog">
-             <property name="sizePolicy">
-              <sizepolicy hsizetype="Preferred" vsizetype="Minimum">
-               <horstretch>0</horstretch>
-               <verstretch>0</verstretch>
-              </sizepolicy>
-             </property>
-             <property name="minimumSize">
-              <size>
-               <width>0</width>
-               <height>190</height>
-              </size>
-             </property>
-             <property name="always_show_latest" stdset="0">
-              <bool>true</bool>
-             </property>
-             <property name="hide_curve_selection" stdset="0">
-              <bool>true</bool>
-             </property>
-             <property name="hide_summary" stdset="0">
-              <bool>true</bool>
-             </property>
-            </widget>
-           </item>
-          </layout>
-         </widget>
-        </item>
-       </layout>
-      </widget>
-      <widget class="QWidget" name="tab_2">
-       <attribute name="title">
-        <string>Logbook</string>
-       </attribute>
-       <layout class="QHBoxLayout" name="horizontalLayout_4">
-        <property name="leftMargin">
-         <number>2</number>
-        </property>
-        <property name="topMargin">
-         <number>2</number>
-        </property>
-        <property name="rightMargin">
-         <number>2</number>
-        </property>
-        <property name="bottomMargin">
-         <number>2</number>
-        </property>
-        <item>
-         <widget class="WebsiteWidget" name="website_widget">
-          <property name="url" stdset="0">
-           <string>https://scilog.psi.ch/login</string>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </widget>
-     </widget>
-    </item>
-   </layout>
-  </widget>
- </widget>
- <customwidgets>
-  <customwidget>
-   <class>DapComboBox</class>
-   <extends>QWidget</extends>
-   <header>dap_combo_box</header>
-  </customwidget>
-  <customwidget>
-   <class>StopButton</class>
-   <extends>QWidget</extends>
-   <header>stop_button</header>
-  </customwidget>
-  <customwidget>
-   <class>WebsiteWidget</class>
-   <extends>QWidget</extends>
-   <header>website_widget</header>
-  </customwidget>
-  <customwidget>
-   <class>BECQueue</class>
-   <extends>QWidget</extends>
-   <header>bec_queue</header>
-  </customwidget>
-  <customwidget>
-   <class>ScanControl</class>
-   <extends>QWidget</extends>
-   <header>scan_control</header>
-  </customwidget>
-  <customwidget>
-   <class>ToggleSwitch</class>
-   <extends>QWidget</extends>
-   <header>toggle_switch</header>
-  </customwidget>
-  <customwidget>
-   <class>BECProgressBar</class>
-   <extends>QWidget</extends>
-   <header>bec_progress_bar</header>
-  </customwidget>
-  <customwidget>
-   <class>DarkModeButton</class>
-   <extends>QWidget</extends>
-   <header>dark_mode_button</header>
-  </customwidget>
-  <customwidget>
-   <class>PositionerGroup</class>
-   <extends>QWidget</extends>
-   <header>positioner_group</header>
-  </customwidget>
-  <customwidget>
-   <class>BECWaveformWidget</class>
-   <extends>QWidget</extends>
-   <header>bec_waveform_widget</header>
-  </customwidget>
-  <customwidget>
-   <class>DeviceComboBox</class>
-   <extends>QComboBox</extends>
-   <header>device_combobox</header>
-  </customwidget>
-  <customwidget>
-   <class>LMFitDialog</class>
-   <extends>QWidget</extends>
-   <header>lm_fit_dialog</header>
-  </customwidget>
-  <customwidget>
-   <class>BECStatusBox</class>
-   <extends>QWidget</extends>
-   <header>bec_status_box</header>
-  </customwidget>
- </customwidgets>
- <resources/>
- <connections>
-  <connection>
-   <sender>toggle_switch</sender>
-   <signal>enabled(bool)</signal>
-   <receiver>bec_waveform_widget</receiver>
-   <slot>toogle_roi_select(bool)</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>1042</x>
-     <y>212</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>1416</x>
-     <y>322</y>
-    </hint>
-   </hints>
-  </connection>
-  <connection>
-   <sender>bec_waveform_widget</sender>
-   <signal>dap_summary_update(QVariantMap,QVariantMap)</signal>
-   <receiver>lm_fit_dialog</receiver>
-   <slot>update_summary_tree(QVariantMap,QVariantMap)</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>1099</x>
-     <y>258</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>1157</x>
-     <y>929</y>
-    </hint>
-   </hints>
-  </connection>
-  <connection>
-   <sender>device_combobox_2</sender>
-   <signal>currentTextChanged(QString)</signal>
-   <receiver>bec_waveform_widget</receiver>
-   <slot>plot(QString)</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>577</x>
-     <y>215</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>1416</x>
-     <y>427</y>
-    </hint>
-   </hints>
-  </connection>
-  <connection>
-   <sender>device_combobox_2</sender>
-   <signal>currentTextChanged(QString)</signal>
-   <receiver>dap_combo_box</receiver>
-   <slot>select_y_axis(QString)</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>577</x>
-     <y>215</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>909</x>
-     <y>215</y>
-    </hint>
-   </hints>
-  </connection>
-  <connection>
-   <sender>dap_combo_box</sender>
-   <signal>new_dap_config(QString,QString,QString)</signal>
-   <receiver>bec_waveform_widget</receiver>
-   <slot>add_dap(QString,QString,QString)</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>909</x>
-     <y>215</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>1416</x>
-     <y>447</y>
-    </hint>
-   </hints>
-  </connection>
-  <connection>
-   <sender>scan_control</sender>
-   <signal>device_selected(QString)</signal>
-   <receiver>positioner_group</receiver>
-   <slot>set_positioners(QString)</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>230</x>
-     <y>306</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>187</x>
-     <y>926</y>
-    </hint>
-   </hints>
-  </connection>
-  <connection>
-   <sender>scan_control</sender>
-   <signal>device_selected(QString)</signal>
-   <receiver>bec_waveform_widget</receiver>
-   <slot>set_x(QString)</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>187</x>
-     <y>356</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>972</x>
-     <y>509</y>
-    </hint>
-   </hints>
-  </connection>
-  <connection>
-   <sender>scan_control</sender>
-   <signal>device_selected(QString)</signal>
-   <receiver>dap_combo_box</receiver>
-   <slot>select_x_axis(QString)</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>187</x>
-     <y>356</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>794</x>
-     <y>202</y>
-    </hint>
-   </hints>
-  </connection>
- </connections>
-</ui>

bec_widgets/applications/bec_app.py

@@ -1,84 +0,0 @@
-"""
-Launcher for BEC GUI Applications
-
-Application must be located in bec_widgets/applications ;
-in order for the launcher to find the application, it has to be put in
-a subdirectory with the same name as the main Python module:
-
-/bec_widgets/applications
-    ├── alignment
-    │   └── alignment_1d
-    │       └── alignment_1d.py
-    ├── other_app
-        └── other_app.py
-
-The tree above would contain 2 applications, alignment_1d and other_app.
-
-The Python module for the application must have `if __name__ == "__main__":`
-in order for the launcher to execute it (it is run with `python -m`).
-"""
-
-import argparse
-import os
-import sys
-
-MODULE_PATH = os.path.dirname(__file__)
-
-
-def find_apps(base_dir: str) -> list[str]:
-    matching_modules = []
-
-    for root, dirs, files in os.walk(base_dir):
-        parent_dir = os.path.basename(root)
-
-        for file in files:
-            if file.endswith(".py") and file != "__init__.py":
-                file_name_without_ext = os.path.splitext(file)[0]
-
-                if file_name_without_ext == parent_dir:
-                    rel_path = os.path.relpath(root, base_dir)
-                    module_path = rel_path.replace(os.sep, ".")
-
-                    module_name = f"{module_path}.{file_name_without_ext}"
-                    matching_modules.append((file_name_without_ext, module_name))
-
-    return matching_modules
-
-
-def main():
-    parser = argparse.ArgumentParser(description="BEC application launcher")
-
-    parser.add_argument("-m", "--module", type=str, help="The module to run (string argument).")
-
-    # Add a positional argument for the module, which acts as a fallback if -m is not provided
-    parser.add_argument(
-        "positional_module",
-        nargs="?",  # This makes the positional argument optional
-        help="Positional argument that is treated as module if -m is not specified.",
-    )
-
-    args = parser.parse_args()
-    # If the -m/--module is not provided, fallback to the positional argument
-    module = args.module if args.module else args.positional_module
-
-    if module:
-        for app_name, app_module in find_apps(MODULE_PATH):
-            if module in (app_name, app_module):
-                print("Starting:", app_name)
-                python_executable = sys.executable
-
-                # Replace the current process with the new Python module
-                os.execvp(
-                    python_executable,
-                    [python_executable, "-m", f"bec_widgets.applications.{app_module}"],
-                )
-        print(f"Error: cannot find application {module}")
-
-    # display list of apps
-    print("Available applications:")
-    for app, _ in find_apps(MODULE_PATH):
-        print(f"  - {app}")
-
-
-if __name__ == "__main__":  # pragma: no cover
-    main()

bec_widgets/applications/bw_launch.py

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

@@ -0,0 +1,583 @@
+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.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, UILaunchWindow
+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, BECWidget] = get_all_plugin_widgets()
+        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 = BECMainWindow()
+                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 the custom UI file
+        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)
+
+        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.")
+
+        if widget.attrib.get("class") == "QMainWindow":
+            raise ValueError(
+                "Loading a QMainWindow from a UI file is currently not supported. "
+                "If you need this, please contact the BEC team or create a ticket on gitlab.psi.ch/bec/bec_widgets."
+            )
+
+        window = UILaunchWindow(object_name=filename)
+        QApplication.processEvents()
+        result_widget = UILoader(window).loader(ui_file)
+        window.setCentralWidget(result_widget)
+        window.setWindowTitle(f"BEC - {window.object_name}")
+        window.show()
+        logger.info(f"Object name of new instance: {result_widget.objectName()}, {window.gui_id}")
+        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 = BECMainWindow()
+
+        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) <= 1
+
+    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/cli/__init__.py

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

bec_widgets/cli/auto_updates.py

@@ -1,169 +0,0 @@
-# TODO autoupdate disabled
-# from __future__ import annotations
-#
-# import threading
-# from queue import Queue
-# 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
-#         self._default_dock = None
-#         self._default_fig = None
-#
-#     def start_default_dock(self):
-#         """
-#         Create a default dock for the auto updates.
-#         """
-#         self.dock_name = "default_figure"
-#         self._default_dock = self.gui.new(self.dock_name)
-#         self._default_dock.new("BECFigure")
-#         self._default_fig = self._default_dock.elements_list[0]
-#
-#     @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.
-#         """
-#         return self._default_fig
-#
-#     def do_update(self, msg):
-#         """
-#         Run the update function if enabled.
-#         """
-#         if not self.enabled:
-#             return
-#         if msg.status != "open":
-#             return
-#         info = self.get_scan_info(msg)
-#         return self.handler(info)
-#
-#     def get_selected_device(self, 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:
-#             return self.simple_line_scan(info)
-#         if info.scan_name == "grid_scan" and info.scan_report_devices:
-#             return self.simple_grid_scan(info)
-#         if info.scan_report_devices:
-#             return self.best_effort(info)
-#
-#     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]
-#         selected_device = yield self.gui.selected_device
-#         dev_y = self.get_selected_device(info.monitored_devices, selected_device)
-#         if not dev_y:
-#             return
-#         yield fig.clear_all()
-#         yield fig.plot(
-#             x_name=dev_x,
-#             y_name=dev_y,
-#             label=f"Scan {info.scan_number} - {dev_y}",
-#             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]
-#         selected_device = yield self.gui.selected_device
-#         dev_z = self.get_selected_device(info.monitored_devices, selected_device)
-#         yield fig.clear_all()
-#         yield fig.plot(
-#             x_name=dev_x,
-#             y_name=dev_y,
-#             z_name=dev_z,
-#             label=f"Scan {info.scan_number} - {dev_z}",
-#             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]
-#         selected_device = yield self.gui.selected_device
-#         dev_y = self.get_selected_device(info.monitored_devices, selected_device)
-#         if not dev_y:
-#             return
-#         yield fig.clear_all()
-#         yield fig.plot(
-#             x_name=dev_x,
-#             y_name=dev_y,
-#             label=f"Scan {info.scan_number} - {dev_y}",
-#             title=f"Scan {info.scan_number}",
-#             x_label=dev_x,
-#             y_label=dev_y,
-#         )

bec_widgets/cli/client_utils.py

@@ -10,25 +10,31 @@ import threading
 import time
 from contextlib import contextmanager
 from threading import Lock
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Literal, TypeAlias, cast
 
 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 bec_lib.utils.import_utils import lazy_import_from
 from rich.console import Console
 from rich.table import Table
 
 import bec_widgets.cli.client as client
 from bec_widgets.cli.rpc.rpc_base import RPCBase, RPCReference
+from bec_widgets.utils.serialization import register_serializer_extension
 
 if TYPE_CHECKING:  # pragma: no cover
-    from bec_lib.redis_connector import StreamMessage
+    from bec_lib.messages import GUIRegistryStateMessage
 else:
-    StreamMessage = lazy_import_from("bec_lib.redis_connector", ("StreamMessage",))
+    GUIRegistryStateMessage = lazy_import_from("bec_lib.messages", "GUIRegistryStateMessage")
 
 logger = bec_logger.logger
 
-IGNORE_WIDGETS = ["BECDockArea", "BECDock"]
+IGNORE_WIDGETS = ["LaunchWindow"]
+
+RegistryState: TypeAlias = dict[
+    Literal["gui_id", "name", "widget_class", "config", "__rpc__", "container_proxy"],
+    str | bool | dict,
+]
 
 # pylint: disable=redefined-outer-scope
 
@@ -67,7 +73,11 @@ def _get_output(process, logger) -> None:
 
 
 def _start_plot_process(
-    gui_id: str, gui_class: type, gui_class_id: str, config: dict | str, logger=None
+    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]:
     """
     Start the plot in a new process.
@@ -82,7 +92,7 @@ def _start_plot_process(
         "--id",
         gui_id,
         "--gui_class",
-        gui_class.__name__,
+        gui_class,
         "--gui_class_id",
         gui_class_id,
         "--hide",
@@ -195,25 +205,28 @@ class BECGuiClient(RPCBase):
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
         self._lock = Lock()
-        self._default_dock_name = "bec"
-        self._auto_updates_enabled = True
-        self._auto_updates = None
+        self._anchor_widget = "launcher"
         self._killed = False
-        self._top_level: dict[str, client.BECDockArea] = {}
+        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._exposed_widgets = []
-        self._server_registry = {}
-        self._ipython_registry = {}
+        self._server_registry: dict[str, RegistryState] = {}
+        self._ipython_registry: dict[str, RPCReference] = {}
         self.available_widgets = AvailableWidgetsNamespace()
+        register_serializer_extension()
 
     ####################
     #### Client API ####
     ####################
 
+    @property
+    def launcher(self) -> RPCBase:
+        """The launcher object."""
+        return RPCBase(gui_id=f"{self._gui_id}:launcher", parent=self, object_name="launcher")
+
     def connect_to_gui_server(self, gui_id: str) -> None:
         """Connect to a GUI server"""
         # Unregister the old callback
@@ -221,21 +234,25 @@ class BECGuiClient(RPCBase):
             MessageEndpoints.gui_registry_state(self._gui_id), cb=self._handle_registry_update
         )
         self._gui_id = gui_id
-        # Get the registry state
-        msgs = self._client.connector.xread(
-            MessageEndpoints.gui_registry_state(self._gui_id), count=1
-        )
-        if msgs:
-            self._handle_registry_update(msgs[0])
+
+        # reset the namespace
+        self._update_dynamic_namespace({})
+        self._server_registry = {}
+        self._top_level = {}
+        self._ipython_registry = {}
+
         # Register the new callback
         self._client.connector.register(
-            MessageEndpoints.gui_registry_state(self._gui_id), cb=self._handle_registry_update
+            MessageEndpoints.gui_registry_state(self._gui_id),
+            cb=self._handle_registry_update,
+            parent=self,
+            from_start=True,
         )
 
     @property
     def windows(self) -> dict:
         """Dictionary with dock areas in the GUI."""
-        return self._top_level
+        return {widget.object_name: widget for widget in self._top_level.values()}
 
     @property
     def window_list(self) -> list:
@@ -261,6 +278,8 @@ class BECGuiClient(RPCBase):
         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.
 
@@ -275,14 +294,12 @@ class BECGuiClient(RPCBase):
             self.start(wait=True)
         if wait:
             with wait_for_server(self):
-                rpc_client = RPCBase(gui_id=f"{self._gui_id}:window", parent=self)
-                widget = rpc_client._run_rpc(
-                    "new_dock_area", name, geometry
+                widget = self.launcher._run_rpc(
+                    "launch", launch_script=launch_script, name=name, geometry=geometry, **kwargs
                 )  # pylint: disable=protected-access
                 return widget
-        rpc_client = RPCBase(gui_id=f"{self._gui_id}:window", parent=self)
-        widget = rpc_client._run_rpc(
-            "new_dock_area", name, geometry
+        widget = self.launcher._run_rpc(
+            "launch", launch_script=launch_script, name=name, geometry=geometry, **kwargs
         )  # pylint: disable=protected-access
         return widget
 
@@ -352,11 +369,13 @@ class BECGuiClient(RPCBase):
         # 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())) == 0:
+            if len(list(self._server_registry.keys())) < 2 or not hasattr(
+                self, self._anchor_widget
+            ):
                 time.sleep(0.1)
             else:
                 break
-        self._do_show_all()
+
         self._gui_started_event.set()
 
     def _start_server(self, wait: bool = False) -> None:
@@ -369,8 +388,7 @@ class BECGuiClient(RPCBase):
             self._gui_started_event.clear()
             self._process, self._process_output_processing_thread = _start_plot_process(
                 self._gui_id,
-                self.__class__,
-                gui_class_id=self._default_dock_name,
+                gui_class_id="bec",
                 config=self._client._service_config.config,  # pylint: disable=protected-access
                 logger=logger,
             )
@@ -380,7 +398,7 @@ class BECGuiClient(RPCBase):
                     if callable(callback):
                         callback()
                 finally:
-                    threading.current_thread().cancel()
+                    threading.current_thread().cancel()  # type: ignore
 
             self._gui_started_timer = RepeatTimer(
                 0.5, lambda: self._gui_is_alive() and gui_started_callback(self._gui_post_startup)
@@ -390,25 +408,27 @@ class BECGuiClient(RPCBase):
         if wait:
             self._gui_started_event.wait()
 
-    def _dump(self):
-        rpc_client = RPCBase(gui_id=f"{self._gui_id}:window", parent=self)
-        return rpc_client._run_rpc("_dump")
-
     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
+            MessageEndpoints.gui_registry_state(self._gui_id),
+            cb=self._handle_registry_update,
+            parent=self,
         )
         return self._start_server(wait=wait)
 
-    def _handle_registry_update(self, msg: StreamMessage) -> None:
+    @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._server_registry = msg["data"].state
-        self._update_dynamic_namespace()
+        self = parent
+        self._server_registry = cast(dict[str, RegistryState], msg["data"].state)
+        self._update_dynamic_namespace(self._server_registry)
 
     def _do_show_all(self):
-        rpc_client = RPCBase(gui_id=f"{self._gui_id}:window", parent=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()
@@ -419,124 +439,72 @@ class BECGuiClient(RPCBase):
 
     def _hide_all(self):
         with wait_for_server(self):
-            rpc_client = RPCBase(gui_id=f"{self._gui_id}:window", parent=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()
 
-    def _update_dynamic_namespace(self):
-        """Update the dynamic name space"""
-        # Clear the top level
-        self._top_level.clear()
-        # First we update the name space based on the new registry state
-        self._add_registry_to_namespace()
-        # Then we clear the ipython registry from old objects
-        self._cleanup_ipython_registry()
+    def _update_dynamic_namespace(self, server_registry: dict):
+        """
+        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.
 
-    def _cleanup_ipython_registry(self):
-        """Cleanup the ipython registry"""
-        names_in_registry = list(self._ipython_registry.keys())
-        names_in_server_state = list(self._server_registry.keys())
-        remove_ids = list(set(names_in_registry) - set(names_in_server_state))
-        for widget_id in remove_ids:
-            self._ipython_registry.pop(widget_id)
-        self._cleanup_rpc_references_on_rpc_base(remove_ids)
-        # Clear the exposed widgets
-        self._exposed_widgets.clear()  # No longer needed I think
+        Args:
+            server_registry (dict): The server registry
+        """
+        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
 
-    def _cleanup_rpc_references_on_rpc_base(self, remove_ids: list[str]) -> None:
-        """Cleanup the rpc references on the RPCBase object"""
-        if not remove_ids:
-            return
-        for widget in self._ipython_registry.values():
-            to_delete = []
-            for attr_name, gui_id in widget._rpc_references.items():
-                if gui_id in remove_ids:
-                    to_delete.append(attr_name)
-            for attr_name in to_delete:
-                if hasattr(widget, attr_name):
-                    delattr(widget, attr_name)
-                if attr_name.startswith("elements."):
-                    delattr(widget.elements, attr_name.split(".")[1])
-                widget._rpc_references.pop(attr_name)
+        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)
 
-    def _set_dynamic_attributes(self, obj: object, name: str, value: Any) -> None:
-        """Add an object to the namespace"""
-        setattr(obj, name, value)
-
-    def _update_rpc_references(self, widget: RPCBase, name: str, gui_id: str) -> None:
-        """Update the RPC references"""
-        widget._rpc_references[name] = gui_id
-
-    def _add_registry_to_namespace(self) -> None:
-        """Add registry to namespace"""
-        # Add dock areas
-        dock_area_states = [
-            state
-            for state in self._server_registry.values()
-            if state["widget_class"] == "BECDockArea"
+        removed_widgets = [
+            widget.object_name for widget in self._top_level.values() if widget._is_deleted()
         ]
-        for state in dock_area_states:
-            dock_area_ref = self._add_widget(state, self)
-            dock_area = self._ipython_registry.get(dock_area_ref._gui_id)
-            if not hasattr(dock_area, "elements"):
-                self._set_dynamic_attributes(dock_area, "elements", WidgetNameSpace())
-            self._set_dynamic_attributes(self, dock_area.widget_name, dock_area_ref)
-            # Keep track of rpc references on RPCBase object
-            self._update_rpc_references(self, dock_area.widget_name, dock_area_ref._gui_id)
-            # Add dock_area to the top level
-            self._top_level[dock_area_ref.widget_name] = dock_area_ref
-            self._exposed_widgets.append(dock_area_ref._gui_id)
 
-            # Add docks
-            dock_states = [
-                state
-                for state in self._server_registry.values()
-                if state["config"].get("parent_id", "") == dock_area_ref._gui_id
-            ]
-            for state in dock_states:
-                dock_ref = self._add_widget(state, dock_area)
-                dock = self._ipython_registry.get(dock_ref._gui_id)
-                self._set_dynamic_attributes(dock_area, dock_ref.widget_name, dock_ref)
-                # Keep track of rpc references on RPCBase object
-                self._update_rpc_references(dock_area, dock_ref.widget_name, dock_ref._gui_id)
-                # Keep track of exposed docks
-                self._exposed_widgets.append(dock_ref._gui_id)
+        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)
 
-                # Add widgets
-                widget_states = [
-                    state
-                    for state in self._server_registry.values()
-                    if state["config"].get("parent_id", "") == dock_ref._gui_id
-                ]
-                for state in widget_states:
-                    widget_ref = self._add_widget(state, dock)
-                    self._set_dynamic_attributes(dock, widget_ref.widget_name, widget_ref)
-                    self._set_dynamic_attributes(
-                        dock_area.elements, widget_ref.widget_name, widget_ref
-                    )
-                    # Keep track of rpc references on RPCBase object
-                    self._update_rpc_references(
-                        dock_area, f"elements.{widget_ref.widget_name}", widget_ref._gui_id
-                    )
-                    self._update_rpc_references(dock, widget_ref.widget_name, widget_ref._gui_id)
-                    # Keep track of exposed widgets
-                    self._exposed_widgets.append(widget_ref._gui_id)
+        for gui_id, widget_ref in top_level_widgets.items():
+            setattr(self, widget_ref.object_name, widget_ref)
 
-    def _add_widget(self, state: dict, parent: object) -> RPCReference:
+        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.
         """
-        name = state["name"]
+        object_name = state["object_name"]
         gui_id = state["gui_id"]
-        widget_class = getattr(client, state["widget_class"])
+        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, name=name, parent=parent)
+            widget = widget_class(gui_id=gui_id, object_name=object_name, parent=parent)
             self._ipython_registry[gui_id] = widget
         else:
             widget = obj

bec_widgets/cli/generate_cli.py

@@ -34,13 +34,29 @@ else:
 
 
 class ClientGenerator:
-    def __init__(self):
-        self.header = """# This file was automatically generated by generate_cli.py\n
+    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
-import enum
-from typing import Literal, Optional, overload
+{base_imports}
+from bec_lib.logger import bec_logger
 
 from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call
+{"from bec_widgets.utils.bec_plugin_helper import get_all_plugin_widgets, get_plugin_client_module" if self._base else ""}
+
+logger = bec_logger.logger
 
 # pylint: skip-file"""
 
@@ -67,6 +83,7 @@ from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call
 
         self.write_client_enum(rpc_top_level_classes)
         for cls in connector_classes:
+            logger.debug(f"generating RPC client class for {cls.__name__}")
             self.content += "\n\n"
             self.generate_content_for_class(cls)
 
@@ -74,10 +91,14 @@ from bec_widgets.cli.rpc.rpc_base import RPCBase, rpc_call
         """
         Write the client enum to the content.
         """
-        self.content += """
+        if self._base:
+            self.content += """
 class _WidgetsEnumType(str, enum.Enum):
     \"\"\" Enum for the available widgets, to be generated programatically  \"\"\"
     ...
+    """
+
+        self.content += """
 
 _Widgets = {
     """
@@ -85,8 +106,35 @@ _Widgets = {
             self.content += f'"{cls.__name__}": "{cls.__name__}",\n    '
 
         self.content += """}
-Widgets = _WidgetsEnumType("Widgets", _Widgets)
-        """
+"""
+        if self._base:
+            self.content += """
+
+try:
+    _plugin_widgets = get_all_plugin_widgets()
+    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))}")
+"""
 
     def generate_content_for_class(self, cls):
         """
@@ -175,18 +223,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.FileMode(line_length=100))
+            formatted_content = black.format_str(full_content, mode=black.Mode(line_length=100))
         except black.NothingChanged:
             formatted_content = full_content
 
-        isort.Config(
+        config = isort.Config(
             profile="black",
             line_length=100,
             multi_line_output=3,
-            include_trailing_comma=True,
+            include_trailing_comma=False,
             known_first_party=["bec_widgets"],
         )
-        formatted_content = isort.code(formatted_content)
+        formatted_content = isort.code(formatted_content, config=config)
 
         with open(file_name, "w", encoding="utf-8") as file:
             file.write(formatted_content)
@@ -199,38 +247,59 @@ def main():
 
     parser = argparse.ArgumentParser(description="Auto-generate the client for RPC widgets")
     parser.add_argument(
-        "--module-name",
+        "--target",
         action="store",
         type=str,
-        default="bec_widgets",
-        help="Which module to generate plugin files for (default: bec_widgets, example: my_plugin_repo.bec_widgets)",
+        help="Which package to generate plugin files for. Should be installed in the local environment (example: my_plugin_repo)",
     )
 
     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}")
 
+    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"
+
     try:
-        module = importlib.import_module(args.module_name)
+        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 {args.module_name} for code generation: {e}")
+        logger.error(f"Failed to load module {module_name} for code generation: {e}")
         return
 
-    client_path = module_dir / "client.py"
+    client_path = module_dir / client_subdir / "client.py"
 
-    rpc_classes = get_custom_classes(args.module_name)
+    rpc_classes = get_custom_classes(module_name)
     logger.info(f"Obtained classes with RPC objects: {rpc_classes!r}")
 
-    generator = ClientGenerator(base=args.module_name == "bec_widgets")
-    logger.info(f"Generating client.py")
+    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 plugins for: {cls}")
+        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
@@ -239,11 +308,16 @@ def main():
             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 {plugin.info.plugin_name_snake} - a file already exists.")
+            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 __name__ == "__main__":  # pragma: no cover
+    import sys
+
+    sys.argv = ["bw-generate-cli", "--target", "bec_widgets"]
     main()

bec_widgets/cli/rpc/rpc_base.py

@@ -4,20 +4,21 @@ import inspect
 import threading
 import uuid
 from functools import wraps
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
 from bec_lib.client import BECClient
 from bec_lib.endpoints import MessageEndpoints
 from bec_lib.utils.import_utils import lazy_import, lazy_import_from
 
-import bec_widgets.cli.client as client
-
 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")
-    # from bec_lib.connector import MessageObject
     MessageObject = lazy_import_from("bec_lib.connector", ("MessageObject",))
 
 # pylint: disable=protected-access
@@ -38,7 +39,7 @@ def rpc_call(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
+        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
@@ -88,16 +89,20 @@ 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"]:
+        if name in ["_registry", "_gui_id", "_is_deleted", "object_name"]:
             return super().__getattribute__(name)
         return self._registry[self._gui_id].__getattribute__(name)
 
-    @check_for_deleted_widget
-    def __getitem__(self, key):
-        return self._registry[self._gui_id].__getitem__(key)
+    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:
@@ -114,19 +119,23 @@ class RPCReference:
             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,
-        name: str | 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._name = name if name 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
@@ -136,23 +145,23 @@ class RPCBase:
     def __repr__(self):
         type_ = type(self)
         qualname = type_.__qualname__
-        return f"<{qualname} with name: {self.widget_name}>"
+        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 widget_name(self):
-        """
-        Get the widget name.
-        """
-        return self._name
-
-    @property
-    def _root(self):
+    def _root(self) -> BECGuiClient:
         """
         Get the root widget. This is the BECFigure widget that holds
         the anchor gui_id.
@@ -161,9 +170,17 @@ class RPCBase:
         # pylint: disable=protected-access
         while parent._parent is not None:
             parent = parent._parent
-        return parent
+        return parent  # type: ignore
 
-    def _run_rpc(self, method, *args, wait_for_rpc_response=True, timeout=3, **kwargs) -> Any:
+    def _run_rpc(
+        self,
+        method,
+        *args,
+        wait_for_rpc_response=True,
+        timeout=5,
+        gui_id: str | None = None,
+        **kwargs,
+    ) -> Any:
         """
         Run the RPC call.
 
@@ -171,6 +188,8 @@ class RPCBase:
             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:
@@ -179,7 +198,7 @@ class RPCBase:
         request_id = str(uuid.uuid4())
         rpc_msg = messages.GUIInstructionMessage(
             action=method,
-            parameter={"args": args, "kwargs": kwargs, "gui_id": self._gui_id},
+            parameter={"args": args, "kwargs": kwargs, "gui_id": gui_id or self._gui_id},
             metadata={"request_id": request_id},
         )
         # pylint: disable=protected-access
@@ -205,7 +224,11 @@ class RPCBase:
                 self._client.connector.unregister(
                     MessageEndpoints.gui_instruction_response(request_id), cb=self._on_rpc_response
                 )
-            # get class name
+
+            # 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")
@@ -213,10 +236,10 @@ class RPCBase:
             return self._create_widget_from_msg_result(msg_result)
 
     @staticmethod
-    def _on_rpc_response(msg: MessageObject, parent: RPCBase) -> None:
-        msg = msg.value
-        parent._msg_wait_event.set()
+    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:
@@ -236,13 +259,14 @@ class RPCBase:
 
             cls = getattr(client, cls)
             # The namespace of the object will be updated dynamically on the client side
-            # Therefor it is important to check if the object is already in the registry
+            # 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
@@ -258,3 +282,27 @@ class RPCBase:
         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,7 +1,7 @@
 from __future__ import annotations
 
 from functools import wraps
-from threading import Lock, RLock
+from threading import RLock
 from typing import TYPE_CHECKING, Callable
 from weakref import WeakValueDictionary
 
@@ -65,7 +65,7 @@ class RPCRegister:
         return register._broadcast_on_hold
 
     @broadcast_update
-    def add_rpc(self, rpc: QObject):
+    def add_rpc(self, rpc: BECConnector):
         """
         Add an RPC object to the register.
 
@@ -77,7 +77,7 @@ class RPCRegister:
         self._rpc_register[rpc.gui_id] = rpc
 
     @broadcast_update
-    def remove_rpc(self, rpc: str):
+    def remove_rpc(self, rpc: BECConnector):
         """
         Remove an RPC object from the register.
 
@@ -113,7 +113,7 @@ class RPCRegister:
         return connections
 
     def get_names_of_rpc_by_class_type(
-        self, cls: BECWidget | BECConnector | BECDock | BECDockArea
+        self, cls: type[BECWidget] | type[BECConnector] | type[BECDock] | type[BECDockArea]
     ) -> list[str]:
         """Get all the names of the widgets.
 
@@ -123,7 +123,7 @@ class RPCRegister:
         # 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._name for widget in widgets]
+        return [widget.object_name for widget in widgets]
 
     def broadcast(self):
         """
@@ -136,6 +136,18 @@ class RPCRegister:
         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.
@@ -170,7 +182,8 @@ class RPCRegisterBroadcast:
 
     def __exit__(self, *exc):
         """Exit the context manager"""
+
         self._call_depth -= 1  # Remove nested calls
-        if self._call_depth == 0:  # Last one to exit is repsonsible for broadcasting
+        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/rpc_widget_handler.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
-from typing import Any
-
 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
 
 
 class RPCWidgetHandler:
@@ -31,14 +31,12 @@ class RPCWidgetHandler:
         Returns:
             None
         """
-        from bec_widgets.utils.plugin_utils import get_custom_classes
-
         clss = get_custom_classes("bec_widgets")
-        self._widget_classes = {
+        self._widget_classes = get_all_plugin_widgets() | {
             cls.__name__: cls for cls in clss.widgets if cls.__name__ not in IGNORE_WIDGETS
         }
 
-    def create_widget(self, widget_type, name: str | None = None, **kwargs) -> BECWidget:
+    def create_widget(self, widget_type, **kwargs) -> BECWidget:
         """
         Create a widget from an RPC message.
 
@@ -52,7 +50,7 @@ class RPCWidgetHandler:
         """
         widget_class = self.widget_classes.get(widget_type)  # type: ignore
         if widget_class:
-            return widget_class(name=name, **kwargs)
+            return widget_class(**kwargs)
         raise ValueError(f"Unknown widget type: {widget_type}")
 
 

bec_widgets/cli/server.py

@@ -1,188 +1,26 @@
 from __future__ import annotations
 
-import functools
+import argparse
 import json
+import os
 import signal
 import sys
-import types
-from contextlib import contextmanager, redirect_stderr, redirect_stdout
-from typing import Union
+from contextlib import redirect_stderr, redirect_stdout
 
-from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import bec_logger
 from bec_lib.service_config import ServiceConfig
-from bec_lib.utils.import_utils import lazy_import
-from qtpy.QtCore import Qt, QTimer
-from redis.exceptions import RedisError
+from qtpy.QtCore import QSize, Qt
+from qtpy.QtGui import QIcon
+from qtpy.QtWidgets import QApplication
 
+import bec_widgets
+from bec_widgets.applications.launch_window import LaunchWindow
 from bec_widgets.cli.rpc.rpc_register import RPCRegister
-from bec_widgets.utils import BECDispatcher
-from bec_widgets.utils.bec_connector import BECConnector
-from bec_widgets.utils.error_popups import ErrorPopupUtility
-from bec_widgets.widgets.containers.dock import BECDockArea
-from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
+from bec_widgets.utils.bec_dispatcher import BECDispatcher
 
-messages = lazy_import("bec_lib.messages")
 logger = bec_logger.logger
 
-
-@contextmanager
-def rpc_exception_hook(err_func):
-    """This context replaces the popup message box for error display with a specific hook"""
-    # get error popup utility singleton
-    popup = ErrorPopupUtility()
-    # save current setting
-    old_exception_hook = popup.custom_exception_hook
-
-    # install err_func, if it is a callable
-    # IMPORTANT, Keep self here, because this method is overwriting the custom_exception_hook
-    # of the ErrorPopupUtility (popup instance) class.
-    def custom_exception_hook(self, exc_type, value, tb, **kwargs):
-        err_func({"error": popup.get_error_message(exc_type, value, tb)})
-
-    popup.custom_exception_hook = types.MethodType(custom_exception_hook, popup)
-
-    try:
-        yield popup
-    finally:
-        # restore state of error popup utility singleton
-        popup.custom_exception_hook = old_exception_hook
-
-
-class BECWidgetsCLIServer:
-
-    def __init__(
-        self,
-        gui_id: str,
-        dispatcher: BECDispatcher = None,
-        client=None,
-        config=None,
-        gui_class: type[BECDockArea] = BECDockArea,
-        gui_class_id: str = "bec",
-    ) -> None:
-        self.status = messages.BECStatus.BUSY
-        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
-        # register broadcast callback
-        self.rpc_register = RPCRegister()
-        self.rpc_register.add_callback(self.broadcast_registry_update)
-
-        self.dispatcher.connect_slot(
-            self.on_rpc_update, MessageEndpoints.gui_instructions(self.gui_id)
-        )
-
-        # Setup QTimer for heartbeat
-        self._heartbeat_timer = QTimer()
-        self._heartbeat_timer.timeout.connect(self.emit_heartbeat)
-        self._heartbeat_timer.start(200)
-
-        self.status = messages.BECStatus.RUNNING
-        with RPCRegister.delayed_broadcast():
-            self.gui = gui_class(parent=None, name=gui_class_id, gui_id=gui_class_id)
-        logger.success(f"Server started with gui_id: {self.gui_id}")
-        # Create initial object -> BECFigure or BECDockArea
-
-    def on_rpc_update(self, msg: dict, metadata: dict):
-        request_id = metadata.get("request_id")
-        logger.debug(f"Received RPC instruction: {msg}, metadata: {metadata}")
-        with rpc_exception_hook(functools.partial(self.send_response, request_id, False)):
-            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:
-                logger.error(f"Error while executing RPC instruction: {e}")
-                self.send_response(request_id, False, {"error": str(e)})
-            else:
-                logger.debug(f"RPC instruction executed successfully: {res}")
-                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):
-        # Run with rpc registry broadcast, but only once
-        with RPCRegister.delayed_broadcast():
-            logger.debug(f"Running RPC instruction: {method} with args: {args}, kwargs: {kwargs}")
-            method_obj = getattr(obj, method)
-            # check if the method accepts args and kwargs
-            if not callable(method_obj):
-                if not args:
-                    res = method_obj
-                else:
-                    setattr(obj, method, args[0])
-                    res = None
-            else:
-                res = method_obj(*args, **kwargs)
-
-            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):
-            config = obj.config.model_dump()
-            config["parent_id"] = obj.parent_id  # add parent_id to config
-            return {
-                "gui_id": obj.gui_id,
-                "name": (
-                    obj._name if hasattr(obj, "_name") else obj.__class__.__name__
-                ),  # pylint: disable=protected-access
-                "widget_class": obj.__class__.__name__,
-                "config": config,
-                "__rpc__": True,
-            }
-        return obj
-
-    def emit_heartbeat(self):
-        logger.trace(f"Emitting heartbeat for {self.gui_id}")
-        try:
-            self.client.connector.set(
-                MessageEndpoints.gui_heartbeat(self.gui_id),
-                messages.StatusMessage(name=self.gui_id, status=self.status, info={}),
-                expire=10,
-            )
-        except RedisError as exc:
-            logger.error(f"Error while emitting heartbeat: {exc}")
-
-    def broadcast_registry_update(self, connections: dict):
-        """
-        Broadcast the updated registry to all clients.
-        """
-
-        # We only need to broadcast the dock areas
-        data = {key: self.serialize_object(val) for key, val in connections.items()}
-        self.client.connector.xadd(
-            MessageEndpoints.gui_registry_state(self.gui_id),
-            msg_dict={"data": messages.GUIRegistryStateMessage(state=data)},
-            max_size=1,  # only single message in stream
-        )
-
-    def shutdown(self):  # TODO not sure if needed when cleanup is done at level of BECConnector
-        self.status = messages.BECStatus.IDLE
-        self._heartbeat_timer.stop()
-        self.emit_heartbeat()
-        logger.info("Succeded in shutting down gui")
-        self.client.shutdown()
+MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 
 
 class SimpleFileLikeFromLogOutputFunc:
@@ -199,44 +37,120 @@ class SimpleFileLikeFromLogOutputFunc:
             self._log_func(lines)
         self._buffer = [remaining]
 
+    @property
+    def encoding(self):
+        return "utf-8"
+
     def close(self):
         return
 
 
-def _start_server(
-    gui_id: str, gui_class: BECDockArea, gui_class_id: str = "bec", config: str | None = None
-):
-    if config:
-        try:
-            config = json.loads(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()
+class GUIServer:
+    """
+    This class is used to start the BEC GUI and is the main entry point for launching BEC Widgets in a subprocess.
+    """
 
-    # bec_logger.configure(
-    #     service_config.redis,
-    #     QtRedisConnector,
-    #     service_name="BECWidgetsCLIServer",
-    #     service_config=service_config.service_config,
-    # )
-    server = BECWidgetsCLIServer(
-        gui_id=gui_id, config=service_config, gui_class=gui_class, gui_class_id=gui_class_id
-    )
-    return server
+    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)
+        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 self.dispatcher:
+            self.dispatcher.stop_cli_server()
+            self.dispatcher.disconnect_all()
 
 
 def main():
-    import argparse
-    import os
-
-    from qtpy.QtCore import QSize
-    from qtpy.QtGui import QIcon
-    from qtpy.QtWidgets import QApplication
-
-    import bec_widgets
+    """
+    Main entry point for subprocesses that start a GUI server.
+    """
 
     parser = argparse.ArgumentParser(description="BEC Widgets CLI Server")
     parser.add_argument("--id", type=str, default="test", help="The id of the server")
@@ -256,69 +170,12 @@ def main():
 
     args = parser.parse_args()
 
-    bec_logger.level = bec_logger.LOGLEVEL.INFO
-    if args.hide:
-        # pylint: disable=protected-access
-        bec_logger._stderr_log_level = bec_logger.LOGLEVEL.ERROR
-        bec_logger._update_sinks()
-
-    if 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 = BECDockArea
-
-    with redirect_stdout(SimpleFileLikeFromLogOutputFunc(logger.info)):
-        with redirect_stderr(SimpleFileLikeFromLogOutputFunc(logger.error)):
-            app = QApplication(sys.argv)
-            # set close on last window, only if not under control of client ;
-            # indeed, Qt considers a hidden window a closed window, so if all windows
-            # are hidden by default it exits
-            app.setQuitOnLastWindowClosed(not args.hide)
-            module_path = os.path.dirname(bec_widgets.__file__)
-            icon = QIcon()
-            icon.addFile(
-                os.path.join(module_path, "assets", "app_icons", "bec_widgets_icon.png"),
-                size=QSize(48, 48),
-            )
-            app.setWindowIcon(icon)
-            # store gui id within QApplication object, to make it available to all widgets
-            app.gui_id = args.id
-
-            # args.id = "abff6"
-            server = _start_server(args.id, gui_class, args.gui_class_id, args.config)
-
-            win = BECMainWindow(gui_id=f"{server.gui_id}:window")
-            win.setAttribute(Qt.WA_ShowWithoutActivating)
-            win.setWindowTitle("BEC")
-
-            RPCRegister().add_rpc(win)
-            gui = server.gui
-            win.setCentralWidget(gui)
-            if not args.hide:
-                win.show()
-
-            app.aboutToQuit.connect(server.shutdown)
-
-            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():
-                        widget.close()
-                app.quit()
-
-            # gui.bec.close()
-            # win.shutdown()
-            signal.signal(signal.SIGINT, sigint_handler)
-            signal.signal(signal.SIGTERM, sigint_handler)
-
-            sys.exit(app.exec())
+    server = GUIServer(args)
+    server.start()
 
 
 if __name__ == "__main__":
+    # import sys
+
+    # sys.argv = ["bec_widgets", "--gui_class", "MainWindow"]
     main()

bec_widgets/examples/jupyter_console/jupyter_console_window.py

@@ -44,21 +44,21 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
                     "wh": wh,
                     "dock": self.dock,
                     "im": self.im,
-                    "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,
+                    # "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,
                 }
             )
 
@@ -77,76 +77,76 @@ class JupyterConsoleWindow(QWidget):  # pragma: no cover:
         first_tab_layout.addWidget(self.dock)
         tab_widget.addTab(first_tab, "Dock Area")
 
-        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)
-
+        # 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 = 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)
-
+        #
+        # # 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()
+        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(5)
-
-        seventh_tab = QWidget()
-        seventh_tab_layout = QVBoxLayout(seventh_tab)
-        self.scatter = ScatterWaveform()
-        self.scatter_mi = self.scatter.main_curve
-        self.scatter.plot("samx", "samy", "bpm4i")
-        seventh_tab_layout.addWidget(self.scatter)
-        tab_widget.addTab(seventh_tab, "Scatter Waveform")
-        tab_widget.setCurrentIndex(6)
-
-        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")
+        tab_widget.setCurrentIndex(1)
+        #
+        # seventh_tab = QWidget()
+        # seventh_tab_layout = QVBoxLayout(seventh_tab)
+        # self.scatter = ScatterWaveform()
+        # self.scatter_mi = self.scatter.main_curve
+        # self.scatter.plot("samx", "samy", "bpm4i")
+        # seventh_tab_layout.addWidget(self.scatter)
+        # tab_widget.addTab(seventh_tab, "Scatter Waveform")
+        # tab_widget.setCurrentIndex(6)
+        #
+        # 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")
 
     def _init_waveform(self):
         self.wf.plot(y_name="bpm4i", y_entry="bpm4i", dap="GaussianModel")
@@ -174,7 +174,7 @@ if __name__ == "__main__":  # pragma: no cover
     icon = material_icon("terminal", color=(255, 255, 255, 255), filled=True)
     app.setWindowIcon(icon)
 
-    bec_dispatcher = BECDispatcher()
+    bec_dispatcher = BECDispatcher(gui_id="jupyter_console")
     client = bec_dispatcher.client
     client.start()
 

bec_widgets/tests/utils.py

@@ -96,9 +96,9 @@ class FakePositioner(BECPositioner):
         }
         self._info = {
             "signals": {
-                "readback": {"kind_str": "5"},  # hinted
-                "setpoint": {"kind_str": "1"},  # normal
-                "velocity": {"kind_str": "2"},  # config
+                "readback": {"kind_str": "hinted"},  # hinted
+                "setpoint": {"kind_str": "normal"},  # normal
+                "velocity": {"kind_str": "config"},  # config
             }
         }
         self.signals = {
@@ -200,7 +200,13 @@ class DMMock:
         self.devices = DeviceContainer()
         self.enabled_devices = [device for device in self.devices if device.enabled]
 
-    def add_devives(self, devices: list):
+    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
 

bec_widgets/utils/bec_connector.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import os
 import time
+import traceback
 import uuid
 from datetime import datetime
 from typing import TYPE_CHECKING, Optional
@@ -10,21 +11,21 @@ from typing import TYPE_CHECKING, Optional
 from bec_lib.logger import bec_logger
 from bec_lib.utils.import_utils import lazy_import_from
 from pydantic import BaseModel, Field, field_validator
-from qtpy.QtCore import QObject, QRunnable, QThreadPool, Signal
+from qtpy.QtCore import QObject, QRunnable, QThreadPool, QTimer, Signal
 from qtpy.QtWidgets import QApplication
 
 from bec_widgets.cli.rpc.rpc_register import RPCRegister
-from bec_widgets.utils.container_utils import WidgetContainerUtils
-from bec_widgets.utils.error_popups import ErrorPopupUtility
-from bec_widgets.utils.error_popups import SafeSlot as pyqtSlot
+from bec_widgets.utils.error_popups import ErrorPopupUtility, SafeSlot
+from bec_widgets.utils.widget_io import WidgetHierarchy
 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):
@@ -82,19 +83,47 @@ class BECConnector:
         client=None,
         config: ConnectionConfig | None = None,
         gui_id: str | None = None,
-        name: str | None = None,
-        parent_dock: BECDock | None = None,
-        parent_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
+
         # 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
+        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
-            @pyqtSlot()
+            @SafeSlot()
             def terminate(client=self.client, dispatcher=self.bec_dispatcher):
                 logger.info("Disconnecting", repr(dispatcher))
                 dispatcher.disconnect_all()
@@ -114,7 +143,6 @@ class BECConnector:
             )
             self.config = ConnectionConfig(widget_class=self.__class__.__name__)
 
-        self.parent_id = parent_id
         # 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:
@@ -122,14 +150,19 @@ class BECConnector:
             self.gui_id: str = gui_id  # Keep namespace in sync
         else:
             self.gui_id: str = self.config.gui_id  # type: ignore
-        if name is None:
-            name = self.__class__.__name__
-        else:
-            if not WidgetContainerUtils.has_name_valid_chars(name):
-                raise ValueError(f"Name {name} contains invalid characters.")
-        self._name = name if name else self.__class__.__name__
-        self.rpc_register = RPCRegister()
-        self.rpc_register.add_rpc(self)
+
+        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)
+        if isinstance(self.parent(), QObject) and hasattr(self, "cleanup"):
+            self.parent().destroyed.connect(self._run_cleanup_on_deleted_parent)
 
         # Error popups
         self.error_utility = ErrorPopupUtility()
@@ -138,7 +171,119 @@ class BECConnector:
         # Store references to running workers so they're not garbage collected prematurely.
         self._workers = []
 
-    def submit_task(self, fn, *args, on_complete: pyqtSlot = None, **kwargs) -> Worker:
+        # 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__}")
+
+    @SafeSlot()
+    def _run_cleanup_on_deleted_parent(self) -> None:
+        """
+        Run cleanup on the deleted parent.
+        This method is called when the parent is deleted.
+        """
+        if not hasattr(self, "cleanup"):
+            return
+        try:
+            if not self._destroyed:
+                self.cleanup()
+                self._destroyed = True
+        except Exception:
+            content = traceback.format_exc()
+            logger.info(
+                "Failed to run cleanup on deleted parent. "
+                f"This is not necessarily an error as the parent may be deleted before the child and includes already a cleanup. The following exception was raised:\n{content}"
+            )
+
+    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)
+
+    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:
         """
         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.
@@ -266,7 +411,7 @@ class BECConnector:
             file_path = os.path.join(path, f"{self.__class__.__name__}_config.yaml")
             save_yaml(file_path, self._config_dict)
 
-    # @pyqtSlot(str)
+    # @SafeSlot(str)
     def _set_gui_id(self, gui_id: str) -> None:
         """
         Set the GUI ID for the widget.
@@ -298,7 +443,7 @@ class BECConnector:
         self.client = client
         self.get_bec_shortcuts()
 
-    @pyqtSlot(ConnectionConfig)  # TODO can be also dict
+    @SafeSlot(ConnectionConfig)  # TODO can be also dict
     def on_config_update(self, config: ConnectionConfig | dict) -> None:
         """
         Update the configuration for the widget.
@@ -316,8 +461,9 @@ class BECConnector:
     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._name)
+            self._parent_dock.delete(self.object_name)
         # If the widget is from Qt, trigger its close method.
         elif hasattr(self, "close"):
             self.close()

bec_widgets/utils/bec_designer.py

@@ -10,13 +10,15 @@ 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,
     )
 
@@ -76,7 +78,7 @@ def list_editable_packages() -> set[str]:
     return editable_packages
 
 
-def patch_designer():  # pragma: no cover
+def patch_designer(cmd_args: list[str] = []):  # pragma: no cover
     if not PYSIDE6:
         print("PYSIDE6 is not available in the environment. Cannot patch designer.")
         return
@@ -117,7 +119,7 @@ def patch_designer():  # pragma: no cover
             editable_packages = list_editable_packages()
             for pckg in editable_packages:
                 _extend_path_var("PYTHONPATH", pckg, True)
-    qt_tool_wrapper(ui_tool_binary("designer"), sys.argv[1:])
+    qt_tool_wrapper(ui_tool_binary("designer"), cmd_args)
 
 
 def find_plugin_paths(base_path: Path):
@@ -145,15 +147,24 @@ def set_plugin_environment_variable(plugin_paths):
 
 
 # Patch the designer function
-def main():  # pragma: no cover
+def open_designer(cmd_args: list[str] = []):  # 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()
+    patch_designer(cmd_args)
+
+
+def main():
+    open_designer(sys.argv[1:])
 
 
 if __name__ == "__main__":  # pragma: no cover

bec_widgets/utils/bec_dispatcher.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
 import collections
+import random
+import string
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, DefaultDict, Hashable, Union
 
+import louie
 import redis
 from bec_lib.client import BECClient
 from bec_lib.logger import bec_logger
@@ -12,28 +15,52 @@ from bec_lib.service_config import ServiceConfig
 from qtpy.QtCore import QObject
 from qtpy.QtCore import Signal as pyqtSignal
 
+from bec_widgets.utils.serialization import register_serializer_extension
+
 logger = bec_logger.logger
 
-if TYPE_CHECKING:
+if TYPE_CHECKING:  # pragma: no cover
     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):
+    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.
+        """
         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 id(self.cb)
+        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
 
     def __call__(self, msg_content, metadata):
+        if self.cb_ref() is None:
+            # callback has been deleted
+            return
         self.cb_signal.emit(msg_content, metadata)
 
 
@@ -73,18 +100,29 @@ class BECDispatcher:
 
     _instance = None
     _initialized = False
+    client: BECClient
+    cli_server: RPCServer | None = None
 
-    def __new__(cls, client=None, config: str = None, *args, **kwargs):
+    def __new__(
+        cls,
+        client=None,
+        config: str | ServiceConfig | None = None,
+        gui_id: str | None = 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):
+    def __init__(self, client=None, config: str | ServiceConfig | None = None, gui_id: str = None):
         if self._initialized:
             return
 
-        self._slots = collections.defaultdict(set)
+        self._registered_slots: DefaultDict[Hashable, QtThreadSafeCallback] = (
+            collections.defaultdict()
+        )
         self.client = client
 
         if self.client is None:
@@ -107,11 +145,18 @@ class BECDispatcher:
         except redis.exceptions.ConnectionError:
             logger.warning("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
 
@@ -119,6 +164,7 @@ class BECDispatcher:
         self,
         slot: Callable,
         topics: Union[EndpointInfo, str, list[Union[EndpointInfo, str]]],
+        cb_info: dict | None = None,
         **kwargs,
     ) -> None:
         """Connect widget's qt slot, so that it is called on new pub/sub topic message.
@@ -127,11 +173,15 @@ class BECDispatcher:
             slot (Callable): A slot method/function that accepts two inputs: content and metadata of
                 the corresponding pub/sub message
             topics (EndpointInfo | str | list): A topic or list of topics that can typically be acquired via bec_lib.MessageEndpoints
+            cb_info (dict | None): A dictionary containing information about the callback. Defaults to None.
         """
-        slot = QtThreadSafeCallback(slot)
-        self.client.connector.register(topics, cb=slot, **kwargs)
+        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)
         topics_str, _ = self.client.connector._convert_endpointinfo(topics)
-        self._slots[slot].update(set(topics_str))
+        qt_slot.topics.update(set(topics_str))
 
     def disconnect_slot(self, slot: Callable, topics: Union[str, list]):
         """
@@ -144,16 +194,16 @@ class BECDispatcher:
         # find the right slot to disconnect from ;
         # slot callbacks are wrapped in QtThreadSafeCallback objects,
         # but the slot we receive here is the original callable
-        for connected_slot in self._slots:
+        for connected_slot in self._registered_slots.values():
             if connected_slot.cb == slot:
                 break
         else:
             return
         self.client.connector.unregister(topics, cb=connected_slot)
         topics_str, _ = self.client.connector._convert_endpointinfo(topics)
-        self._slots[connected_slot].difference_update(set(topics_str))
-        if not self._slots[connected_slot]:
-            del self._slots[connected_slot]
+        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]
 
     def disconnect_topics(self, topics: Union[str, list]):
         """
@@ -164,11 +214,16 @@ class BECDispatcher:
         """
         self.client.connector.unregister(topics)
         topics_str, _ = self.client.connector._convert_endpointinfo(topics)
-        for slot in list(self._slots.keys()):
-            slot_topics = self._slots[slot]
-            slot_topics.difference_update(set(topics_str))
-            if not slot_topics:
-                del self._slots[slot]
+
+        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)
 
     def disconnect_all(self, *args, **kwargs):
         """
@@ -178,4 +233,49 @@ class BECDispatcher:
             *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

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import importlib.metadata
+import inspect
+import pkgutil
+from importlib import util as importlib_util
+from importlib.machinery import FileFinder, ModuleSpec, SourceFileLoader
+from types import ModuleType
+from typing import Generator
+
+from bec_widgets.utils.bec_widget import BECWidget
+
+
+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!"
+        submodule.__loader__.exec_module(submodule)
+        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) -> dict[str, "type[BECWidget]"]:
+    """Find any BECWidget subclasses in the given module and return them with their names."""
+    from bec_widgets.utils.bec_widget import BECWidget  # avoid circular import
+
+    return dict(
+        inspect.getmembers(
+            module,
+            predicate=lambda item: inspect.isclass(item)
+            and issubclass(item, BECWidget)
+            and item is not BECWidget,
+        )
+    )
+
+
+def _all_widgets_from_all_submods(module):
+    """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.update(_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() -> dict[str, "type[BECWidget]"]:
+    """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 {}
+
+
+if __name__ == "__main__":  # pragma: no cover
+    #  print(get_all_plugin_widgets())
+    client = get_plugin_client_module()
+    ...

bec_widgets/utils/bec_signal_proxy.py

@@ -1,6 +1,6 @@
-""" This custom class is a thin wrapper around the SignalProxy class to allow signal calls to be blocked.
+"""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 
+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."""
 

bec_widgets/utils/bec_widget.py

@@ -4,8 +4,8 @@ from typing import TYPE_CHECKING
 
 import darkdetect
 from bec_lib.logger import bec_logger
-from qtpy.QtCore import Slot
-from qtpy.QtWidgets import QApplication, QWidget
+from qtpy.QtCore import QObject, Slot
+from qtpy.QtWidgets import QApplication
 
 from bec_widgets.cli.rpc.rpc_register import RPCRegister
 from bec_widgets.utils.bec_connector import BECConnector, ConnectionConfig
@@ -32,9 +32,7 @@ class BECWidget(BECConnector):
         config: ConnectionConfig = None,
         gui_id: str | None = None,
         theme_update: bool = False,
-        name: str | None = None,
-        parent_dock: BECDock | None = None,
-        parent_id: str | None = None,
+        parent_dock: BECDock | None = None,  # TODO should go away -> issue created #473
         **kwargs,
     ):
         """
@@ -54,17 +52,12 @@ class BECWidget(BECConnector):
             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.
         """
-        if not isinstance(self, QWidget):
-            raise RuntimeError(f"{repr(self)} is not a subclass of QWidget")
 
         super().__init__(
-            client=client,
-            config=config,
-            gui_id=gui_id,
-            name=name,
-            parent_dock=parent_dock,
-            parent_id=parent_id,
+            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")
         app = QApplication.instance()
         if not hasattr(app, "theme"):
             # DO NOT SET THE THEME TO AUTO! Otherwise, the qwebengineview will segfault
@@ -107,11 +100,14 @@ class BECWidget(BECConnector):
         """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)
 
     def closeEvent(self, event):
         """Wrap the close even to ensure the rpc_register is cleaned up."""
         try:
-            self.cleanup()
+            if not self._destroyed:
+                self.cleanup()
+                self._destroyed = True
         finally:
             super().closeEvent(event)  # pylint: disable=no-member

bec_widgets/utils/colors.py

@@ -11,7 +11,7 @@ from pydantic_core import PydanticCustomError
 from qtpy.QtGui import QColor
 from qtpy.QtWidgets import QApplication
 
-if TYPE_CHECKING:
+if TYPE_CHECKING:  # pragma: no cover
     from bec_qthemes._main import AccentColors
 
 

bec_widgets/utils/compact_popup.py

@@ -266,3 +266,5 @@ class CompactPopupWidget(QWidget):
         # to ensure proper resources cleanup
         for child in self.container.findChildren(QWidget, options=Qt.FindDirectChildrenOnly):
             child.close()
+
+        super().closeEvent(event)

bec_widgets/utils/container_utils.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
-import itertools
-from typing import Literal, Type
+from typing import Any, Type
 
 from qtpy.QtWidgets import QWidget
 
-from bec_widgets.cli.rpc.rpc_register import RPCRegister
+from bec_widgets.cli.client_utils import BECGuiClient
 
 
 class WidgetContainerUtils:
@@ -73,3 +72,36 @@ 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

@@ -85,7 +85,8 @@ class Crosshair(QObject):
         self.items = []
         self.marker_moved_1d = {}
         self.marker_clicked_1d = {}
-        self.marker_2d = None
+        self.marker_2d_row = None
+        self.marker_2d_col = None
         self.update_markers()
         self.check_log()
         self.check_derivatives()
@@ -195,13 +196,23 @@ class Crosshair(QObject):
                         marker_clicked_list.append(marker_clicked)
                     self.marker_clicked_1d[name] = marker_clicked_list
             elif isinstance(item, pg.ImageItem):  # 2D plot
-                if self.marker_2d is not None:
+                if self.marker_2d_row is not None and self.marker_2d_col is not None:
                     continue
-                self.marker_2d = pg.ROI(
-                    [0, 0], size=[1, 1], pen=pg.mkPen("r", width=2), movable=False
+                # 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.skip_auto_range = True
-                self.plot_item.addItem(self.marker_2d)
+                self.marker_2d_row.skip_auto_range = True
+                self.plot_item.addItem(self.marker_2d_row)
+
+                # 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
+                )
+                self.marker_2d_col.skip_auto_range = True
+                self.plot_item.addItem(self.marker_2d_col)
 
     def snap_to_data(
         self, x: float, y: float
@@ -243,6 +254,8 @@ class Crosshair(QObject):
             elif isinstance(item, pg.ImageItem):  # 2D plot
                 name = item.config.monitor or str(id(item))
                 image_2d = item.image
+                if image_2d is None:
+                    continue
                 # Clip the x and y values to the image dimensions to avoid out of bounds errors
                 y_values[name] = int(np.clip(y, 0, image_2d.shape[1] - 1))
                 x_values[name] = int(np.clip(x, 0, image_2d.shape[0] - 1))
@@ -330,7 +343,10 @@ class Crosshair(QObject):
                     x, y = x_snap_values[name], y_snap_values[name]
                     if x is None or y is None:
                         continue
-                    self.marker_2d.setPos([x, y])
+                    # Set position of horizontal ROI (row)
+                    self.marker_2d_row.setPos([0, y])
+                    # Set position of vertical ROI (column)
+                    self.marker_2d_col.setPos([x, 0])
                     coordinate_to_emit = (name, x, y)
                     self.coordinatesChanged2D.emit(coordinate_to_emit)
                 else:
@@ -384,7 +400,10 @@ class Crosshair(QObject):
                     x, y = x_snap_values[name], y_snap_values[name]
                     if x is None or y is None:
                         continue
-                    self.marker_2d.setPos([x, y])
+                    # Set position of horizontal ROI (row)
+                    self.marker_2d_row.setPos([0, y])
+                    # Set position of vertical ROI (column)
+                    self.marker_2d_col.setPos([x, 0])
                     coordinate_to_emit = (name, x, y)
                     self.coordinatesClicked2D.emit(coordinate_to_emit)
                 else:
@@ -428,6 +447,8 @@ class Crosshair(QObject):
         for item in self.items:
             if isinstance(item, pg.ImageItem):
                 image = item.image
+                if image is None:
+                    continue
                 ix = int(np.clip(x, 0, image.shape[0] - 1))
                 iy = int(np.clip(y, 0, image.shape[1] - 1))
                 intensity = image[ix, iy]
@@ -450,9 +471,12 @@ class Crosshair(QObject):
         self.clear_markers()
 
     def cleanup(self):
-        if self.marker_2d is not None:
-            self.plot_item.removeItem(self.marker_2d)
-            self.marker_2d = None
+        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.plot_item.removeItem(self.v_line)
         self.plot_item.removeItem(self.h_line)
         self.plot_item.removeItem(self.coord_label)

bec_widgets/utils/entry_validator.py

@@ -17,13 +17,23 @@ 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]
 
         if entry is None or entry == "":
             entry = next(iter(device._hints), name) if hasattr(device, "_hints") else name
-        if entry not in description:
+        if entry not in available_entries:
             raise ValueError(
-                f"Entry '{entry}' not found in device '{name}' signals. Available signals: {description.keys()}"
+                f"Entry '{entry}' not found in device '{name}' signals. "
+                f"Available signals: '{available_entries}'"
             )
 
         return entry

bec_widgets/utils/error_popups.py

@@ -96,23 +96,55 @@ def SafeSlot(*slot_args, **slot_kwargs):  # pylint: disable=invalid-name
 
     '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.
+
     """
-    popup_error = bool(slot_kwargs.pop("popup_error", False))
+    _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 popup_error:
-                    ErrorPopupUtility().custom_exception_hook(
-                        *sys.exc_info(), popup_error=popup_error
-                    )
+                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
 

bec_widgets/utils/expandable_frame.py

@@ -37,7 +37,7 @@ class ExpandableGroupFrame(QFrame):
         self._title_layout.addWidget(self._expansion_button)
         self._title_layout.addWidget(self._title)
 
-        self._contents = QWidget()
+        self._contents = QWidget(self)
         self._layout.addWidget(self._contents)
 
         self._expansion_button.clicked.connect(self.switch_expanded_state)

bec_widgets/utils/forms_from_types/forms.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+from decimal import Decimal
+from types import NoneType
+
+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 QGridLayout, QLabel, QLayout, QVBoxLayout, QWidget
+
+from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.compact_popup import CompactPopupWidget
+from bec_widgets.utils.forms_from_types.items import FormItemSpec, widget_from_type
+
+logger = bec_logger.logger
+
+
+class TypedForm(BECWidget, QWidget):
+    PLUGIN = True
+    ICON_NAME = "list_alt"
+
+    value_changed = Signal()
+
+    RPC = False
+
+    def __init__(
+        self,
+        parent=None,
+        items: list[tuple[str, type]] | None = None,
+        form_item_specs: list[FormItemSpec] | None = None,
+        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.
+
+        """
+        if (items is not None and form_item_specs is not None) or (
+            items is None and form_item_specs is None
+        ):
+            raise ValueError("Must specify one and only one of items and form_item_specs")
+        super().__init__(parent=parent, client=client, **kwargs)
+        self._items = (
+            form_item_specs
+            if form_item_specs is not None
+            else [
+                FormItemSpec(name=name, item_type=item_type)
+                for name, item_type in items  # type: ignore
+            ]
+        )
+        self._layout = QVBoxLayout()
+        self._layout.setContentsMargins(0, 0, 0, 0)
+        self.setLayout(self._layout)
+
+        self._form_grid_container = QWidget(parent=self)
+        self._form_grid = QWidget(parent=self._form_grid_container)
+        self._layout.addWidget(self._form_grid_container)
+        self._form_grid_container.setLayout(QVBoxLayout())
+        self._form_grid.setLayout(self._new_grid_layout())
+
+        self.populate()
+
+    def populate(self):
+        self._clear_grid()
+        for r, item in enumerate(self._items):
+            self._add_griditem(item, r)
+
+    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 = widget_from_type(item.item_type)(parent=self, spec=item)
+        widget.valueChanged.connect(self.value_changed)
+        grid.addWidget(widget, row, 1)
+
+    def _dict_from_grid(self) -> dict[str, str | int | float | Decimal | bool]:
+        grid: QGridLayout = self._form_grid.layout()  # type: ignore
+        return {
+            grid.itemAtPosition(i, 0)
+            .widget()
+            .property("_model_field_name"): grid.itemAtPosition(i, 1)
+            .widget()
+            .getValue()  # type: ignore # we only add 'DynamicFormItem's here
+            for i in range(grid.rowCount())
+        }
+
+    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.setLayout(self._new_grid_layout())
+        self._form_grid_container.layout().addWidget(self._form_grid)
+
+        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)
+        new_grid.setSizeConstraint(QLayout.SizeConstraint.SetFixedSize)
+        return new_grid
+
+
+class PydanticModelForm(TypedForm):
+    metadata_updated = Signal(dict)
+    metadata_cleared = Signal(NoneType)
+
+    def __init__(self, parent=None, metadata_model: type[BaseModel] = None, client=None, **kwargs):
+        """
+        A form generated from a pydantic model.
+
+        Args:
+            metadata_model (type[BaseModel]): the model class for which to generate a form.
+        """
+        self._md_schema = metadata_model
+        super().__init__(parent=parent, form_item_specs=self._form_item_specs(), client=client)
+
+        self._validity = CompactPopupWidget()
+        self._validity.compact_view = True  # type: ignore
+        self._validity.label = "Metadata 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)
+
+    def set_schema(self, schema: type[BaseModel]):
+        self._md_schema = schema
+        self.populate()
+
+    def _form_item_specs(self):
+        return [
+            FormItemSpec(name=name, info=info, item_type=info.annotation)
+            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 metadata_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.metadata_updated.emit(metadata_dict)
+            return True
+        except ValidationError as e:
+            self._validity.set_global_state("emergency")
+            self._validity_message.setText(str(e))
+            self.metadata_cleared.emit(None)
+            return False

bec_widgets/utils/forms_from_types/items.py

@@ -2,11 +2,13 @@ from __future__ import annotations
 
 from abc import abstractmethod
 from decimal import Decimal
-from typing import TYPE_CHECKING, Callable, get_args
+from types import UnionType
+from typing import Callable, Protocol
 
 from bec_lib.logger import bec_logger
 from bec_qthemes import material_icon
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
+from pydantic.fields import FieldInfo
 from qtpy.QtCore import Signal  # type: ignore
 from qtpy.QtWidgets import (
     QApplication,
@@ -33,12 +35,22 @@ from bec_widgets.widgets.editors.scan_metadata._util import (
     field_precision,
 )
 
-if TYPE_CHECKING:
-    from pydantic.fields import FieldInfo
-
 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
+    name: str
+    info: FieldInfo = FieldInfo()
+
+
 class ClearableBoolEntry(QWidget):
     stateChanged = Signal()
 
@@ -82,21 +94,20 @@ class ClearableBoolEntry(QWidget):
         self._false.setToolTip(tooltip)
 
 
-class MetadataWidget(QWidget):
-
+class DynamicFormItem(QWidget):
     valueChanged = Signal()
 
-    def __init__(self, info: FieldInfo, parent: QWidget | None = None) -> None:
+    def __init__(self, parent: QWidget | None = None, *, spec: FormItemSpec) -> None:
         super().__init__(parent)
-        self._info = info
+        self._spec = spec
         self._layout = QHBoxLayout()
         self._layout.setContentsMargins(0, 0, 0, 0)
         self._layout.setSizeConstraint(QLayout.SizeConstraint.SetMaximumSize)
-        self._default = field_default(self._info)
-        self._desc = self._info.description
+        self._default = field_default(self._spec.info)
+        self._desc = self._spec.info.description
         self.setLayout(self._layout)
         self._add_main_widget()
-        if clearable_required(info):
+        if clearable_required(spec.info):
             self._add_clear_button()
 
     @abstractmethod
@@ -127,15 +138,15 @@ class MetadataWidget(QWidget):
         self.valueChanged.emit()
 
 
-class StrMetadataField(MetadataWidget):
-    def __init__(self, info: FieldInfo, parent: QWidget | None = None) -> None:
-        super().__init__(info, parent)
+class StrMetadataField(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._info), field_maxlen(self._info)
+        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(
@@ -156,15 +167,15 @@ class StrMetadataField(MetadataWidget):
         self._main_widget.setText(value)
 
 
-class IntMetadataField(MetadataWidget):
-    def __init__(self, info: FieldInfo, parent: QWidget | None = None) -> None:
-        super().__init__(info, parent)
+class IntMetadataField(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._info, int)
+        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()}")
@@ -185,18 +196,18 @@ class IntMetadataField(MetadataWidget):
         self._main_widget.setValue(value)
 
 
-class FloatDecimalMetadataField(MetadataWidget):
-    def __init__(self, info: FieldInfo, parent: QWidget | None = None) -> None:
-        super().__init__(info, parent)
+class FloatDecimalMetadataField(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 = QDoubleSpinBox()
         self._layout.addWidget(self._main_widget)
-        min_, max_ = field_limits(self._info, int)
+        min_, max_ = field_limits(self._spec.info, int)
         self._main_widget.setMinimum(min_)
         self._main_widget.setMaximum(max_)
-        precision = field_precision(self._info)
+        precision = field_precision(self._spec.info)
         if precision:
             self._main_widget.setDecimals(precision)
         minstr = f"{float(min_):.3f}" if abs(min_) <= 1000 else f"{float(min_):.3e}"
@@ -219,13 +230,13 @@ class FloatDecimalMetadataField(MetadataWidget):
         self._main_widget.setValue(value)
 
 
-class BoolMetadataField(MetadataWidget):
-    def __init__(self, info: FieldInfo, parent: QWidget | None = None) -> None:
-        super().__init__(info, parent)
+class BoolMetadataField(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._info):
+        if clearable_required(self._spec.info):
             self._main_widget = ClearableBoolEntry()
         else:
             self._main_widget = QCheckBox()
@@ -240,7 +251,7 @@ class BoolMetadataField(MetadataWidget):
         self._main_widget.setChecked(value)
 
 
-def widget_from_type(annotation: type | None) -> Callable[[FieldInfo], MetadataWidget]:
+def widget_from_type(annotation: type | UnionType | None) -> type[DynamicFormItem]:
     if annotation in [str, str | None]:
         return StrMetadataField
     if annotation in [int, int | None]:

bec_widgets/utils/generate_designer_plugin.py

@@ -5,6 +5,8 @@ from typing import NamedTuple
 
 from qtpy.QtCore import QObject
 
+from bec_widgets.utils.name_utils import pascal_to_snake
+
 EXCLUDED_PLUGINS = ["BECConnector", "BECDockArea", "BECDock", "BECFigure"]
 
 
@@ -22,7 +24,7 @@ class DesignerPluginInfo:
     def __init__(self, plugin_class):
         self.plugin_class = plugin_class
         self.plugin_name_pascal = plugin_class.__name__
-        self.plugin_name_snake = self.pascal_to_snake(self.plugin_name_pascal)
+        self.plugin_name_snake = 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"
@@ -38,21 +40,6 @@ 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):
@@ -122,6 +109,16 @@ class DesignerPluginGenerator:
                 or bool(init_source.find("super().__init__(parent)") > 0)
             )
 
+        # 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 = bool(
+                init_source.find("super().__init__(parent=parent") > 0
+                or init_source.find("super().__init__(parent,") > 0
+                or 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."

bec_widgets/utils/linear_region_selector.py

@@ -1,5 +1,7 @@
-""" Module for a thin wrapper (LinearRegionWrapper) around the LinearRegionItem in pyqtgraph.
-The class is mainly designed for usage with the BECWaveform and 1D plots. """
+"""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

bec_widgets/utils/name_utils.py

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

@@ -22,10 +22,10 @@ class PaletteViewer(BECWidget, QWidget):
     """
 
     ICON_NAME = "palette"
+    RPC = False
 
     def __init__(self, *args, parent=None, **kwargs):
-        super().__init__(*args, theme_update=True, **kwargs)
-        QWidget.__init__(self, parent=parent)
+        super().__init__(parent=parent, theme_update=True, **kwargs)
         self.setFixedSize(400, 600)
         layout = QVBoxLayout(self)
         dark_mode_button = DarkModeButton(self)

bec_widgets/utils/plugin_utils.py

@@ -1,7 +1,10 @@
+from __future__ import annotations
+
 import importlib
 import inspect
 import os
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
 from bec_lib.plugin_helper import _get_available_plugins
 from qtpy.QtWidgets import QGraphicsWidget, QWidget
@@ -9,6 +12,9 @@ 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]:
     """
@@ -45,6 +51,40 @@ 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
@@ -63,6 +103,9 @@ class BECClassContainer:
     def __repr__(self):
         return str(list(cl.name for cl in self.collection))
 
+    def __iter__(self):
+        return self._collection.__iter__()
+
     def add_class(self, class_info: BECClassInfo):
         """
         Add a class to the collection.

bec_widgets/utils/round_frame.py

@@ -16,6 +16,7 @@ class RoundedFrame(QFrame):
         parent=None,
         content_widget: QWidget = None,
         background_color: str = None,
+        orientation: str = "horizontal",
         radius: int = 10,
     ):
         QFrame.__init__(self, parent)
@@ -28,8 +29,12 @@ class RoundedFrame(QFrame):
         self.setObjectName("roundedFrame")
 
         # Create a layout for the frame
-        self.layout = QHBoxLayout(self)
-        self.layout.setContentsMargins(5, 5, 5, 5)  # Set 5px margin
+        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:

bec_widgets/utils/rpc_server.py

@@ -0,0 +1,277 @@
+from __future__ import annotations
+
+import functools
+import traceback
+import types
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, Callable, TypeVar
+
+from bec_lib.client import BECClient
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.logger import bec_logger
+from bec_lib.utils.import_utils import lazy_import
+from qtpy.QtCore import QTimer
+from qtpy.QtWidgets import QApplication
+from redis.exceptions import RedisError
+
+from bec_widgets.cli.rpc.rpc_register import RPCRegister
+from bec_widgets.utils import BECDispatcher
+from bec_widgets.utils.bec_connector import BECConnector
+from bec_widgets.utils.error_popups import ErrorPopupUtility
+from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
+
+if TYPE_CHECKING:  # pragma: no cover
+    from bec_lib import messages
+    from qtpy.QtCore import QObject
+else:
+    messages = lazy_import("bec_lib.messages")
+logger = bec_logger.logger
+
+
+T = TypeVar("T")
+
+
+@contextmanager
+def rpc_exception_hook(err_func):
+    """This context replaces the popup message box for error display with a specific hook"""
+    # get error popup utility singleton
+    popup = ErrorPopupUtility()
+    # save current setting
+    old_exception_hook = popup.custom_exception_hook
+
+    # install err_func, if it is a callable
+    # IMPORTANT, Keep self here, because this method is overwriting the custom_exception_hook
+    # of the ErrorPopupUtility (popup instance) class.
+    def custom_exception_hook(self, exc_type, value, tb, **kwargs):
+        err_func({"error": popup.get_error_message(exc_type, value, tb)})
+
+    popup.custom_exception_hook = types.MethodType(custom_exception_hook, popup)
+
+    try:
+        yield popup
+    finally:
+        # restore state of error popup utility singleton
+        popup.custom_exception_hook = old_exception_hook
+
+
+class RPCServer:
+
+    client: BECClient
+
+    def __init__(
+        self,
+        gui_id: str,
+        dispatcher: BECDispatcher | None = None,
+        client: BECClient | None = None,
+        config=None,
+        gui_class_id: str = "bec",
+    ) -> None:
+        self.status = messages.BECStatus.BUSY
+        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
+        # register broadcast callback
+        self.rpc_register = RPCRegister()
+        self.rpc_register.add_callback(self.broadcast_registry_update)
+
+        self.dispatcher.connect_slot(
+            self.on_rpc_update, MessageEndpoints.gui_instructions(self.gui_id)
+        )
+
+        # Setup QTimer for heartbeat
+        self._heartbeat_timer = QTimer()
+        self._heartbeat_timer.timeout.connect(self.emit_heartbeat)
+        self._heartbeat_timer.start(200)
+        self._registry_update_callbacks = []
+        self._broadcasted_data = {}
+
+        self.status = messages.BECStatus.RUNNING
+        logger.success(f"Server started with gui_id: {self.gui_id}")
+
+    def on_rpc_update(self, msg: dict, metadata: dict):
+        request_id = metadata.get("request_id")
+        if request_id is None:
+            logger.error("Received RPC instruction without request_id")
+            return
+        logger.debug(f"Received RPC instruction: {msg}, metadata: {metadata}")
+        with rpc_exception_hook(functools.partial(self.send_response, request_id, False)):
+            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:
+                content = traceback.format_exc()
+                logger.error(f"Error while executing RPC instruction: {content}")
+                self.send_response(request_id, False, {"error": content})
+            else:
+                logger.debug(f"RPC instruction executed successfully: {res}")
+                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):
+        # Run with rpc registry broadcast, but only once
+        with RPCRegister.delayed_broadcast():
+            logger.debug(f"Running RPC instruction: {method} with args: {args}, kwargs: {kwargs}")
+            method_obj = getattr(obj, method)
+            # check if the method accepts args and kwargs
+            if not callable(method_obj):
+                if not args:
+                    res = method_obj
+                else:
+                    setattr(obj, method, args[0])
+                    res = None
+            else:
+                res = method_obj(*args, **kwargs)
+
+            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: T) -> None | dict | T:
+        """
+        Serialize all BECConnector objects.
+
+        Args:
+            obj: The object to be serialized.
+
+        Returns:
+            None | dict | T: The serialized object or None if the object is not a BECConnector.
+        """
+        if not isinstance(obj, BECConnector):
+            return obj
+        # Respect RPC = False
+        if getattr(obj, "RPC", True) is False:
+            return None
+        return self._serialize_bec_connector(obj, wait=True)
+
+    def emit_heartbeat(self) -> None:
+        """
+        Emit a heartbeat message to the GUI server.
+        This method is called periodically to indicate that the server is still running.
+        """
+        logger.trace(f"Emitting heartbeat for {self.gui_id}")
+        try:
+            self.client.connector.set(
+                MessageEndpoints.gui_heartbeat(self.gui_id),
+                messages.StatusMessage(name=self.gui_id, status=self.status, info={}),
+                expire=10,
+            )
+        except RedisError as exc:
+            logger.error(f"Error while emitting heartbeat: {exc}")
+
+    def broadcast_registry_update(self, connections: dict) -> None:
+        """
+        Broadcast the registry update to all the callbacks.
+        This method is called whenever the registry is updated.
+        """
+        data = {}
+        for key, val in connections.items():
+            if not isinstance(val, BECConnector):
+                continue
+            if not getattr(val, "RPC", True):
+                continue
+            data[key] = self._serialize_bec_connector(val)
+        if self._broadcasted_data == data:
+            return
+        self._broadcasted_data = data
+
+        logger.info(f"Broadcasting registry update: {data} for {self.gui_id}")
+        self.client.connector.xadd(
+            MessageEndpoints.gui_registry_state(self.gui_id),
+            msg_dict={"data": messages.GUIRegistryStateMessage(state=data)},
+            max_size=1,
+        )
+
+    def _serialize_bec_connector(self, connector: BECConnector, wait=False) -> dict:
+        """
+        Create the serialization dict for a single BECConnector.
+
+        Args:
+            connector (BECConnector): The BECConnector to serialize.
+            wait (bool): If True, wait until the object is registered in the RPC register.
+
+        Returns:
+            dict: The serialized BECConnector object.
+        """
+
+        config_dict = connector.config.model_dump()
+        config_dict["parent_id"] = getattr(connector, "parent_id", None)
+
+        try:
+            parent = connector.parent()
+            if isinstance(parent, BECMainWindow):
+                container_proxy = parent.gui_id
+            else:
+                container_proxy = None
+        except Exception:
+            container_proxy = None
+
+        if wait:
+            while not self.rpc_register.object_is_registered(connector):
+                QApplication.processEvents()
+
+        widget_class = getattr(connector, "rpc_widget_class", None)
+        if not widget_class:
+            widget_class = connector.__class__.__name__
+
+        return {
+            "gui_id": connector.gui_id,
+            "object_name": connector.object_name or connector.__class__.__name__,
+            "widget_class": widget_class,
+            "config": config_dict,
+            "container_proxy": container_proxy,
+            "__rpc__": True,
+        }
+
+    @staticmethod
+    def _get_becwidget_ancestor(widget: QObject) -> BECConnector | None:
+        """
+        Traverse up the parent chain to find the nearest BECConnector.
+        Returns None if none is found.
+        """
+
+        parent = widget.parent()
+        while parent is not None:
+            if isinstance(parent, BECConnector):
+                return parent
+            parent = parent.parent()
+        return None
+
+    # Suppose clients register callbacks to receive updates
+    def add_registry_update_callback(self, cb: Callable) -> None:
+        """
+        Add a callback to be called whenever the registry is updated.
+        The specified callback is called whenever the registry is updated.
+
+        Args:
+            cb (Callable): The callback to be added. It should accept a dictionary of all the
+            registered RPC objects as an argument.
+        """
+        self._registry_update_callbacks.append(cb)
+
+    def shutdown(self):  # TODO not sure if needed when cleanup is done at level of BECConnector
+        self.status = messages.BECStatus.IDLE
+        self._heartbeat_timer.stop()
+        self.emit_heartbeat()
+        logger.info("Succeded in shutting down CLI server")
+        self.client.shutdown()

bec_widgets/utils/serialization.py

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

bec_widgets/utils/settings_dialog.py

@@ -1,7 +1,11 @@
+from bec_lib.logger import bec_logger
+from PySide6.QtGui import QCloseEvent
 from qtpy.QtWidgets import QDialog, QDialogButtonBox, QHBoxLayout, QPushButton, QVBoxLayout, QWidget
 
 from bec_widgets.utils.error_popups import SafeSlot
 
+logger = bec_logger.logger
+
 
 class SettingWidget(QWidget):
     """
@@ -37,6 +41,15 @@ class SettingWidget(QWidget):
         """
         pass
 
+    def cleanup(self):
+        """
+        Cleanup the settings widget.
+        """
+
+    def closeEvent(self, event: QCloseEvent) -> None:
+        self.cleanup()
+        return super().closeEvent(event)
+
 
 class SettingsDialog(QDialog):
     """
@@ -99,8 +112,17 @@ class SettingsDialog(QDialog):
         Accept the changes made in the settings widget and close the dialog.
         """
         self.widget.accept_changes()
+        self.cleanup()
         super().accept()
 
+    @SafeSlot()
+    def reject(self):
+        """
+        Reject the changes made in the settings widget and close the dialog.
+        """
+        self.cleanup()
+        super().reject()
+
     @SafeSlot()
     def apply_changes(self):
         """
@@ -114,7 +136,10 @@ class SettingsDialog(QDialog):
         """
         self.button_box.close()
         self.button_box.deleteLater()
+        self.widget.close()
+        self.widget.deleteLater()
 
     def closeEvent(self, event):
+        logger.info("Closing settings dialog")
         self.cleanup()
         super().closeEvent(event)

bec_widgets/utils/side_panel.py

@@ -31,16 +31,17 @@ class SidePanel(QWidget):
         panel_max_width: int = 200,
         animation_duration: int = 200,
         animations_enabled: bool = True,
+        show_toolbar: bool = True,
     ):
         super().__init__(parent=parent)
 
         self.setProperty("skip_settings", True)
-        self.setObjectName("SidePanel")
 
         self._orientation = orientation
         self._panel_max_width = panel_max_width
         self._animation_duration = animation_duration
         self._animations_enabled = animations_enabled
+        self._show_toolbar = show_toolbar
 
         self._panel_width = 0
         self._panel_height = 0
@@ -60,7 +61,7 @@ class SidePanel(QWidget):
             self.main_layout.setContentsMargins(0, 0, 0, 0)
             self.main_layout.setSpacing(0)
 
-            self.toolbar = ModularToolBar(target_widget=self, orientation="vertical")
+            self.toolbar = ModularToolBar(parent=self, target_widget=self, orientation="vertical")
 
             self.container = QWidget()
             self.container.layout = QVBoxLayout(self.container)
@@ -72,13 +73,14 @@ class SidePanel(QWidget):
             self.stack_widget.setMinimumWidth(5)
             self.stack_widget.setMaximumWidth(self._panel_max_width)
 
-            if self._orientation == "left":
-                self.main_layout.addWidget(self.toolbar)
-                self.main_layout.addWidget(self.container)
-            else:
-                self.main_layout.addWidget(self.container)
-                self.main_layout.addWidget(self.toolbar)
+            if self._orientation in ("left", "right"):
+                if self._show_toolbar:
+                    self.main_layout.addWidget(self.toolbar)
 
+                if self._orientation == "left":
+                    self.main_layout.addWidget(self.container)
+                else:
+                    self.main_layout.insertWidget(0, self.container)
             self.container.layout.addWidget(self.stack_widget)
 
             self.menu_anim = QPropertyAnimation(self, b"panel_width")
@@ -90,7 +92,7 @@ class SidePanel(QWidget):
             self.main_layout.setContentsMargins(0, 0, 0, 0)
             self.main_layout.setSpacing(0)
 
-            self.toolbar = ModularToolBar(target_widget=self, orientation="horizontal")
+            self.toolbar = ModularToolBar(parent=self, target_widget=self, orientation="horizontal")
 
             self.container = QWidget()
             self.container.layout = QVBoxLayout(self.container)
@@ -103,11 +105,13 @@ class SidePanel(QWidget):
             self.stack_widget.setMaximumHeight(self._panel_max_width)
 
             if self._orientation == "top":
-                self.main_layout.addWidget(self.toolbar)
+                if self._show_toolbar:
+                    self.main_layout.addWidget(self.toolbar)
                 self.main_layout.addWidget(self.container)
             else:
                 self.main_layout.addWidget(self.container)
-                self.main_layout.addWidget(self.toolbar)
+                if self._show_toolbar:
+                    self.main_layout.addWidget(self.toolbar)
 
             self.container.layout.addWidget(self.stack_widget)
 
@@ -234,21 +238,24 @@ class SidePanel(QWidget):
 
     def add_menu(
         self,
-        action_id: str,
-        icon_name: str,
-        tooltip: str,
         widget: QWidget,
+        action_id: str | None = None,
+        icon_name: str | None = None,
+        tooltip: str | None = None,
         title: str | None = None,
-    ):
+    ) -> int:
         """
         Add a menu to the side panel.
 
         Args:
-            action_id(str): The ID of the action.
-            icon_name(str): The name of the icon.
-            tooltip(str): The tooltip for the action.
             widget(QWidget): The widget to add to the panel.
-            title(str): The title of the panel.
+            action_id(str | None): The ID of the action. Optional if no toolbar action is needed.
+            icon_name(str | None): The name of the icon. Optional if no toolbar action is needed.
+            tooltip(str | None): The tooltip for the action. Optional if no toolbar action is needed.
+            title(str | None): The title of the panel.
+
+        Returns:
+            int: The index of the added panel, which can be used with show_panel() and switch_to().
         """
         # container_widget: top-level container for the stacked page
         container_widget = QWidget()
@@ -279,32 +286,35 @@ class SidePanel(QWidget):
         index = self.stack_widget.count()
         self.stack_widget.addWidget(container_widget)
 
-        # Add an action to the toolbar
-        action = MaterialIconAction(icon_name=icon_name, tooltip=tooltip, checkable=True)
-        self.toolbar.add_action(action_id, action, target_widget=self)
+        # Add an action to the toolbar if action_id, icon_name, and tooltip are provided
+        if action_id is not None and icon_name is not None and tooltip is not None:
+            action = MaterialIconAction(icon_name=icon_name, tooltip=tooltip, checkable=True)
+            self.toolbar.add_action(action_id, action, target_widget=self)
 
-        def on_action_toggled(checked: bool):
-            if self.switching_actions:
-                return
+            def on_action_toggled(checked: bool):
+                if self.switching_actions:
+                    return
 
-            if checked:
-                if self.current_action and self.current_action != action.action:
-                    self.switching_actions = True
-                    self.current_action.setChecked(False)
-                    self.switching_actions = False
+                if checked:
+                    if self.current_action and self.current_action != action.action:
+                        self.switching_actions = True
+                        self.current_action.setChecked(False)
+                        self.switching_actions = False
 
-                self.current_action = action.action
+                    self.current_action = action.action
 
-                if not self.panel_visible:
-                    self.show_panel(index)
+                    if not self.panel_visible:
+                        self.show_panel(index)
+                    else:
+                        self.switch_to(index)
                 else:
-                    self.switch_to(index)
-            else:
-                if self.current_action == action.action:
-                    self.current_action = None
-                    self.hide_panel()
+                    if self.current_action == action.action:
+                        self.current_action = None
+                        self.hide_panel()
 
-        action.action.toggled.connect(on_action_toggled)
+            action.action.toggled.connect(on_action_toggled)
+
+        return index
 
 
 ############################################
@@ -333,41 +343,56 @@ class ExampleApp(QMainWindow):  # pragma: no cover
         self.add_side_menus()
 
     def add_side_menus(self):
+        # Example 1: With action, icon, and tooltip
         widget1 = QWidget()
         layout1 = QVBoxLayout(widget1)
         for i in range(15):
             layout1.addWidget(QLabel(f"Widget 1 label row {i}"))
         self.side_panel.add_menu(
+            widget=widget1,
             action_id="widget1",
             icon_name="counter_1",
             tooltip="Show Widget 1",
-            widget=widget1,
             title="Widget 1 Panel",
         )
 
+        # Example 2: With action, icon, and tooltip
         widget2 = QWidget()
         layout2 = QVBoxLayout(widget2)
         layout2.addWidget(QLabel("Short widget 2 content"))
         self.side_panel.add_menu(
+            widget=widget2,
             action_id="widget2",
             icon_name="counter_2",
             tooltip="Show Widget 2",
-            widget=widget2,
             title="Widget 2 Panel",
         )
 
+        # Example 3: With action, icon, and tooltip
         widget3 = QWidget()
         layout3 = QVBoxLayout(widget3)
         for i in range(10):
             layout3.addWidget(QLabel(f"Line {i} for Widget 3"))
         self.side_panel.add_menu(
+            widget=widget3,
             action_id="widget3",
             icon_name="counter_3",
             tooltip="Show Widget 3",
-            widget=widget3,
             title="Widget 3 Panel",
         )
 
+        # Example 4: Without action, icon, and tooltip (can only be shown programmatically)
+        widget4 = QWidget()
+        layout4 = QVBoxLayout(widget4)
+        layout4.addWidget(QLabel("This panel has no toolbar button"))
+        layout4.addWidget(QLabel("It can only be shown programmatically"))
+        self.hidden_panel_index = self.side_panel.add_menu(widget=widget4, title="Hidden Panel")
+
+        # Example of how to show the hidden panel programmatically after 3 seconds
+        from qtpy.QtCore import QTimer
+
+        QTimer.singleShot(3000, lambda: self.side_panel.show_panel(self.hidden_panel_index))
+
 
 if __name__ == "__main__":  # pragma: no cover
     app = QApplication(sys.argv)

bec_widgets/utils/toolbar.py

@@ -7,6 +7,7 @@ from abc import ABC, abstractmethod
 from collections import defaultdict
 from typing import Dict, List, Literal, Tuple
 
+from bec_lib.logger import bec_logger
 from bec_qthemes._icon.material_icons import material_icon
 from qtpy.QtCore import QSize, Qt, QTimer
 from qtpy.QtGui import QAction, QColor, QIcon
@@ -31,6 +32,8 @@ from bec_widgets.widgets.utility.visual.dark_mode_button.dark_mode_button import
 
 MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 
+logger = bec_logger.logger
+
 # Ensure that icons are shown in menus (especially on macOS)
 QApplication.setAttribute(Qt.AA_DontShowIconsInMenus, False)
 
@@ -118,7 +121,7 @@ class IconAction(ToolBarAction):
     def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
         icon = QIcon()
         icon.addFile(self.icon_path, size=QSize(20, 20))
-        self.action = QAction(icon, self.tooltip, target)
+        self.action = QAction(icon=icon, text=self.tooltip, parent=target)
         self.action.setCheckable(self.checkable)
         toolbar.addAction(self.action)
 
@@ -128,7 +131,7 @@ class QtIconAction(ToolBarAction):
         super().__init__(icon_path=None, tooltip=tooltip, checkable=checkable)
         self.standard_icon = standard_icon
         self.icon = QApplication.style().standardIcon(standard_icon)
-        self.action = QAction(self.icon, self.tooltip, parent)
+        self.action = QAction(icon=self.icon, text=self.tooltip, parent=parent)
         self.action.setCheckable(self.checkable)
 
     def add_to_toolbar(self, toolbar, target):
@@ -173,7 +176,11 @@ class MaterialIconAction(ToolBarAction):
             filled=self.filled,
             color=self.color,
         )
-        self.action = QAction(self.icon, self.tooltip, parent=parent)
+        if parent is None:
+            logger.warning(
+                "MaterialIconAction was created without a parent. Please consider adding one. Using None as parent may cause issues."
+            )
+        self.action = QAction(icon=self.icon, text=self.tooltip, parent=parent)
         self.action.setCheckable(self.checkable)
 
     def add_to_toolbar(self, toolbar: QToolBar, target: QWidget):
@@ -212,12 +219,12 @@ class DeviceSelectionAction(ToolBarAction):
         self.device_combobox.currentIndexChanged.connect(lambda: self.set_combobox_style("#ffa700"))
 
     def add_to_toolbar(self, toolbar, target):
-        widget = QWidget()
+        widget = QWidget(parent=target)
         layout = QHBoxLayout(widget)
         layout.setContentsMargins(0, 0, 0, 0)
         layout.setSpacing(0)
         if self.label is not None:
-            label = QLabel(f"{self.label}")
+            label = QLabel(text=f"{self.label}", parent=target)
             layout.addWidget(label)
         if self.device_combobox is not None:
             layout.addWidget(self.device_combobox)
@@ -280,7 +287,9 @@ class SwitchableToolBarAction(ToolBarAction):
         self.main_button.clicked.connect(self._trigger_current_action)
         menu = QMenu(self.main_button)
         for key, action_obj in self.actions.items():
-            menu_action = QAction(action_obj.get_icon(), action_obj.tooltip, self.main_button)
+            menu_action = QAction(
+                icon=action_obj.get_icon(), text=action_obj.tooltip, parent=self.main_button
+            )
             menu_action.setIconVisibleInMenu(True)
             menu_action.setCheckable(self.checkable)
             menu_action.setChecked(key == self.current_key)
@@ -369,13 +378,13 @@ class WidgetAction(ToolBarAction):
             toolbar (QToolBar): The toolbar to add the widget to.
             target (QWidget): The target widget for the action.
         """
-        self.container = QWidget()
+        self.container = QWidget(parent=target)
         layout = QHBoxLayout(self.container)
         layout.setContentsMargins(0, 0, 0, 0)
         layout.setSpacing(0)
 
         if self.label is not None:
-            label_widget = QLabel(f"{self.label}")
+            label_widget = QLabel(text=f"{self.label}", parent=target)
             label_widget.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
             label_widget.setAlignment(Qt.AlignVCenter | Qt.AlignRight)
             layout.addWidget(label_widget)
@@ -437,7 +446,7 @@ class ExpandableMenuAction(ToolBarAction):
         )
         menu = QMenu(button)
         for action_id, action in self.actions.items():
-            sub_action = QAction(action.tooltip, target)
+            sub_action = QAction(text=action.tooltip, parent=target)
             sub_action.setIconVisibleInMenu(True)
             if action.icon_path:
                 icon = QIcon()
@@ -521,7 +530,7 @@ class ModularToolBar(QToolBar):
         orientation: Literal["horizontal", "vertical"] = "horizontal",
         background_color: str = "rgba(0, 0, 0, 0)",
     ):
-        super().__init__(parent)
+        super().__init__(parent=parent)
 
         self.widgets = defaultdict(dict)
         self.background_color = background_color
@@ -700,6 +709,85 @@ class ModularToolBar(QToolBar):
         self.bundles[bundle_id].append(action_id)
         self.update_separators()
 
+    def remove_action(self, action_id: str):
+        """
+        Completely remove a single action from the toolbar.
+
+        The method takes care of both standalone actions and actions that are
+        part of an existing bundle.
+
+        Args:
+            action_id (str): Unique identifier for the action.
+        """
+        if action_id not in self.widgets:
+            raise ValueError(f"Action with ID '{action_id}' does not exist.")
+
+        # Identify potential bundle membership
+        parent_bundle = None
+        for b_id, a_ids in self.bundles.items():
+            if action_id in a_ids:
+                parent_bundle = b_id
+                break
+
+        # 1. Remove the QAction from the QToolBar and delete it
+        tool_action = self.widgets.pop(action_id)
+        if hasattr(tool_action, "action") and tool_action.action is not None:
+            self.removeAction(tool_action.action)
+            tool_action.action.deleteLater()
+
+        # 2. Clean bundle bookkeeping if the action belonged to one
+        if parent_bundle:
+            self.bundles[parent_bundle].remove(action_id)
+            # If the bundle becomes empty, get rid of the bundle entry as well
+            if not self.bundles[parent_bundle]:
+                self.remove_bundle(parent_bundle)
+
+        # 3. Remove from the ordering list
+        self.toolbar_items = [
+            item
+            for item in self.toolbar_items
+            if not (item[0] == "action" and item[1] == action_id)
+        ]
+
+        self.update_separators()
+
+    def remove_bundle(self, bundle_id: str):
+        """
+        Remove an entire bundle (and all of its actions) from the toolbar.
+
+        Args:
+            bundle_id (str): Unique identifier for the bundle.
+        """
+        if bundle_id not in self.bundles:
+            raise ValueError(f"Bundle '{bundle_id}' does not exist.")
+
+        # Remove every action belonging to this bundle
+        for action_id in list(self.bundles[bundle_id]):  # copy the list
+            if action_id in self.widgets:
+                tool_action = self.widgets.pop(action_id)
+                if hasattr(tool_action, "action") and tool_action.action is not None:
+                    self.removeAction(tool_action.action)
+                    tool_action.action.deleteLater()
+
+        # Drop the bundle entry
+        self.bundles.pop(bundle_id, None)
+
+        # Remove bundle entry and its preceding separator (if any) from the ordering list
+        cleaned_items = []
+        skip_next_separator = False
+        for item_type, ident in self.toolbar_items:
+            if item_type == "bundle" and ident == bundle_id:
+                # mark to skip one following separator if present
+                skip_next_separator = True
+                continue
+            if skip_next_separator and item_type == "separator":
+                skip_next_separator = False
+                continue
+            cleaned_items.append((item_type, ident))
+        self.toolbar_items = cleaned_items
+
+        self.update_separators()
+
     def contextMenuEvent(self, event):
         """
         Overrides the context menu event to show toolbar actions with checkboxes and icons.
@@ -858,7 +946,7 @@ class MainWindow(QMainWindow):  # pragma: no cover
 
         # For theme testing
 
-        self.dark_button = DarkModeButton(toolbar=True)
+        self.dark_button = DarkModeButton(parent=self, toolbar=True)
         dark_mode_action = WidgetAction(label=None, widget=self.dark_button)
         self.toolbar.add_action("dark_mode", dark_mode_action, self)
 

bec_widgets/utils/ui_loader.py

@@ -1,16 +1,18 @@
-import os
-
-from qtpy import PYQT6, PYSIDE6, QT_VERSION
+from bec_lib.logger import bec_logger
+from qtpy import PYQT6, PYSIDE6
 from qtpy.QtCore import QFile, QIODevice
 
+from bec_widgets.utils.bec_plugin_helper import get_all_plugin_widgets
 from bec_widgets.utils.generate_designer_plugin import DesignerPluginInfo
 from bec_widgets.utils.plugin_utils import get_custom_classes
 
+logger = bec_logger.logger
+
 if PYSIDE6:
     from PySide6.QtUiTools import QUiLoader
 
     class CustomUiLoader(QUiLoader):
-        def __init__(self, baseinstance, custom_widgets: dict = None):
+        def __init__(self, baseinstance, custom_widgets: dict | None = None):
             super().__init__(baseinstance)
             self.custom_widgets = custom_widgets or {}
 
@@ -18,10 +20,9 @@ if PYSIDE6:
 
         def createWidget(self, class_name, parent=None, name=""):
             if class_name in self.custom_widgets:
-                widget = self.custom_widgets[class_name](parent)
-                widget.setObjectName(name)
+                widget = self.custom_widgets[class_name](self.baseinstance)
                 return widget
-            return super().createWidget(class_name, parent, name)
+            return super().createWidget(class_name, self.baseinstance, name)
 
 
 class UILoader:
@@ -34,6 +35,9 @@ class UILoader:
 
         self.custom_widgets = {widget.__name__: widget for widget in widgets}
 
+        plugin_widgets = get_all_plugin_widgets()
+        self.custom_widgets.update(plugin_widgets)
+
         if PYSIDE6:
             self.loader = self.load_ui_pyside6
         elif PYQT6:
@@ -51,7 +55,7 @@ class UILoader:
         Returns:
             QWidget: The loaded widget.
         """
-
+        parent = parent or self.parent
         loader = CustomUiLoader(parent, self.custom_widgets)
         file = QFile(ui_file)
         if not file.open(QIODevice.ReadOnly):

bec_widgets/utils/widget_io.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 
+import shiboken6 as shb
 from qtpy.QtWidgets import (
     QApplication,
     QCheckBox,
@@ -275,39 +276,162 @@ class WidgetHierarchy:
         grab_values: bool = False,
         prefix: str = "",
         exclude_internal_widgets: bool = True,
+        only_bec_widgets: bool = False,
+        show_parent: bool = True,
     ) -> None:
         """
         Print the widget hierarchy to the console.
 
         Args:
-            widget: Widget to print the hierarchy of
+            widget: Widget to print the hierarchy of.
             indent(int, optional): Level of indentation.
             grab_values(bool,optional): Whether to grab the values of the widgets.
-            prefix(stc,optional): Custom string prefix for indentation.
+            prefix(str,optional): Custom string prefix for indentation.
             exclude_internal_widgets(bool,optional): Whether to exclude internal widgets (e.g. QComboBox in PyQt6).
+            only_bec_widgets(bool, optional): Whether to print only widgets that are instances of BECWidget.
+            show_parent(bool, optional): Whether to display which BECWidget is the parent of each discovered BECWidget.
         """
-        widget_info = f"{widget.__class__.__name__} ({widget.objectName()})"
-        if grab_values:
-            value = WidgetIO.get_value(widget, ignore_errors=True)
-            value_str = f" [value: {value}]" if value is not None else ""
-            widget_info += value_str
+        from bec_widgets.utils import BECConnector
+        from bec_widgets.widgets.plots.waveform.waveform import Waveform
 
+        # 1) Filter out widgets that are not BECConnectors (if 'only_bec_widgets' is True)
+        is_bec = isinstance(widget, BECConnector)
+        if only_bec_widgets and not is_bec:
+            return
+
+        # 2) Determine and print the parent's info (closest BECConnector)
+        parent_info = ""
+        if show_parent and is_bec:
+            ancestor = WidgetHierarchy._get_becwidget_ancestor(widget)
+            if ancestor:
+                parent_label = ancestor.objectName() or ancestor.__class__.__name__
+                parent_info = f" parent={parent_label}"
+            else:
+                parent_info = " parent=None"
+
+        widget_info = f"{widget.__class__.__name__} ({widget.objectName()}){parent_info}"
         print(prefix + widget_info)
 
-        children = widget.children()
-        for child in children:
-            if (
-                exclude_internal_widgets
-                and isinstance(widget, QComboBox)
-                and child.__class__.__name__ in ["QFrame", "QBoxLayout", "QListView"]
-            ):
+        # 3) If it's a Waveform, explicitly print the curves
+        if isinstance(widget, Waveform):
+            for curve in widget.curves:
+                curve_prefix = prefix + "  └─ "
+                print(
+                    f"{curve_prefix}{curve.__class__.__name__} ({curve.objectName()}) "
+                    f"parent={widget.objectName()}"
+                )
+
+        # 4) Recursively handle each child if:
+        #    - It's a QWidget
+        #    - It is a BECConnector (or we don't care about filtering)
+        #    - Its closest BECConnector parent is the current widget
+        for child in widget.findChildren(QWidget):
+            if only_bec_widgets and not isinstance(child, BECConnector):
                 continue
-            child_prefix = prefix + "  "
-            arrow = "├─ " if child != children[-1] else "└─ "
+
+            # if WidgetHierarchy._get_becwidget_ancestor(child) == widget:
+            child_prefix = prefix + "  └─ "
             WidgetHierarchy.print_widget_hierarchy(
-                child, indent + 1, grab_values, prefix=child_prefix + arrow
+                child,
+                indent=indent + 1,
+                grab_values=grab_values,
+                prefix=child_prefix,
+                exclude_internal_widgets=exclude_internal_widgets,
+                only_bec_widgets=only_bec_widgets,
+                show_parent=show_parent,
             )
 
+    @staticmethod
+    def print_becconnector_hierarchy_from_app():
+        """
+        Enumerate ALL BECConnector objects in the QApplication.
+        Also detect if a widget is a PlotBase, and add any data items
+        (PlotDataItem-like) that are also BECConnector objects.
+
+        Build a parent->children graph where each child's 'parent'
+        is its closest BECConnector ancestor. Print the entire hierarchy
+        from the root(s).
+
+        The result is a single, consolidated tree for your entire
+        running GUI, including PlotBase data items that are BECConnector.
+        """
+        import sys
+        from collections import defaultdict
+
+        from qtpy.QtWidgets import QApplication
+
+        from bec_widgets.utils import BECConnector
+        from bec_widgets.widgets.plots.plot_base import PlotBase
+
+        # 1) Gather ALL QWidget-based BECConnector objects
+        all_qwidgets = QApplication.allWidgets()
+        bec_widgets = set(w for w in all_qwidgets if isinstance(w, BECConnector))
+
+        # 2) Also gather any BECConnector-based data items from PlotBase widgets
+        for w in all_qwidgets:
+            if isinstance(w, PlotBase) and hasattr(w, "plot_item"):
+                plot_item = w.plot_item
+                if hasattr(plot_item, "listDataItems"):
+                    for data_item in plot_item.listDataItems():
+                        if isinstance(data_item, BECConnector):
+                            bec_widgets.add(data_item)
+
+        # 3) Build a map of (closest BECConnector parent) -> list of children
+        parent_map = defaultdict(list)
+        for w in bec_widgets:
+            parent_bec = WidgetHierarchy._get_becwidget_ancestor(w)
+            parent_map[parent_bec].append(w)
+
+        # 4) Define a recursive printer to show each object's children
+        def print_tree(parent, prefix=""):
+            children = parent_map[parent]
+            for i, child in enumerate(children):
+                connector_class = child.__class__.__name__
+                connector_name = child.objectName() or connector_class
+
+                if parent is None:
+                    parent_label = "None"
+                else:
+                    parent_label = parent.objectName() or parent.__class__.__name__
+
+                line = f"{connector_class} ({connector_name}) parent={parent_label}"
+                # Determine tree-branch symbols
+                is_last = i == len(children) - 1
+                branch_str = "└─ " if is_last else "├─ "
+                print(prefix + branch_str + line)
+
+                # Recurse deeper
+                next_prefix = prefix + ("   " if is_last else "│  ")
+                print_tree(child, prefix=next_prefix)
+
+        # 5) Print top-level items (roots) whose BECConnector parent is None
+        roots = parent_map[None]
+        for r_i, root in enumerate(roots):
+            root_class = root.__class__.__name__
+            root_name = root.objectName() or root_class
+            line = f"{root_class} ({root_name}) parent=None"
+            is_last_root = r_i == len(roots) - 1
+            print(line)
+            # Recurse into its children
+            print_tree(root, prefix="   ")
+
+    @staticmethod
+    def _get_becwidget_ancestor(widget):
+        """
+        Traverse up the parent chain to find the nearest BECConnector.
+        Returns None if none is found.
+        """
+        from bec_widgets.utils import BECConnector
+
+        if not shb.isValid(widget):
+            return None
+        parent = widget.parent()
+        while parent is not None:
+            if isinstance(parent, BECConnector):
+                return parent
+            parent = parent.parent()
+        return None
+
     @staticmethod
     def export_config_to_dict(
         widget: QWidget,

bec_widgets/widgets/containers/auto_update/auto_updates.py

@@ -0,0 +1,364 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal, overload
+
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.logger import bec_logger
+from bec_lib.messages import ScanStatusMessage
+
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.widgets.containers.dock.dock_area import BECDockArea
+from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
+
+if TYPE_CHECKING:  # pragma: no cover
+    from bec_widgets.utils.bec_widget import BECWidget
+    from bec_widgets.widgets.containers.dock.dock import BECDock
+    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.scatter_waveform.scatter_waveform import ScatterWaveform
+    from bec_widgets.widgets.plots.waveform.waveform import Waveform
+
+
+logger = bec_logger.logger
+
+
+class AutoUpdates(BECMainWindow):
+    _default_dock: BECDock
+    USER_ACCESS = ["enabled", "enabled.setter", "selected_device", "selected_device.setter"]
+    RPC = True
+
+    # enforce that subclasses have the same rpc widget class
+    rpc_widget_class = "AutoUpdates"
+
+    def __init__(
+        self, parent=None, gui_id: str = None, window_title="Auto Update", *args, **kwargs
+    ):
+        super().__init__(parent=parent, gui_id=gui_id, window_title=window_title, **kwargs)
+
+        self.dock_area = BECDockArea(parent=self, object_name="dock_area")
+        self.setCentralWidget(self.dock_area)
+        self._auto_update_selected_device: str | None = None
+
+        self._default_dock = None  # type:ignore
+        self.current_widget: BECWidget | None = None
+        self.dock_name = None
+        self._enabled = True
+        self.start_auto_update()
+
+    def start_auto_update(self):
+        """
+        Establish all connections for the auto updates.
+        """
+        self.bec_dispatcher.connect_slot(self._on_scan_status, MessageEndpoints.scan_status())
+
+    def stop_auto_update(self):
+        """
+        Disconnect all connections for the auto updates.
+        """
+        self.bec_dispatcher.disconnect_slot(
+            self._on_scan_status, MessageEndpoints.scan_status()  # type:ignore
+        )
+
+    @property
+    def selected_device(self) -> str | None:
+        """
+        Get the selected device from the auto update config.
+
+        Returns:
+            str: The selected device. If no device is selected, None is returned.
+        """
+        return self._auto_update_selected_device
+
+    @selected_device.setter
+    def selected_device(self, value: str | None) -> None:
+        """
+        Set the selected device in the auto update config.
+
+        Args:
+            value(str): The selected device.
+        """
+        self._auto_update_selected_device = value
+
+    @SafeSlot()
+    def _on_scan_status(self, content: dict, metadata: dict) -> None:
+        """
+        Callback for scan status messages.
+        """
+        msg = ScanStatusMessage(**content, metadata=metadata)
+        if not self.enabled:
+            return
+
+        self.enable_gui_highlights(True)
+
+        match msg.status:
+            case "open":
+                self.on_scan_open(msg)
+            case "closed":
+                self.on_scan_closed(msg)
+            case ["aborted", "halted"]:
+                self.on_scan_abort(msg)
+            case _:
+                pass
+
+    def start_default_dock(self):
+        """
+        Create a default dock for the auto updates.
+        """
+        self.dock_name = "update_dock"
+        self._default_dock = self.dock_area.new(self.dock_name)
+        self.current_widget = self._default_dock.new("Waveform")
+
+    @overload
+    def set_dock_to_widget(self, widget: Literal["Waveform"]) -> Waveform: ...
+
+    @overload
+    def set_dock_to_widget(self, widget: Literal["Image"]) -> Image: ...
+
+    @overload
+    def set_dock_to_widget(self, widget: Literal["ScatterWaveform"]) -> ScatterWaveform: ...
+
+    @overload
+    def set_dock_to_widget(self, widget: Literal["MotorMap"]) -> MotorMap: ...
+
+    @overload
+    def set_dock_to_widget(self, widget: Literal["MultiWaveform"]) -> MultiWaveform: ...
+
+    def set_dock_to_widget(
+        self,
+        widget: Literal["Waveform", "Image", "ScatterWaveform", "MotorMap", "MultiWaveForm"] | str,
+    ) -> BECWidget:
+        """
+        Set the dock to the widget.
+
+        Args:
+            widget (str): The widget to set the dock to. Must be the name of a valid widget class.
+
+        Returns:
+            BECWidget: The widget that was set.
+        """
+        if self._default_dock is None or self.current_widget is None:
+            logger.warning(
+                f"Auto Updates: No default dock found. Creating a new one with name {self.dock_name}"
+            )
+            self.start_default_dock()
+        assert self.current_widget is not None
+
+        if not self.current_widget.__class__.__name__ == widget:
+            self._default_dock.delete(self.current_widget.object_name)
+            self.current_widget = self._default_dock.new(widget)
+        return self.current_widget
+
+    def get_selected_device(
+        self, monitored_devices, selected_device: str | None = None
+    ) -> str | None:
+        """
+        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 is None:
+            selected_device = self.selected_device
+        if selected_device:
+            return selected_device
+        if len(monitored_devices) > 0:
+            sel_device = monitored_devices[0]
+            return sel_device
+        return None
+
+    def enable_gui_highlights(self, enable: bool) -> None:
+        """
+        Enable or disable GUI highlights.
+
+        Args:
+            enable (bool): Whether to enable or disable the highlights.
+        """
+        if enable:
+            title = self.dock_area.window().windowTitle()
+            if " [Auto Updates]" in title:
+                return
+            self.dock_area.window().setWindowTitle(f"{title} [Auto Updates]")
+        else:
+            title = self.dock_area.window().windowTitle()
+            self.dock_area.window().setWindowTitle(title.replace(" [Auto Updates]", ""))
+
+    @property
+    def enabled(self) -> bool:
+        """
+        Get the enabled status of the auto updates.
+        """
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, value: bool) -> None:
+        """
+        Set the enabled status of the auto updates.
+        """
+        if self._enabled == value:
+            return
+        self._enabled = value
+
+        if value:
+            self.start_auto_update()
+            self.enable_gui_highlights(True)
+            self.on_start()
+        else:
+            self.stop_auto_update()
+            self.enable_gui_highlights(False)
+            self.on_stop()
+
+    def cleanup(self) -> None:
+        """
+        Cleanup procedure to run when the auto updates are disabled.
+        """
+        self.enabled = False
+        self.stop_auto_update()
+        self.dock_area.close()
+        self.dock_area.deleteLater()
+        self.dock_area = None
+        super().cleanup()
+
+    ########################################################################
+    ################# Update Functions #####################################
+    ########################################################################
+
+    def simple_line_scan(self, info: ScanStatusMessage) -> None:
+        """
+        Simple line scan.
+
+        Args:
+            info (ScanStatusMessage): The scan status message.
+        """
+
+        # Set the dock to the waveform widget
+        wf = self.set_dock_to_widget("Waveform")
+
+        # Get the scan report devices reported by the scan
+        dev_x = info.scan_report_devices[0]  # type:ignore
+
+        # For the y axis, get the selected device
+        dev_y = self.get_selected_device(info.readout_priority["monitored"])  # type:ignore
+        if not dev_y:
+            return
+
+        # Clear the waveform widget and plot the data
+        # with the scan number and device names
+        # as the label and title
+        wf.clear_all()
+        wf.plot(
+            x_name=dev_x,
+            y_name=dev_y,
+            label=f"Scan {info.scan_number} - {dev_y}",
+            title=f"Scan {info.scan_number}",
+            x_label=dev_x,
+            y_label=dev_y,
+        )
+
+        logger.info(
+            f"Auto Update [simple_line_scan]: Started plot with: x_name={dev_x}, y_name={dev_y}"
+        )
+
+    def simple_grid_scan(self, info: ScanStatusMessage) -> None:
+        """
+        Simple grid scan.
+
+        Args:
+            info (ScanStatusMessage): The scan status message.
+        """
+        # Set the dock to the scatter waveform widget
+        scatter = self.set_dock_to_widget("ScatterWaveform")
+
+        # Get the scan report devices reported by the scan
+        dev_x, dev_y = info.scan_report_devices[0], info.scan_report_devices[1]  # type:ignore
+        dev_z = self.get_selected_device(info.readout_priority["monitored"])  # type:ignore
+
+        if None in (dev_x, dev_y, dev_z):
+            return
+
+        # Clear the scatter waveform widget and plot the data
+        scatter.clear_all()
+        scatter.plot(
+            x_name=dev_x, y_name=dev_y, z_name=dev_z, label=f"Scan {info.scan_number} - {dev_z}"
+        )
+
+        logger.info(
+            f"Auto Update [simple_grid_scan]: Started plot with: x_name={dev_x}, y_name={dev_y}, z_name={dev_z}"
+        )
+
+    def best_effort(self, info: ScanStatusMessage) -> None:
+        """
+        Best effort scan.
+
+        Args:
+            info (ScanStatusMessage): The scan status message.
+        """
+
+        # If the scan report devices are empty, there is nothing we can do
+        if not info.scan_report_devices:
+            return
+        dev_x = info.scan_report_devices[0]  # type:ignore
+        dev_y = self.get_selected_device(info.readout_priority["monitored"])  # type:ignore
+        if not dev_y:
+            return
+
+        # Set the dock to the waveform widget
+        wf = self.set_dock_to_widget("Waveform")
+
+        # Clear the waveform widget and plot the data
+        wf.clear_all()
+        wf.plot(
+            x_name=dev_x,
+            y_name=dev_y,
+            label=f"Scan {info.scan_number} - {dev_y}",
+            title=f"Scan {info.scan_number}",
+            x_label=dev_x,
+            y_label=dev_y,
+        )
+
+        logger.info(f"Auto Update [best_effort]: Started plot with: x_name={dev_x}, y_name={dev_y}")
+
+    #######################################################################
+    ################# GUI Callbacks #######################################
+    #######################################################################
+
+    def on_start(self) -> None:
+        """
+        Procedure to run when the auto updates are enabled.
+        """
+        self.start_default_dock()
+
+    def on_stop(self) -> None:
+        """
+        Procedure to run when the auto updates are disabled.
+        """
+
+    def on_scan_open(self, msg: ScanStatusMessage) -> None:
+        """
+        Procedure to run when a scan starts.
+
+        Args:
+            msg (ScanStatusMessage): The scan status message.
+        """
+        if msg.scan_name == "line_scan" and msg.scan_report_devices:
+            return self.simple_line_scan(msg)
+        if msg.scan_name == "grid_scan" and msg.scan_report_devices:
+            return self.simple_grid_scan(msg)
+        if msg.scan_report_devices:
+            return self.best_effort(msg)
+        return None
+
+    def on_scan_closed(self, msg: ScanStatusMessage) -> None:
+        """
+        Procedure to run when a scan ends.
+
+        Args:
+            msg (ScanStatusMessage): The scan status message.
+        """
+
+    def on_scan_abort(self, msg: ScanStatusMessage) -> None:
+        """
+        Procedure to run when a scan is aborted.
+
+        Args:
+            msg (ScanStatusMessage): The scan status message.
+        """

bec_widgets/widgets/containers/dock/dock.py

@@ -12,10 +12,11 @@ from bec_widgets.cli.rpc.rpc_widget_handler import widget_handler
 from bec_widgets.utils import ConnectionConfig, GridLayoutManager
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.container_utils import WidgetContainerUtils
+from bec_widgets.utils.error_popups import SafeSlot
 
 logger = bec_logger.logger
 
-if TYPE_CHECKING:
+if TYPE_CHECKING:  # pragma: no cover
     from qtpy.QtWidgets import QWidget
 
     from bec_widgets.widgets.containers.dock.dock_area import BECDockArea
@@ -130,9 +131,9 @@ class BECDock(BECWidget, Dock):
         self,
         parent: QWidget | None = None,
         parent_dock_area: BECDockArea | None = None,
-        parent_id: str | None = None,
         config: DockConfig | None = None,
         name: str | None = None,
+        object_name: str | None = None,
         client=None,
         gui_id: str | None = None,
         closable: bool = True,
@@ -148,12 +149,17 @@ class BECDock(BECWidget, Dock):
             if isinstance(config, dict):
                 config = DockConfig(**config)
             self.config = config
-        super().__init__(
-            client=client, config=config, gui_id=gui_id, name=name, parent_id=parent_id
-        )  # Name was checked and created in BEC Widget
         label = CustomDockLabel(text=name, closable=closable)
-        Dock.__init__(self, name=name, label=label, parent=self, **kwargs)
-        # Dock.__init__(self, name=name, **kwargs)
+        super().__init__(
+            parent=parent_dock_area,
+            name=name,
+            object_name=object_name,
+            client=client,
+            gui_id=gui_id,
+            config=config,
+            label=label,
+            **kwargs,
+        )
 
         self.parent_dock_area = parent_dock_area
         # Layout Manager
@@ -193,7 +199,7 @@ class BECDock(BECWidget, Dock):
             widgets(dict): The widgets in the dock.
         """
         # pylint: disable=protected-access
-        return dict((widget._name, widget) for widget in self.element_list)
+        return dict((widget.object_name, widget) for widget in self.element_list)
 
     @property
     def element_list(self) -> list[BECWidget]:
@@ -265,13 +271,15 @@ class BECDock(BECWidget, Dock):
         """
         return list(widget_handler.widget_classes.keys())
 
-    def _get_list_of_widget_name_of_parent_dock_area(self):
-        docks = self.parent_dock_area.panel_list
+    def _get_list_of_widget_name_of_parent_dock_area(self) -> list[str]:
+        if (docks := self.parent_dock_area.panel_list) is None:
+            return []
         widgets = []
         for dock in docks:
             widgets.extend(dock.elements.keys())
         return widgets
 
+    @SafeSlot(popup_error=True)
     def new(
         self,
         widget: BECWidget | str,
@@ -294,28 +302,15 @@ class BECDock(BECWidget, Dock):
             colspan(int): The number of columns the widget should span.
             shift(Literal["down", "up", "left", "right"]): The direction to shift the widgets if the position is occupied.
         """
+        if name is not None:
+            WidgetContainerUtils.raise_for_invalid_name(name, container=self)
+
         if row is None:
-            # row = cast(int, self.layout.rowCount())  # type:ignore
             row = self.layout.rowCount()
-            # row = cast(int, row)
 
         if self.layout_manager.is_position_occupied(row, col):
             self.layout_manager.shift_widgets(shift, start_row=row)
 
-        existing_widgets_parent_dock = self._get_list_of_widget_name_of_parent_dock_area()
-
-        if name is not None:  # Name is provided
-            if name in existing_widgets_parent_dock:
-                # pylint: disable=protected-access
-                raise ValueError(
-                    f"Name {name} must be unique for widgets, but already exists in DockArea "
-                    f"with name: {self.parent_dock_area._name} and id {self.parent_dock_area.gui_id}."
-                )
-        else:  # Name is not provided
-            widget_class_name = widget if isinstance(widget, str) else widget.__class__.__name__
-            name = WidgetContainerUtils.generate_unique_name(
-                name=widget_class_name, list_of_names=existing_widgets_parent_dock
-            )
         # Check that Widget is not BECDock or BECDockArea
         widget_class_name = widget if isinstance(widget, str) else widget.__class__.__name__
         if widget_class_name in IGNORE_WIDGETS:
@@ -325,16 +320,16 @@ class BECDock(BECWidget, Dock):
             widget = cast(
                 BECWidget,
                 widget_handler.create_widget(
-                    widget_type=widget, name=name, parent_dock=self, parent_id=self.gui_id
+                    widget_type=widget, object_name=name, parent_dock=self, parent=self
                 ),
             )
         else:
-            widget._name = name  # pylint: disable=protected-access
+            widget.object_name = name
 
         self.addWidget(widget, row=row, col=col, rowspan=rowspan, colspan=colspan)
         if hasattr(widget, "config"):
             widget.config.gui_id = widget.gui_id
-            self.config.widgets[widget._name] = widget.config  # pylint: disable=protected-access
+            self.config.widgets[widget.object_name] = widget.config
         return widget
 
     def move_widget(self, widget: QWidget, new_row: int, new_col: int):
@@ -364,7 +359,7 @@ class BECDock(BECWidget, Dock):
         """
         Remove the dock from the parent dock area.
         """
-        self.parent_dock_area.delete(self._name)
+        self.parent_dock_area.delete(self.object_name)
 
     def delete(self, widget_name: str) -> None:
         """
@@ -374,7 +369,7 @@ class BECDock(BECWidget, Dock):
             widget_name(str): Delete the widget with the given name.
         """
         # pylint: disable=protected-access
-        widgets = [widget for widget in self.widgets if widget._name == widget_name]
+        widgets = [widget for widget in self.widgets if widget.object_name == widget_name]
         if len(widgets) == 0:
             logger.warning(
                 f"Widget with name {widget_name} not found in dock {self.name()}. "
@@ -390,7 +385,7 @@ class BECDock(BECWidget, Dock):
         else:
             widget = widgets[0]
         self.layout.removeWidget(widget)
-        self.config.widgets.pop(widget._name, None)
+        self.config.widgets.pop(widget.object_name, None)
         if widget in self.widgets:
             self.widgets.remove(widget)
         widget.close()
@@ -400,7 +395,7 @@ class BECDock(BECWidget, Dock):
         Remove all widgets from the dock.
         """
         for widget in self.widgets:
-            self.delete(widget._name)  # pylint: disable=protected-access
+            self.delete(widget.object_name)
 
     def cleanup(self):
         """
@@ -421,6 +416,7 @@ class BECDock(BECWidget, Dock):
         self.delete_all()
         self.widgets.clear()
         super().cleanup()
+        self.deleteLater()
 
     def close(self):
         """

bec_widgets/widgets/containers/dock/dock_area.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 from typing import Literal, Optional
 from weakref import WeakValueDictionary
 
-from bec_lib.endpoints import MessageEndpoints
 from bec_lib.logger import bec_logger
 from pydantic import Field
 from pyqtgraph.dockarea.DockArea import DockArea
@@ -15,13 +14,16 @@ from bec_widgets.cli.rpc.rpc_register import RPCRegister
 from bec_widgets.utils import ConnectionConfig, WidgetContainerUtils
 from bec_widgets.utils.bec_widget import BECWidget
 from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.name_utils import pascal_to_snake
 from bec_widgets.utils.toolbar import (
     ExpandableMenuAction,
     MaterialIconAction,
     ModularToolBar,
     SeparatorAction,
 )
+from bec_widgets.utils.widget_io import WidgetHierarchy
 from bec_widgets.widgets.containers.dock.dock import BECDock, DockConfig
+from bec_widgets.widgets.containers.main_window.main_window import BECMainWindow
 from bec_widgets.widgets.control.device_control.positioner_box import PositionerBox
 from bec_widgets.widgets.control.scan_control.scan_control import ScanControl
 from bec_widgets.widgets.editors.vscode.vscode import VSCodeEditor
@@ -47,6 +49,10 @@ class DockAreaConfig(ConnectionConfig):
 
 
 class BECDockArea(BECWidget, QWidget):
+    """
+    Container for other widgets. Widgets can be added to the dock area and arranged in a grid layout.
+    """
+
     PLUGIN = True
     USER_ACCESS = [
         "_rpc_id",
@@ -62,7 +68,6 @@ class BECDockArea(BECWidget, QWidget):
         "remove",
         "detach_dock",
         "attach_all",
-        "selected_device",
         "save_state",
         "restore_state",
     ]
@@ -73,7 +78,7 @@ class BECDockArea(BECWidget, QWidget):
         config: DockAreaConfig | None = None,
         client=None,
         gui_id: str = None,
-        name: str | None = None,
+        object_name: str = None,
         **kwargs,
     ) -> None:
         if config is None:
@@ -82,17 +87,25 @@ class BECDockArea(BECWidget, QWidget):
             if isinstance(config, dict):
                 config = DockAreaConfig(**config)
             self.config = config
-        super().__init__(client=client, config=config, gui_id=gui_id, name=name, **kwargs)
-        QWidget.__init__(self, parent=parent)
-        self._parent = parent
+        super().__init__(
+            parent=parent,
+            object_name=object_name,
+            client=client,
+            gui_id=gui_id,
+            config=config,
+            **kwargs,
+        )
+        self._parent = parent  # TODO probably not needed
         self.layout = QVBoxLayout(self)
         self.layout.setSpacing(5)
         self.layout.setContentsMargins(0, 0, 0, 0)
 
         self._instructions_visible = True
 
-        self.dock_area = DockArea()
+        self.dark_mode_button = DarkModeButton(parent=self, toolbar=True)
+        self.dock_area = DockArea(parent=self)
         self.toolbar = ModularToolBar(
+            parent=self,
             actions={
                 "menu_plots": ExpandableMenuAction(
                     label="Add Plot ",
@@ -150,8 +163,11 @@ class BECDockArea(BECWidget, QWidget):
                             tooltip="Add Circular ProgressBar",
                             filled=True,
                         ),
+                        # FIXME temporarily disabled  -> issue #644
                         "log_panel": MaterialIconAction(
-                            icon_name=LogPanel.ICON_NAME, tooltip="Add LogPanel", filled=True
+                            icon_name=LogPanel.ICON_NAME,
+                            tooltip="Add LogPanel - Disabled",
+                            filled=True,
                         ),
                     },
                 ),
@@ -169,10 +185,10 @@ class BECDockArea(BECWidget, QWidget):
 
         self.layout.addWidget(self.toolbar)
         self.layout.addWidget(self.dock_area)
-        self.spacer = QWidget()
+        self.spacer = QWidget(parent=self)
         self.spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
         self.toolbar.addWidget(self.spacer)
-        self.toolbar.addWidget(DarkModeButton(toolbar=True))
+        self.toolbar.addWidget(self.dark_mode_button)
         self._hook_toolbar()
 
     def minimumSizeHint(self):
@@ -217,9 +233,11 @@ class BECDockArea(BECWidget, QWidget):
         self.toolbar.widgets["menu_utils"].widgets["progress_bar"].triggered.connect(
             lambda: self._create_widget_from_toolbar(widget_name="RingProgressBar")
         )
-        self.toolbar.widgets["menu_utils"].widgets["log_panel"].triggered.connect(
-            lambda: self._create_widget_from_toolbar(widget_name="LogPanel")
-        )
+        # FIXME temporarily disabled -> issue #644
+        self.toolbar.widgets["menu_utils"].widgets["log_panel"].setEnabled(False)
+        # self.toolbar.widgets["menu_utils"].widgets["log_panel"].triggered.connect(
+        #     lambda: self._create_widget_from_toolbar(widget_name="LogPanel")
+        # )
 
         # Icons
         self.toolbar.widgets["attach_all"].action.triggered.connect(self.attach_all)
@@ -230,7 +248,8 @@ class BECDockArea(BECWidget, QWidget):
     def _create_widget_from_toolbar(self, widget_name: str) -> None:
         # Run with RPC broadcast to namespace of all widgets
         with RPCRegister.delayed_broadcast():
-            dock_name = WidgetContainerUtils.generate_unique_name(widget_name, self.panels.keys())
+            name = pascal_to_snake(widget_name)
+            dock_name = WidgetContainerUtils.generate_unique_name(name, self.panels.keys())
             self.new(name=dock_name, widget=widget_name)
 
     def paintEvent(self, event: QPaintEvent):  # TODO decide if we want any default instructions
@@ -243,17 +262,6 @@ class BECDockArea(BECWidget, QWidget):
                 "Add docks using 'new' method from CLI\n or \n Add widget docks using the toolbar",
             )
 
-    @property
-    def selected_device(self) -> str:
-        gui_id = QApplication.instance().gui_id
-        auto_update_config = self.client.connector.get(
-            MessageEndpoints.gui_auto_update_config(gui_id)
-        )
-        try:
-            return auto_update_config.selected_device
-        except AttributeError:
-            return None
-
     @property
     def panels(self) -> dict[str, BECDock]:
         """
@@ -305,6 +313,8 @@ class BECDockArea(BECWidget, QWidget):
         """
         if state is None:
             state = self.config.docks_state
+        if state is None:
+            return
         self.dock_area.restoreState(state, missing=missing, extra=extra)
 
     @SafeSlot()
@@ -352,17 +362,27 @@ class BECDockArea(BECWidget, QWidget):
         Returns:
             BECDock: The created dock.
         """
-        dock_names = [dock._name for dock in self.panel_list]  # pylint: disable=protected-access
+        dock_names = [
+            dock.object_name for dock in self.panel_list
+        ]  # pylint: disable=protected-access
         if name is not None:  # Name is provided
             if name in dock_names:
                 raise ValueError(
                     f"Name {name} must be unique for docks, but already exists in DockArea "
-                    f"with name: {self._name} and id {self.gui_id}."
+                    f"with name: {self.object_name} and id {self.gui_id}."
                 )
+            WidgetContainerUtils.raise_for_invalid_name(name, container=self)
+
         else:  # Name is not provided
             name = WidgetContainerUtils.generate_unique_name(name="dock", list_of_names=dock_names)
 
-        dock = BECDock(name=name, parent_dock_area=self, parent_id=self.gui_id, closable=closable)
+        dock = BECDock(
+            parent=self,
+            name=name,  # this is dock name pyqtgraph property, this is displayed on label
+            object_name=name,  # this is a real qt object name passed to BECConnector
+            parent_dock_area=self,
+            closable=closable,
+        )
         dock.config.position = position
         self.config.docks[dock.name()] = dock.config
         # The dock.name is equal to the name passed to BECDock
@@ -430,10 +450,8 @@ class BECDockArea(BECWidget, QWidget):
         Cleanup the dock area.
         """
         self.delete_all()
-        self.toolbar.close()
-        self.toolbar.deleteLater()
-        self.dock_area.close()
-        self.dock_area.deleteLater()
+        self.dark_mode_button.close()
+        self.dark_mode_button.deleteLater()
         super().cleanup()
 
     def show(self):
@@ -482,7 +500,18 @@ class BECDockArea(BECWidget, QWidget):
         # self._broadcast_update()
 
     def remove(self) -> None:
-        """Remove the dock area."""
+        """
+        Remove the dock area. If the dock area is embedded in a BECMainWindow and
+        is set as the central widget, the main window will be closed.
+        """
+        parent = self.parent()
+        if isinstance(parent, BECMainWindow):
+            central_widget = parent.centralWidget()
+            if central_widget is self:
+                # Closing the parent will also close the dock area
+                parent.close()
+                return
+
         self.close()
 
 
@@ -495,11 +524,13 @@ if __name__ == "__main__":  # pragma: no cover
     app = QApplication([])
     set_theme("auto")
     dock_area = BECDockArea()
-    dock_1 = dock_area.new(name="dock_0", widget="Waveform")
+    dock_1 = dock_area.new(name="dock_0", widget="DarkModeButton")
+    dock_1.new(widget="DarkModeButton")
     # dock_1 = dock_area.new(name="dock_0", widget="Waveform")
-    dock_area.new(widget="Waveform")
+    dock_area.new(widget="DarkModeButton")
     dock_area.show()
     dock_area.setGeometry(100, 100, 800, 600)
     app.topLevelWidgets()
+    WidgetHierarchy.print_becconnector_hierarchy_from_app()
     app.exec_()
     sys.exit(app.exec_())

bec_widgets/widgets/containers/layout_manager/layout_manager.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import math
 import sys
 from typing import Dict, Literal, Optional, Set, Tuple, Union
@@ -34,7 +36,6 @@ class LayoutManagerWidget(QWidget):
 
     def __init__(self, parent=None, auto_reindex=True):
         super().__init__(parent)
-        self.setObjectName("LayoutManagerWidget")
         self.layout = QGridLayout(self)
         self.auto_reindex = auto_reindex
 
@@ -52,7 +53,7 @@ class LayoutManagerWidget(QWidget):
         self,
         widget: QWidget | str,
         row: int | None = None,
-        col: Optional[int] = None,
+        col: int | None = None,
         rowspan: int = 1,
         colspan: int = 1,
         shift_existing: bool = True,
@@ -137,6 +138,39 @@ class LayoutManagerWidget(QWidget):
         ref_row, ref_col, ref_rowspan, ref_colspan = self.widget_positions[reference_widget]
 
         # Determine new widget position based on the specified relative position
+
+        # If adding to the left or right with shifting, shift the entire column
+        if (
+            position in ("left", "right")
+            and shift_existing
+            and shift_direction in ("left", "right")
+        ):
+            column = ref_col
+            # Collect all rows in this column and sort for safe shifting
+            rows = sorted(
+                {row for (row, col) in self.position_widgets.keys() if col == column},
+                reverse=(shift_direction == "right"),
+            )
+            # Shift each widget in the column
+            for r in rows:
+                self.shift_widgets(direction=shift_direction, start_row=r, start_col=column)
+            # Update reference widget's position after the column shift
+            ref_row, ref_col, ref_rowspan, ref_colspan = self.widget_positions[reference_widget]
+            new_row = ref_row
+            # Compute insertion column based on relative position
+            if position == "left":
+                new_col = ref_col - ref_colspan
+            else:
+                new_col = ref_col + ref_colspan
+            # Add the new widget without triggering another shift
+            return self.add_widget(
+                widget=widget,
+                row=new_row,
+                col=new_col,
+                rowspan=rowspan,
+                colspan=colspan,
+                shift_existing=False,
+            )
         if position == "left":
             new_row = ref_row
             new_col = ref_col - 1

bec_widgets/widgets/containers/main_window/addons/web_links.py

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

@@ -1,74 +1,189 @@
-from bec_lib.logger import bec_logger
-from qtpy.QtWidgets import QApplication, QMainWindow
+import os
 
-from bec_widgets.cli.rpc.rpc_register import RPCRegister
+from qtpy.QtCore import QSize
+from qtpy.QtGui import QAction, QActionGroup, QIcon
+from qtpy.QtWidgets import QApplication, QMainWindow, QStyle
+
+import bec_widgets
+from bec_widgets.utils import UILoader
 from bec_widgets.utils.bec_widget import BECWidget
+from bec_widgets.utils.colors import apply_theme
 from bec_widgets.utils.container_utils import WidgetContainerUtils
-from bec_widgets.widgets.containers.dock.dock_area import BECDockArea
+from bec_widgets.utils.error_popups import SafeSlot
+from bec_widgets.utils.widget_io import WidgetHierarchy
+from bec_widgets.widgets.containers.main_window.addons.web_links import BECWebLinksMixin
 
-logger = bec_logger.logger
+MODULE_PATH = os.path.dirname(bec_widgets.__file__)
 
 
 class BECMainWindow(BECWidget, QMainWindow):
-    def __init__(self, gui_id: str = None, *args, **kwargs):
-        BECWidget.__init__(self, gui_id=gui_id, **kwargs)
-        QMainWindow.__init__(self, *args, **kwargs)
+    RPC = False
+    PLUGIN = False
 
-    def _dump(self):
-        """Return a dictionary with informations about the application state, for use in tests"""
-        # TODO: ModularToolBar and something else leak top-level widgets (3 or 4 QMenu + 2 QWidget);
-        # so, a filtering based on title is applied here, but the solution is to not have those widgets
-        # as top-level (so for now, a window with no title does not appear in _dump() result)
+    def __init__(
+        self,
+        parent=None,
+        gui_id: str = None,
+        client=None,
+        window_title: str = "BEC",
+        *args,
+        **kwargs,
+    ):
+        super().__init__(parent=parent, gui_id=gui_id, **kwargs)
 
-        # NOTE: the main window itself is excluded, since we want to dump dock areas
-        info = {
-            tlw.gui_id: {
-                "title": tlw.windowTitle(),
-                "visible": tlw.isVisible(),
-                "class": str(type(tlw)),
-            }
-            for tlw in QApplication.instance().topLevelWidgets()
-            if tlw is not self and tlw.windowTitle()
-        }
-        # Add the main window dock area
-        info[self.centralWidget().gui_id] = {
-            "title": self.windowTitle(),
-            "visible": self.isVisible(),
-            "class": str(type(self.centralWidget())),
-        }
-        return info
+        self.app = QApplication.instance()
+        self.setWindowTitle(window_title)
+        self._init_ui()
+        self._connect_to_theme_change()
 
-    def new_dock_area(
-        self, name: str | None = None, geometry: tuple[int, int, int, int] | None = None
-    ) -> BECDockArea:
-        """Create a new dock area.
+    def _init_ui(self):
 
-        Args:
-            name(str): The name of the dock area.
-            geometry(tuple): The geometry parameters to be passed to the dock area.
-        Returns:
-            BECDockArea: The newly created dock area.
+        # Set the icon
+        self._init_bec_icon()
+
+        # Set Menu and Status bar
+        self._setup_menu_bar()
+
+        # BEC Specific UI
+        self.display_app_id()
+
+    def _init_bec_icon(self):
+        icon = self.app.windowIcon()
+        if icon.isNull():
+            print("No icon is set, setting default icon")
+            icon = QIcon()
+            icon.addFile(
+                os.path.join(MODULE_PATH, "assets", "app_icons", "bec_widgets_icon.png"),
+                size=QSize(48, 48),
+            )
+            self.app.setWindowIcon(icon)
+        else:
+            print("An icon is set")
+
+    def load_ui(self, ui_file):
+        loader = UILoader(self)
+        self.ui = loader.loader(ui_file)
+        self.setCentralWidget(self.ui)
+
+    def display_app_id(self):
         """
-        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}."
-                    )
-            else:
-                name = "dock_area"
-                name = WidgetContainerUtils.generate_unique_name(name, existing_dock_areas)
-            dock_area = BECDockArea(name=name)
-            dock_area.resize(dock_area.minimumSizeHint())
-            # TODO Should we simply use the specified name as title here?
-            dock_area.window().setWindowTitle(f"BEC - {name}")
-            logger.info(f"Created new dock area: {name}")
-            logger.info(f"Existing dock areas: {geometry}")
-            if geometry is not None:
-                dock_area.setGeometry(*geometry)
-            dock_area.show()
-            return dock_area
+        Display the app ID in the status bar.
+        """
+        if self.bec_dispatcher.cli_server is None:
+            status_message = "Not connected"
+        else:
+            # Get the server ID from the dispatcher
+            server_id = self.bec_dispatcher.cli_server.gui_id
+            status_message = f"App ID: {server_id}"
+        self.statusBar().showMessage(status_message)
+
+    def _fetch_theme(self) -> str:
+        return self.app.theme.theme
+
+    def _get_launcher_from_qapp(self):
+        """
+        Get the launcher from the QApplication instance.
+        """
+        from bec_widgets.applications.launch_window import LaunchWindow
+
+        qapp = QApplication.instance()
+        widgets = qapp.topLevelWidgets()
+        widgets = [w for w in widgets if isinstance(w, LaunchWindow)]
+        if widgets:
+            return widgets[0]
+        return None
+
+    def _show_launcher(self):
+        """
+        Show the launcher if it exists.
+        """
+        launcher = self._get_launcher_from_qapp()
+        if launcher:
+            launcher.show()
+            launcher.activateWindow()
+            launcher.raise_()
+
+    def _setup_menu_bar(self):
+        """
+        Setup the menu bar for the main window.
+        """
+        menu_bar = self.menuBar()
+
+        ##########################################
+        # Launch menu
+        launch_menu = menu_bar.addMenu("New")
+
+        open_launcher_action = QAction("Open Launcher", self)
+        launch_menu.addAction(open_launcher_action)
+        open_launcher_action.triggered.connect(self._show_launcher)
+
+        ########################################
+        # Theme menu
+        theme_menu = menu_bar.addMenu("Theme")
+
+        theme_group = QActionGroup(self)
+        light_theme_action = QAction("Light Theme", self, checkable=True)
+        dark_theme_action = QAction("Dark Theme", self, checkable=True)
+        theme_group.addAction(light_theme_action)
+        theme_group.addAction(dark_theme_action)
+        theme_group.setExclusive(True)
+
+        theme_menu.addAction(light_theme_action)
+        theme_menu.addAction(dark_theme_action)
+
+        # Connect theme actions
+        light_theme_action.triggered.connect(lambda: self.change_theme("light"))
+        dark_theme_action.triggered.connect(lambda: self.change_theme("dark"))
+
+        # Set the default theme
+        theme = self.app.theme.theme
+        if theme == "light":
+            light_theme_action.setChecked(True)
+        elif theme == "dark":
+            dark_theme_action.setChecked(True)
+
+        ########################################
+        # Help menu
+        help_menu = menu_bar.addMenu("Help")
+
+        help_icon = QApplication.style().standardIcon(QStyle.SP_MessageBoxQuestion)
+        bug_icon = QApplication.style().standardIcon(QStyle.SP_MessageBoxInformation)
+
+        bec_docs = QAction("BEC Docs", self)
+        bec_docs.setIcon(help_icon)
+        widgets_docs = QAction("BEC Widgets Docs", self)
+        widgets_docs.setIcon(help_icon)
+        bug_report = QAction("Bug Report", self)
+        bug_report.setIcon(bug_icon)
+
+        bec_docs.triggered.connect(BECWebLinksMixin.open_bec_docs)
+        widgets_docs.triggered.connect(BECWebLinksMixin.open_bec_widgets_docs)
+        bug_report.triggered.connect(BECWebLinksMixin.open_bec_bug_report)
+
+        help_menu.addAction(bec_docs)
+        help_menu.addAction(widgets_docs)
+        help_menu.addAction(bug_report)
+
+    @SafeSlot(str)
+    def change_theme(self, theme: str):
+        apply_theme(theme)
 
     def cleanup(self):
-        super().close()
+        central_widget = self.centralWidget()
+        central_widget.close()
+        central_widget.deleteLater()
+        if not isinstance(central_widget, BECWidget):
+            # if the central widget is not a BECWidget, we need to call the cleanup method
+            # of all widgets whose parent is the current BECMainWindow
+            children = self.findChildren(BECWidget)
+            for child in children:
+                ancestor = WidgetHierarchy._get_becwidget_ancestor(child)
+                if ancestor is self:
+                    child.cleanup()
+                    child.close()
+                    child.deleteLater()
+        super().cleanup()
+
+
+class UILaunchWindow(BECMainWindow):
+    RPC = True

bec_widgets/widgets/control/buttons/button_abort/button_abort.py

@@ -11,6 +11,7 @@ class AbortButton(BECWidget, QWidget):
 
     PLUGIN = True
     ICON_NAME = "cancel"
+    RPC = True
 
     def __init__(
         self,
@@ -22,9 +23,7 @@ class AbortButton(BECWidget, QWidget):
         scan_id=None,
         **kwargs,
     ):
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
-        QWidget.__init__(self, parent=parent)
-
+        super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
         self.get_bec_shortcuts()
 
         self.layout = QHBoxLayout(self)

bec_widgets/widgets/control/buttons/button_reset/button_reset.py

@@ -11,11 +11,10 @@ class ResetButton(BECWidget, QWidget):
 
     PLUGIN = True
     ICON_NAME = "restart_alt"
+    RPC = True
 
     def __init__(self, parent=None, client=None, config=None, gui_id=None, toolbar=False, **kwargs):
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
-        QWidget.__init__(self, parent=parent)
-
+        super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
         self.get_bec_shortcuts()
 
         self.layout = QHBoxLayout(self)

bec_widgets/widgets/control/buttons/button_resume/button_resume.py

@@ -11,10 +11,10 @@ class ResumeButton(BECWidget, QWidget):
 
     PLUGIN = True
     ICON_NAME = "resume"
+    RPC = True
 
     def __init__(self, parent=None, client=None, config=None, gui_id=None, toolbar=False, **kwargs):
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
-        QWidget.__init__(self, parent=parent)
+        super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
 
         self.get_bec_shortcuts()
 

bec_widgets/widgets/control/buttons/stop_button/stop_button.py

@@ -11,10 +11,10 @@ class StopButton(BECWidget, QWidget):
 
     PLUGIN = True
     ICON_NAME = "dangerous"
+    RPC = True
 
     def __init__(self, parent=None, client=None, config=None, gui_id=None, toolbar=False, **kwargs):
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
-        QWidget.__init__(self, parent=parent)
+        super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
 
         self.get_bec_shortcuts()
 
@@ -54,9 +54,20 @@ class StopButton(BECWidget, QWidget):
 if __name__ == "__main__":  # pragma: no cover
     import sys
 
-    from qtpy.QtWidgets import QApplication
+    from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
 
-    app = QApplication(sys.argv)
-    w = StopButton()
-    w.show()
+    from bec_widgets.widgets.control.buttons.stop_button.stop_button import StopButton
+
+    class MyGui(QWidget):
+        def __init__(self):
+            super().__init__()
+            self.setLayout(QVBoxLayout())
+            # Create and add the StopButton to the layout
+            self.stop_button = StopButton()
+            self.layout().addWidget(self.stop_button)
+
+    # Example of how this custom GUI might be used:
+    app = QApplication([])
+    my_gui = MyGui()
+    my_gui.show()
     sys.exit(app.exec_())

bec_widgets/widgets/control/device_control/position_indicator/position_indicator.py

@@ -8,13 +8,26 @@ from bec_widgets.utils.colors import get_accent_colors, get_theme_palette
 
 
 class PositionIndicator(BECWidget, QWidget):
-    USER_ACCESS = ["set_value", "set_range", "vertical", "indicator_width", "rounded_corners"]
+    """
+    Display a position within a defined range, e.g. motor limits.
+    """
+
+    USER_ACCESS = [
+        "set_value",
+        "set_range",
+        "vertical",
+        "vertical.setter",
+        "indicator_width",
+        "indicator_width.setter",
+        "rounded_corners",
+        "rounded_corners.setter",
+    ]
     PLUGIN = True
     ICON_NAME = "horizontal_distribute"
 
     def __init__(self, parent=None, client=None, config=None, gui_id=None, **kwargs):
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
-        QWidget.__init__(self, parent=parent)
+        super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
+
         self.position = 50
         self.min_value = 0
         self.max_value = 100
@@ -205,6 +218,12 @@ class PositionIndicator(BECWidget, QWidget):
     @Slot(int)
     @Slot(float)
     def set_value(self, position: float):
+        """
+        Set the position of the indicator
+
+        Args:
+            position: The new position of the indicator
+        """
         self.position = position
         self.update()
 

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

@@ -40,6 +40,7 @@ class DeviceUpdateUIComponents(TypedDict):
     stop: QPushButton
     tweak_increase: QPushButton
     tweak_decrease: QPushButton
+    units: QLabel
 
 
 class PositionerBoxBase(BECWidget, CompactPopupWidget):
@@ -47,6 +48,7 @@ class PositionerBoxBase(BECWidget, CompactPopupWidget):
 
     current_path = ""
     ICON_NAME = "switch_right"
+    RPC = False
 
     def __init__(self, parent=None, **kwargs):
         """Initialize the PositionerBox widget.
@@ -55,8 +57,7 @@ class PositionerBoxBase(BECWidget, CompactPopupWidget):
             parent: The parent widget.
             device (Positioner): The device to control.
         """
-        super().__init__(**kwargs)
-        CompactPopupWidget.__init__(self, parent=parent, layout=QVBoxLayout)
+        super().__init__(parent=parent, layout=QVBoxLayout, **kwargs)
         self._dialog = None
         self.get_bec_shortcuts()
 
@@ -84,16 +85,33 @@ class PositionerBoxBase(BECWidget, CompactPopupWidget):
         limit_update: Callable[[tuple[float, float]], None],
     ):
         """Init the device view and readback"""
-        if self._check_device_is_valid(device):
-            data = self.dev[device].read()
-            self._on_device_readback(
-                device,
-                self._device_ui_components(device),
-                {"signals": data},
-                {},
-                position_emit,
-                limit_update,
-            )
+        if not self._check_device_is_valid(device):
+            return
+
+        data = self.dev[device].read()
+        self._on_device_readback(
+            device,
+            self._device_ui_components(device),
+            {"signals": data},
+            {},
+            position_emit,
+            limit_update,
+        )
+
+        ui = self._device_ui_components(device)
+        if not ui.get("units"):
+            return
+
+        try:
+            egu = f"[{self.dev[device].egu()}]"
+        except Exception:
+            egu = ""
+
+        if egu:
+            ui["units"].setVisible(True)
+            ui["units"].setText(egu)
+        else:
+            ui["units"].setVisible(False)
 
     def _stop_device(self, device: str):
         """Stop call"""

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

@@ -31,6 +31,7 @@ class PositionerBox(PositionerBoxBase):
     dimensions = (234, 224)
 
     PLUGIN = True
+    RPC = True
 
     USER_ACCESS = ["set_positioner"]
     device_changed = Signal(str, str)
@@ -170,6 +171,7 @@ class PositionerBox(PositionerBoxBase):
             "stop": self.ui.stop,
             "tweak_increase": self.ui.tweak_right,
             "tweak_decrease": self.ui.tweak_left,
+            "units": self.ui.units,
         }
 
     @SafeSlot(dict, dict)

bec_widgets/widgets/control/device_control/positioner_box/positioner_box/positioner_box.ui

@@ -135,6 +135,29 @@
             </property>
            </widget>
           </item>
+          <item>
+           <spacer name="horizontalSpacer_2">
+            <property name="orientation">
+             <enum>Qt::Orientation::Horizontal</enum>
+            </property>
+            <property name="sizeHint" stdset="0">
+             <size>
+              <width>40</width>
+              <height>20</height>
+             </size>
+            </property>
+           </spacer>
+          </item>
+          <item>
+           <widget class="QLabel" name="units">
+            <property name="toolTip">
+             <string>Motor units</string>
+            </property>
+            <property name="text">
+             <string></string>
+            </property>
+           </widget>
+          </item>
           <item>
            <spacer name="horizontalSpacer">
             <property name="orientation">
@@ -203,16 +226,16 @@
   </layout>
  </widget>
  <customwidgets>
-  <customwidget>
-   <class>SpinnerWidget</class>
-   <extends>QWidget</extends>
-   <header>spinner_widget</header>
-  </customwidget>
   <customwidget>
    <class>PositionIndicator</class>
    <extends>QWidget</extends>
    <header>position_indicator</header>
   </customwidget>
+  <customwidget>
+   <class>SpinnerWidget</class>
+   <extends>QWidget</extends>
+   <header>spinner_widget</header>
+  </customwidget>
  </customwidgets>
  <resources/>
  <connections/>

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

@@ -1,4 +1,4 @@
-""" Module for a PositionerBox2D widget to control two positioner devices."""
+"""Module for a PositionerBox2D widget to control two positioner devices."""
 
 from __future__ import annotations
 
@@ -33,6 +33,7 @@ class PositionerBox2D(PositionerBoxBase):
     ui_file = "positioner_box_2d.ui"
 
     PLUGIN = True
+    RPC = True
     USER_ACCESS = ["set_positioner_hor", "set_positioner_ver"]
 
     device_changed_hor = Signal(str, str)
@@ -312,6 +313,7 @@ class PositionerBox2D(PositionerBoxBase):
                 "stop": self.ui.stop_button,
                 "tweak_increase": self.ui.tweak_increase_hor,
                 "tweak_decrease": self.ui.tweak_decrease_hor,
+                "units": self.ui.units_hor,
             }
         elif device == "vertical":
             return {
@@ -324,6 +326,7 @@ class PositionerBox2D(PositionerBoxBase):
                 "stop": self.ui.stop_button,
                 "tweak_increase": self.ui.tweak_increase_ver,
                 "tweak_decrease": self.ui.tweak_decrease_ver,
+                "units": self.ui.units_ver,
             }
         else:
             raise ValueError(f"Device {device} is not represented by this UI")

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

@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>326</width>
-    <height>323</height>
+    <width>402</width>
+    <height>394</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -23,7 +23,7 @@
          <property name="title">
           <string>No positioner selected</string>
          </property>
-         <layout class="QGridLayout" name="gridLayout_6" rowstretch="0,0,0,0,0,0">
+         <layout class="QGridLayout" name="gridLayout_6" rowstretch="0,0,0,0,0,0,0">
           <property name="topMargin">
            <number>0</number>
           </property>
@@ -40,15 +40,38 @@
              </widget>
             </item>
             <item>
-             <widget class="QLabel" name="readback_ver">
-              <property name="text">
-               <string>Position</string>
+             <spacer name="horizontalSpacer_18">
+              <property name="orientation">
+               <enum>Qt::Orientation::Horizontal</enum>
               </property>
-              <property name="alignment">
-               <set>Qt::AlignmentFlag::AlignCenter</set>
+              <property name="sizeHint" stdset="0">
+               <size>
+                <width>40</width>
+                <height>20</height>
+               </size>
+              </property>
+             </spacer>
+            </item>
+            <item>
+             <widget class="QLabel" name="units_ver">
+              <property name="text">
+               <string/>
               </property>
              </widget>
             </item>
+            <item>
+             <spacer name="horizontalSpacer_19">
+              <property name="orientation">
+               <enum>Qt::Orientation::Horizontal</enum>
+              </property>
+              <property name="sizeHint" stdset="0">
+               <size>
+                <width>40</width>
+                <height>20</height>
+               </size>
+              </property>
+             </spacer>
+            </item>
             <item>
              <widget class="SpinnerWidget" name="spinner_widget_ver">
               <property name="minimumSize">
@@ -67,20 +90,7 @@
             </item>
            </layout>
           </item>
-          <item row="2" column="0">
-           <widget class="QLineEdit" name="setpoint_ver">
-            <property name="enabled">
-             <bool>false</bool>
-            </property>
-            <property name="focusPolicy">
-             <enum>Qt::FocusPolicy::StrongFocus</enum>
-            </property>
-            <property name="alignment">
-             <set>Qt::AlignmentFlag::AlignCenter</set>
-            </property>
-           </widget>
-          </item>
-          <item row="5" column="0">
+          <item row="6" column="0">
            <layout class="QHBoxLayout" name="horizontalLayout_6">
             <item>
              <widget class="QDoubleSpinBox" name="step_size_ver">
@@ -94,6 +104,29 @@
             </item>
            </layout>
           </item>
+          <item row="3" column="0">
+           <widget class="QLineEdit" name="setpoint_ver">
+            <property name="enabled">
+             <bool>false</bool>
+            </property>
+            <property name="focusPolicy">
+             <enum>Qt::FocusPolicy::StrongFocus</enum>
+            </property>
+            <property name="alignment">
+             <set>Qt::AlignmentFlag::AlignCenter</set>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="0">
+           <widget class="QLabel" name="readback_ver">
+            <property name="text">
+             <string>Position</string>
+            </property>
+            <property name="alignment">
+             <set>Qt::AlignmentFlag::AlignCenter</set>
+            </property>
+           </widget>
+          </item>
          </layout>
         </widget>
        </item>
@@ -132,15 +165,38 @@
              </widget>
             </item>
             <item>
-             <widget class="QLabel" name="readback_hor">
-              <property name="text">
-               <string>Position</string>
+             <spacer name="horizontalSpacer_9">
+              <property name="orientation">
+               <enum>Qt::Orientation::Horizontal</enum>
               </property>
-              <property name="alignment">
-               <set>Qt::AlignmentFlag::AlignCenter</set>
+              <property name="sizeHint" stdset="0">
+               <size>
+                <width>40</width>
+                <height>20</height>
+               </size>
+              </property>
+             </spacer>
+            </item>
+            <item>
+             <widget class="QLabel" name="units_hor">
+              <property name="text">
+               <string/>
               </property>
              </widget>
             </item>
+            <item>
+             <spacer name="horizontalSpacer_13">
+              <property name="orientation">
+               <enum>Qt::Orientation::Horizontal</enum>
+              </property>
+              <property name="sizeHint" stdset="0">
+               <size>
+                <width>40</width>
+                <height>20</height>
+               </size>
+              </property>
+             </spacer>
+            </item>
             <item>
              <widget class="SpinnerWidget" name="spinner_widget_hor">
               <property name="minimumSize">
@@ -173,6 +229,16 @@
             </item>
            </layout>
           </item>
+          <item row="2" column="0">
+           <widget class="QLabel" name="readback_hor">
+            <property name="text">
+             <string>Position</string>
+            </property>
+            <property name="alignment">
+             <set>Qt::AlignmentFlag::AlignCenter</set>
+            </property>
+           </widget>
+          </item>
          </layout>
         </widget>
        </item>
@@ -525,16 +591,16 @@
   </layout>
  </widget>
  <customwidgets>
-  <customwidget>
-   <class>StopButton</class>
-   <extends>QWidget</extends>
-   <header>stop_button</header>
-  </customwidget>
   <customwidget>
    <class>PositionIndicator</class>
    <extends>QWidget</extends>
    <header>position_indicator</header>
   </customwidget>
+  <customwidget>
+   <class>StopButton</class>
+   <extends>QWidget</extends>
+   <header>stop_button</header>
+  </customwidget>
   <customwidget>
    <class>SpinnerWidget</class>
    <extends>QWidget</extends>

bec_widgets/widgets/control/device_control/positioner_box/positioner_control_line/positioner_control_line.ui

@@ -116,6 +116,13 @@
           </property>
          </widget>
         </item>
+        <item>
+         <widget class="QLabel" name="units">
+          <property name="text">
+           <string>TextLabel</string>
+          </property>
+         </widget>
+        </item>
        </layout>
       </item>
       <item>
@@ -218,16 +225,16 @@
   </layout>
  </widget>
  <customwidgets>
-  <customwidget>
-   <class>SpinnerWidget</class>
-   <extends>QWidget</extends>
-   <header>spinner_widget</header>
-  </customwidget>
   <customwidget>
    <class>PositionIndicator</class>
    <extends>QWidget</extends>
    <header>position_indicator</header>
   </customwidget>
+  <customwidget>
+   <class>SpinnerWidget</class>
+   <extends>QWidget</extends>
+   <header>spinner_widget</header>
+  </customwidget>
  </customwidgets>
  <resources/>
  <connections/>

bec_widgets/widgets/control/device_control/positioner_group/positioner_group.py

@@ -1,4 +1,4 @@
-""" Module for a PositionerGroup widget to control a positioner device."""
+"""Module for a PositionerGroup widget to control a positioner device."""
 
 from __future__ import annotations
 
@@ -69,8 +69,7 @@ class PositionerGroup(BECWidget, QWidget):
         Args:
             parent: The parent widget.
         """
-        super().__init__(**kwargs)
-        QWidget.__init__(self, parent)
+        super().__init__(parent=parent, **kwargs)
 
         self.get_bec_shortcuts()
 

bec_widgets/widgets/control/device_input/base_classes/device_input_base.py

@@ -82,7 +82,7 @@ class DeviceInputBase(BECWidget):
         ReadoutPriority.ON_REQUEST: "readout_on_request",
     }
 
-    def __init__(self, client=None, config=None, gui_id: str | None = None, **kwargs):
+    def __init__(self, parent=None, client=None, config=None, gui_id: str | None = None, **kwargs):
 
         if config is None:
             config = DeviceInputConfig(widget_class=self.__class__.__name__)
@@ -90,7 +90,9 @@ class DeviceInputBase(BECWidget):
             if isinstance(config, dict):
                 config = DeviceInputConfig(**config)
             self.config = config
-        super().__init__(client=client, config=config, gui_id=gui_id, theme_update=True, **kwargs)
+        super().__init__(
+            parent=parent, client=client, config=config, gui_id=gui_id, theme_update=True, **kwargs
+        )
         self.get_bec_shortcuts()
         self._device_filter = []
         self._readout_filter = []
@@ -395,7 +397,7 @@ class DeviceInputBase(BECWidget):
             object: Device object, can be device of type Device, Positioner, Signal or ComputedSignal.
         """
         self.validate_device(device)
-        dev = getattr(self.dev, device.lower(), None)
+        dev = getattr(self.dev, device, None)
         if dev is None:
             raise ValueError(
                 f"Device {device} is not found in the device manager {self.dev} as enabled device."

bec_widgets/widgets/control/device_input/base_classes/device_signal_input_base.py

@@ -29,20 +29,23 @@ class DeviceSignalInputBase(BECWidget):
     signal object based on the current text of the widget.
     """
 
+    RPC = False
     _filter_handler = {
         Kind.hinted: "include_hinted_signals",
         Kind.normal: "include_normal_signals",
         Kind.config: "include_config_signals",
     }
 
-    def __init__(self, client=None, config=None, gui_id: str = None, **kwargs):
-        if config is None:
-            config = DeviceSignalInputBaseConfig(widget_class=self.__class__.__name__)
-        else:
-            if isinstance(config, dict):
-                config = DeviceSignalInputBaseConfig(**config)
-            self.config = config
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
+    def __init__(
+        self,
+        client=None,
+        config: DeviceSignalInputBaseConfig | dict | None = None,
+        gui_id: str = None,
+        **kwargs,
+    ):
+
+        self.config = self._process_config_input(config)
+        super().__init__(client=client, config=self.config, gui_id=gui_id, **kwargs)
 
         self._device = None
         self.get_bec_shortcuts()
@@ -76,7 +79,7 @@ class DeviceSignalInputBase(BECWidget):
     @Slot(str)
     def set_device(self, device: str | None):
         """
-        Set the device. If device is not valid, device will be set to None which happpens
+        Set the device. If device is not valid, device will be set to None which happens
 
         Args:
             device(str): device name.
@@ -101,10 +104,7 @@ class DeviceSignalInputBase(BECWidget):
         """
         self.config.signal_filter = self.signal_filter
         # pylint: disable=protected-access
-        self._hinted_signals = []
-        self._normal_signals = []
-        self._config_signals = []
-        if self.validate_device(self._device) is False:
+        if not self.validate_device(self._device):
             self._device = None
             self.config.device = self._device
             return
@@ -112,30 +112,25 @@ class DeviceSignalInputBase(BECWidget):
         # See above convention for Signals and ComputedSignals
         if isinstance(device, Signal):
             self._signals = [self._device]
-            FilterIO.set_selection(widget=self, selection=[self._device])
+            self._hinted_signals = [self._device]
+            self._normal_signals = []
+            self._config_signals = []
+            FilterIO.set_selection(widget=self, selection=self._signals)
             return
-        device_info = device._info["signals"]
-        if Kind.hinted in self.signal_filter:
-            hinted_signals = [
+        device_info = device._info.get("signals", {})
+
+        def _update(kind: Kind):
+            return [
                 signal
                 for signal, signal_info in device_info.items()
-                if (signal_info.get("kind_str", None) == str(Kind.hinted.value))
+                if kind in self.signal_filter
+                and (signal_info.get("kind_str", None) == str(kind.name))
             ]
-            self._hinted_signals = hinted_signals
-        if Kind.normal in self.signal_filter:
-            normal_signals = [
-                signal
-                for signal, signal_info in device_info.items()
-                if (signal_info.get("kind_str", None) == str(Kind.normal.value))
-            ]
-            self._normal_signals = normal_signals
-        if Kind.config in self.signal_filter:
-            config_signals = [
-                signal
-                for signal, signal_info in device_info.items()
-                if (signal_info.get("kind_str", None) == str(Kind.config.value))
-            ]
-            self._config_signals = config_signals
+
+        self._hinted_signals = _update(Kind.hinted)
+        self._normal_signals = _update(Kind.normal)
+        self._config_signals = _update(Kind.config)
+
         self._signals = self._hinted_signals + self._normal_signals + self._config_signals
         FilterIO.set_selection(widget=self, selection=self.signals)
 
@@ -249,7 +244,7 @@ class DeviceSignalInputBase(BECWidget):
             object: Device object, can be device of type Device, Positioner, Signal or ComputedSignal.
         """
         self.validate_device(device)
-        dev = getattr(self.dev, device.lower(), None)
+        dev = getattr(self.dev, device, None)
         if dev is None:
             logger.warning(f"Device {device} not found in devicemanager.")
             return None
@@ -278,3 +273,8 @@ class DeviceSignalInputBase(BECWidget):
         if signal in self.signals:
             return True
         return False
+
+    def _process_config_input(self, config: DeviceSignalInputBaseConfig | dict | None):
+        if config is None:
+            return DeviceSignalInputBaseConfig(widget_class=self.__class__.__name__)
+        return DeviceSignalInputBaseConfig.model_validate(config)

bec_widgets/widgets/control/device_input/device_combobox/device_combobox.py

@@ -22,10 +22,14 @@ class DeviceComboBox(DeviceInputBase, QComboBox):
         config: Device input configuration.
         gui_id: GUI ID.
         device_filter: Device filter, name of the device class from BECDeviceFilter and BECReadoutPriority. Check DeviceInputBase for more details.
+        readout_priority_filter: Readout priority filter, name of the readout priority class from BECDeviceFilter and BECReadoutPriority. Check DeviceInputBase for more details.
+        available_devices: List of available devices, if passed, it sets apply filters to false and device/readout priority filters will not be applied.
         default: Default device name.
         arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
     """
 
+    USER_ACCESS = ["set_device", "devices"]
+
     ICON_NAME = "list_alt"
     PLUGIN = True
 
@@ -47,8 +51,7 @@ class DeviceComboBox(DeviceInputBase, QComboBox):
         arg_name: str | None = None,
         **kwargs,
     ):
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
-        QComboBox.__init__(self, parent=parent)
+        super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
         if arg_name is not None:
             self.config.arg_name = arg_name
             self.arg_name = arg_name
@@ -141,7 +144,7 @@ class DeviceComboBox(DeviceInputBase, QComboBox):
         """
         if self.validate_device(input_text) is True:
             self._is_valid_input = True
-            self.device_selected.emit(input_text.lower())
+            self.device_selected.emit(input_text)
         else:
             self._is_valid_input = False
         self.update()

bec_widgets/widgets/control/device_input/device_line_edit/device_line_edit.py

@@ -24,11 +24,15 @@ class DeviceLineEdit(DeviceInputBase, QLineEdit):
         client: BEC client object.
         config: Device input configuration.
         gui_id: GUI ID.
-        device_filter: Device filter, name of the device class from BECDeviceFilter and ReadoutPriority. Check DeviceInputBase for more details.
+        device_filter: Device filter, name of the device class from BECDeviceFilter and BECReadoutPriority. Check DeviceInputBase for more details.
+        readout_priority_filter: Readout priority filter, name of the readout priority class from BECDeviceFilter and BECReadoutPriority. Check DeviceInputBase for more details.
+        available_devices: List of available devices, if passed, it sets apply filters to false and device/readout priority filters will not be applied.
         default: Default device name.
         arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
     """
 
+    USER_ACCESS = ["set_device", "devices", "_is_valid_input"]
+
     device_selected = Signal(str)
     device_config_update = Signal()
 
@@ -51,10 +55,9 @@ class DeviceLineEdit(DeviceInputBase, QLineEdit):
         **kwargs,
     ):
         self._callback_id = None
-        self._is_valid_input = False
+        self.__is_valid_input = False
         self._accent_colors = get_accent_colors()
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
-        QLineEdit.__init__(self, parent=parent)
+        super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
         self.completer = QCompleter(self)
         self.setCompleter(self.completer)
 
@@ -96,6 +99,20 @@ class DeviceLineEdit(DeviceInputBase, QLineEdit):
         self.textChanged.connect(self.check_validity)
         self.check_validity(self.text())
 
+    @property
+    def _is_valid_input(self) -> bool:
+        """
+        Check if the current value is a valid device name.
+
+        Returns:
+            bool: True if the current value is a valid device name, False otherwise.
+        """
+        return self.__is_valid_input
+
+    @_is_valid_input.setter
+    def _is_valid_input(self, value: bool) -> None:
+        self.__is_valid_input = value
+
     def on_device_update(self, action: str, content: dict) -> None:
         """
         Callback for device update events. Triggers the device_update signal.
@@ -148,7 +165,7 @@ class DeviceLineEdit(DeviceInputBase, QLineEdit):
         """
         if self.validate_device(input_text) is True:
             self._is_valid_input = True
-            self.device_selected.emit(input_text.lower())
+            self.device_selected.emit(input_text)
         else:
             self._is_valid_input = False
         self.update()

bec_widgets/widgets/control/device_input/signal_combobox/signal_combobox.py

@@ -23,8 +23,11 @@ class SignalComboBox(DeviceSignalInputBase, QComboBox):
         arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
     """
 
+    USER_ACCESS = ["set_signal", "set_device", "signals"]
+
     ICON_NAME = "list_alt"
     PLUGIN = True
+    RPC = True
 
     device_signal_changed = Signal(str)
 
@@ -40,8 +43,7 @@ class SignalComboBox(DeviceSignalInputBase, QComboBox):
         arg_name: str | None = None,
         **kwargs,
     ):
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
-        QComboBox.__init__(self, parent=parent)
+        super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
         if arg_name is not None:
             self.config.arg_name = arg_name
             self.arg_name = arg_name

bec_widgets/widgets/control/device_input/signal_line_edit/signal_line_edit.py

@@ -24,9 +24,12 @@ class SignalLineEdit(DeviceSignalInputBase, QLineEdit):
         arg_name: Argument name, can be used for the other widgets which has to call some other function in bec using correct argument names.
     """
 
+    USER_ACCESS = ["_is_valid_input", "set_signal", "set_device", "signals"]
+
     device_signal_changed = Signal(str)
 
     PLUGIN = True
+    RPC = True
     ICON_NAME = "vital_signs"
 
     def __init__(
@@ -41,9 +44,8 @@ class SignalLineEdit(DeviceSignalInputBase, QLineEdit):
         arg_name: str | None = None,
         **kwargs,
     ):
-        self._is_valid_input = False
-        super().__init__(client=client, config=config, gui_id=gui_id, **kwargs)
-        QLineEdit.__init__(self, parent=parent)
+        self.__is_valid_input = False
+        super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
         self._accent_colors = get_accent_colors()
         self.completer = QCompleter(self)
         self.setCompleter(self.completer)
@@ -66,8 +68,22 @@ class SignalLineEdit(DeviceSignalInputBase, QLineEdit):
             self.set_device(device)
         if default is not None:
             self.set_signal(default)
-        self.textChanged.connect(self.validate_device)
-        self.validate_device(self.text())
+        self.textChanged.connect(self.check_validity)
+        self.check_validity(self.text())
+
+    @property
+    def _is_valid_input(self) -> bool:
+        """
+        Check if the current value is a valid device name.
+
+        Returns:
+            bool: True if the current value is a valid device name, False otherwise.
+        """
+        return self.__is_valid_input
+
+    @_is_valid_input.setter
+    def _is_valid_input(self, value: bool) -> None:
+        self.__is_valid_input = value
 
     def get_current_device(self) -> object:
         """
@@ -132,6 +148,9 @@ if __name__ == "__main__":  # pragma: no cover
     from qtpy.QtWidgets import QApplication, QVBoxLayout, QWidget
 
     from bec_widgets.utils.colors import set_theme
+    from bec_widgets.widgets.control.device_input.device_combobox.device_combobox import (
+        DeviceComboBox,
+    )
 
     app = QApplication([])
     set_theme("dark")
@@ -139,6 +158,12 @@ if __name__ == "__main__":  # pragma: no cover
     widget.setFixedSize(200, 200)
     layout = QVBoxLayout()
     widget.setLayout(layout)
-    layout.addWidget(SignalLineEdit(device="samx"))
+    device_line_edit = DeviceComboBox()
+    device_line_edit.filter_to_positioner = True
+    signal_line_edit = SignalLineEdit()
+    device_line_edit.device_selected.connect(signal_line_edit.set_device)
+
+    layout.addWidget(device_line_edit)
+    layout.addWidget(signal_line_edit)
     widget.show()
     app.exec_()

bec_widgets/widgets/control/scan_control/scan_control.py

@@ -41,6 +41,10 @@ class ScanControlConfig(ConnectionConfig):
 
 
 class ScanControl(BECWidget, QWidget):
+    """
+    Widget to submit new scans to the queue.
+    """
+
     PLUGIN = True
     ICON_NAME = "tune"
     ARG_BOX_POSITION: int = 2
@@ -60,13 +64,11 @@ class ScanControl(BECWidget, QWidget):
         default_scan: str | None = None,
         **kwargs,
     ):
-
         if config is None:
             config = ScanControlConfig(
                 widget_class=self.__class__.__name__, allowed_scans=allowed_scans
             )
-        super().__init__(client=client, gui_id=gui_id, config=config, **kwargs)
-        QWidget.__init__(self, parent=parent)
+        super().__init__(parent=parent, client=client, gui_id=gui_id, config=config, **kwargs)
 
         self._hide_add_remove_buttons = False
 
@@ -163,7 +165,7 @@ class ScanControl(BECWidget, QWidget):
         self.layout.addStretch()
 
     def _add_metadata_form(self):
-        self._metadata_form = ScanMetadata()
+        self._metadata_form = ScanMetadata(parent=self)
         self.layout.addWidget(self._metadata_form)
         self._metadata_form.update_with_new_scan(self.comboBox_scan_selection.currentText())
         self.scan_selected.connect(self._metadata_form.update_with_new_scan)

bec_widgets/widgets/control/scan_control/scan_group_box.py

@@ -234,7 +234,7 @@ class ScanGroupBox(QGroupBox):
                 continue
             if default == "_empty":
                 default = None
-            widget = widget_class(arg_name=arg_name, default=default)
+            widget = widget_class(parent=self.parent(), arg_name=arg_name, default=default)
             if isinstance(widget, DeviceLineEdit):
                 widget.set_device_filter(BECDeviceFilter.DEVICE)
                 self.selected_devices[widget] = ""
@@ -274,12 +274,24 @@ class ScanGroupBox(QGroupBox):
         for widget in self.widgets[-len(self.inputs) :]:
             if isinstance(widget, DeviceLineEdit):
                 self.selected_devices[widget] = ""
+            widget.close()
             widget.deleteLater()
         self.widgets = self.widgets[: -len(self.inputs)]
 
         selected_devices_str = " ".join(self.selected_devices.values())
         self.device_selected.emit(selected_devices_str.strip())
 
+    def remove_all_widget_bundles(self):
+        """Remove every widget bundle from the scan control layout."""
+        for widget in list(self.widgets):
+            if isinstance(widget, DeviceLineEdit):
+                self.selected_devices.pop(widget, None)
+            widget.close()
+            widget.deleteLater()
+            self.layout.removeWidget(widget)
+        self.widgets.clear()
+        self.device_selected.emit("")
+
     @Property(bool)
     def hide_add_remove_buttons(self):
         return self._hide_add_remove_buttons
@@ -348,10 +360,21 @@ class ScanGroupBox(QGroupBox):
             self._set_kwarg_parameters(parameters)
 
     def _set_arg_parameters(self, parameters: list):
-        while len(parameters) != len(self.widgets):
-            self.add_widget_bundle()
-        for i, parameter in enumerate(parameters):
-            WidgetIO.set_value(self.widgets[i], parameter)
+        self.remove_all_widget_bundles()
+        if not parameters:
+            return
+
+        inputs_per_bundle = len(self.inputs)
+        if inputs_per_bundle == 0:
+            return
+
+        bundles_needed = -(-len(parameters) // inputs_per_bundle)
+
+        for row in range(1, bundles_needed + 1):
+            self.add_input_widgets(self.inputs, row)
+
+        for i, value in enumerate(parameters):
+            WidgetIO.set_value(self.widgets[i], value)
 
     def _set_kwarg_parameters(self, parameters: dict):
         for widget in self.widgets: