Reword

Co-authored-by: Ariel Ebersberger <31776703+justanotherariel@users.noreply.github.com>
Signed-off-by: Matt Jones <47545907+SoundMatt@users.noreply.github.com>

.claude/skills/ha-integration-knowledge/SKILL.md

@@ -24,6 +24,7 @@ The following platforms have extra guidelines:
 ## Entity platforms
 
 - Ensure `async_added_to_hass()` and `async_will_remove_from_hass()` have symmetrical behavior. For example, if a subscription is created in `async_added_to_hass()`, it should be unsubscribed in `async_will_remove_from_hass()`. Also, if something is torn down in `async_will_remove_from_hass()`, it should be set up in `async_added_to_hass()`.
+- Entity base class (e.g. `SensorEntity`, `TrackerEntity`) provide a stable API for child classes to inherit from. Do not suggest redeclaring or duplicating attributes, properties, or methods the base class already provides, and do not add guards against the parent's behavior changing — rely on the base class instead.
 
 ## Integration Quality Scale
 

.github/actions/cache-apt-packages/action.yml

@@ -0,0 +1,52 @@
+name: Cache and install APT packages
+description: >-
+  Wraps awalsh128/cache-apt-pkgs-action with the workarounds Home Assistant CI
+  needs. Removes the conflicting Microsoft apt source before any apt run, and
+  points the dynamic linker at the host's multiarch lib subdirectories so
+  shared libraries that rely on update-alternatives or postinst-managed paths
+  (eg libblas, liblapack pulled in by ffmpeg) stay reachable since the upstream
+  action does not execute postinst scripts on cache restore.
+
+inputs:
+  packages:
+    description: Space-delimited list of apt packages to install.
+    required: true
+  version:
+    description: Cache version. Bump to invalidate the cache.
+    required: false
+    default: "1"
+  execute_install_scripts:
+    description: >-
+      Pass-through to awalsh128/cache-apt-pkgs-action. Postinst scripts are not
+      actually cached by the upstream action, so this is largely a no-op today.
+    required: false
+    default: "false"
+
+runs:
+  using: composite
+  steps:
+    - name: Remove conflicting Microsoft apt source
+      shell: bash
+      run: sudo rm -f /etc/apt/sources.list.d/microsoft-prod.list
+    - name: Install apt packages via cache
+      uses: awalsh128/cache-apt-pkgs-action@acb598e5ddbc6f68a970c5da0688d2f3a9f04d05 # v1.5.3
+      with:
+        packages: ${{ inputs.packages }}
+        version: ${{ inputs.version }}
+        execute_install_scripts: ${{ inputs.execute_install_scripts }}
+    - name: Refresh dynamic linker cache
+      shell: bash
+      run: |
+        # awalsh128/cache-apt-pkgs-action does not run postinst scripts on
+        # cache restore, so update-alternatives symlinks (eg the one libblas
+        # creates at /usr/lib/<multiarch>/libblas.so.3) are never produced.
+        # Add every /usr/lib/<multiarch> subdirectory that holds shared
+        # libraries to the ldconfig search path so the dynamic linker still
+        # finds them.  Use dpkg-architecture to derive the host's multiarch
+        # tuple so this works on non-x86_64 runners too.
+        multiarch="$(dpkg-architecture -qDEB_HOST_MULTIARCH)"
+        find "/usr/lib/${multiarch}" -mindepth 2 -maxdepth 2 \
+          -name '*.so.*' -printf '%h\n' \
+          | sort -u \
+          | sudo tee /etc/ld.so.conf.d/zzz-cache-apt-extras.conf > /dev/null
+        sudo ldconfig

.github/copilot-instructions.md

@@ -43,6 +43,7 @@ This repository contains the core of Home Assistant, a Python 3 based home autom
 - Avoid using conditions/branching in tests. Instead, either split tests or adjust the test parametrization to cover all cases without branching.
 - If multiple tests share most of their code, use `pytest.mark.parametrize` to merge them into a single parameterized test instead of duplicating the body. Use `pytest.param` with an `id` parameter to name the test cases clearly.
 - We use Syrupy for snapshot testing. Leverage `.ambr` snapshots instead of repetitive and exhaustive generation of test data within Python code itself.
+- Hardcoded `entity_id`s in tests are fine. If the same one is repeated, use a constant.
 
 ## Good practices
 

.github/instructions/integrations.instructions.md

@@ -27,6 +27,7 @@ The following platforms have extra guidelines:
 ## Entity platforms
 
 - Ensure `async_added_to_hass()` and `async_will_remove_from_hass()` have symmetrical behavior. For example, if a subscription is created in `async_added_to_hass()`, it should be unsubscribed in `async_will_remove_from_hass()`. Also, if something is torn down in `async_will_remove_from_hass()`, it should be set up in `async_added_to_hass()`.
+- Entity base class (e.g. `SensorEntity`, `TrackerEntity`) provide a stable API for child classes to inherit from. Do not suggest redeclaring or duplicating attributes, properties, or methods the base class already provides, and do not add guards against the parent's behavior changing — rely on the base class instead.
 
 ## Integration Quality Scale
 

.github/workflows/ci.yaml

@@ -60,9 +60,7 @@ env:
   # - 15.2 is the latest (as of 9 Feb 2023)
   POSTGRESQL_VERSIONS: "['postgres:12.14','postgres:15.2']"
   UV_CACHE_DIR: /tmp/uv-cache
-  APT_CACHE_BASE: /home/runner/work/apt
-  APT_CACHE_DIR: /home/runner/work/apt/cache
-  APT_LIST_CACHE_DIR: /home/runner/work/apt/lists
+  APT_CACHE_VERSION: 1
   SQLALCHEMY_WARN_20: 1
   PYTHONASYNCIODEBUG: 1
   HASS_CI: 1
@@ -86,7 +84,6 @@ jobs:
       core: ${{ steps.core.outputs.changes }}
       integrations_glob: ${{ steps.info.outputs.integrations_glob }}
       integrations: ${{ steps.integrations.outputs.changes }}
-      apt_cache_key: ${{ steps.generate_apt_cache_key.outputs.key }}
       python_cache_key: ${{ steps.generate_python_cache_key.outputs.key }}
       requirements: ${{ steps.core.outputs.requirements }}
       mariadb_groups: ${{ steps.info.outputs.mariadb_groups }}
@@ -116,10 +113,6 @@ jobs:
           # Include HA_SHORT_VERSION to force the immediate creation
           # of a new uv cache entry after a version bump.
           echo "key=venv-${CACHE_VERSION}-${HA_SHORT_VERSION}-${HASH_REQUIREMENTS_TEST}-${HASH_REQUIREMENTS}-${HASH_REQUIREMENTS_ALL}-${HASH_PACKAGE_CONSTRAINTS}-${HASH_GEN_REQUIREMENTS}" >> $GITHUB_OUTPUT
-      - name: Generate partial apt restore key
-        id: generate_apt_cache_key
-        run: |
-          echo "key=$(lsb_release -rs)-apt-${CACHE_VERSION}-${HA_SHORT_VERSION}" >> $GITHUB_OUTPUT
       - name: Filter for core changes
         uses: dorny/paths-filter@fbd0ab8f3e69293af611ebaee6363fc25e6d187d # v4.0.1
         id: core
@@ -384,65 +377,36 @@ jobs:
           path: ${{ env.UV_CACHE_DIR }}
           key: ${{ steps.generate-uv-key.outputs.full_key }}
           restore-keys: ${{ steps.generate-uv-key.outputs.partial_key }}
-      - name: Check if apt cache exists
-        id: cache-apt-check
-        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
-        with:
-          lookup-only: ${{ steps.cache-venv.outputs.cache-hit == 'true' }}
-          path: |
-            ${{ env.APT_CACHE_DIR }}
-            ${{ env.APT_LIST_CACHE_DIR }}
-          key: >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
       - name: Install additional OS dependencies
-        if: |
-          steps.cache-venv.outputs.cache-hit != 'true'
-          || steps.cache-apt-check.outputs.cache-hit != 'true'
-        id: install-os-deps
+        if: steps.cache-venv.outputs.cache-hit != 'true'
         timeout-minutes: 10
-        env:
-          APT_CACHE_HIT: ${{ steps.cache-apt-check.outputs.cache-hit }}
-        run: |
-          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
-          if [[ "${APT_CACHE_HIT}" != 'true' ]]; then
-            mkdir -p ${APT_CACHE_DIR}
-            mkdir -p ${APT_LIST_CACHE_DIR}
-          fi
-
-          sudo apt-get update \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
-          sudo apt-get -y install \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
-            bluez \
-            ffmpeg \
-            libturbojpeg \
-            libxml2-utils \
-            libavcodec-dev \
-            libavdevice-dev \
-            libavfilter-dev \
-            libavformat-dev \
-            libavutil-dev \
-            libswresample-dev \
-            libswscale-dev \
-            libudev-dev
-
-          if [[ "${APT_CACHE_HIT}" != 'true' ]]; then
-            sudo chmod -R 755 ${APT_CACHE_BASE}
-          fi
-      - name: Save apt cache
-        if: |
-          always()
-          && steps.cache-apt-check.outputs.cache-hit != 'true'
-          && steps.install-os-deps.outcome == 'success'
-        uses: actions/cache/save@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: ./.github/actions/cache-apt-packages
         with:
-          path: |
-            ${{ env.APT_CACHE_DIR }}
-            ${{ env.APT_LIST_CACHE_DIR }}
-          key: >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
+          packages: >-
+            bluez
+            ffmpeg
+            libturbojpeg
+            libxml2-utils
+            libavcodec-dev
+            libavdevice-dev
+            libavfilter-dev
+            libavformat-dev
+            libavutil-dev
+            libswresample-dev
+            libswscale-dev
+            libudev-dev
+          version: ${{ env.APT_CACHE_VERSION }}
+          execute_install_scripts: true
+      - name: Read uv version from requirements.txt
+        if: steps.cache-venv.outputs.cache-hit != 'true'
+        id: read-uv-version
+        run: |
+          echo "version=$(grep '^uv==' requirements.txt | cut -d'=' -f3)" >> "$GITHUB_OUTPUT"
+      - name: Set up uv
+        if: steps.cache-venv.outputs.cache-hit != 'true'
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
+        with:
+          version: ${{ steps.read-uv-version.outputs.version }}
       - name: Create Python virtual environment
         if: steps.cache-venv.outputs.cache-hit != 'true'
         id: create-venv
@@ -450,8 +414,6 @@ jobs:
           python -m venv venv
           . venv/bin/activate
           python --version
-          pip install "$(grep '^uv' < requirements.txt)"
-          uv pip install -U "pip>=25.2"
           uv pip install -r requirements.txt
           uv pip install -r requirements_all.txt -r requirements_test.txt
           uv pip install -e . --config-settings editable_mode=compat
@@ -506,30 +468,16 @@ jobs:
       && github.event.inputs.mypy-only != 'true'
       && github.event.inputs.audit-licenses-only != 'true'
     steps:
-      - name: Restore apt cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
-        with:
-          path: |
-            ${{ env.APT_CACHE_DIR }}
-            ${{ env.APT_LIST_CACHE_DIR }}
-          fail-on-cache-miss: true
-          key: >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
-      - name: Install additional OS dependencies
-        timeout-minutes: 10
-        run: |
-          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
-          sudo apt-get update \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
-          sudo apt-get -y install \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
-            libturbojpeg
       - name: Check out code from GitHub
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           persist-credentials: false
+      - name: Install additional OS dependencies
+        timeout-minutes: 10
+        uses: ./.github/actions/cache-apt-packages
+        with:
+          packages: libturbojpeg
+          version: ${{ env.APT_CACHE_VERSION }}
       - name: Set up Python
         id: python
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -876,32 +824,20 @@ jobs:
       - info
       - base
     steps:
-      - name: Restore apt cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
-        with:
-          path: |
-            ${{ env.APT_CACHE_DIR }}
-            ${{ env.APT_LIST_CACHE_DIR }}
-          fail-on-cache-miss: true
-          key: >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
-      - name: Install additional OS dependencies
-        timeout-minutes: 10
-        run: |
-          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
-          sudo apt-get update \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
-          sudo apt-get -y install \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
-            bluez \
-            ffmpeg \
-            libturbojpeg
       - name: Check out code from GitHub
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           persist-credentials: false
+      - name: Install additional OS dependencies
+        timeout-minutes: 10
+        uses: ./.github/actions/cache-apt-packages
+        with:
+          packages: >-
+            bluez
+            ffmpeg
+            libturbojpeg
+          version: ${{ env.APT_CACHE_VERSION }}
+          execute_install_scripts: true
       - name: Set up Python
         id: python
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -952,33 +888,21 @@ jobs:
         python-version: ${{ fromJson(needs.info.outputs.python_versions) }}
         group: ${{ fromJson(needs.info.outputs.test_groups) }}
     steps:
-      - name: Restore apt cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
-        with:
-          path: |
-            ${{ env.APT_CACHE_DIR }}
-            ${{ env.APT_LIST_CACHE_DIR }}
-          fail-on-cache-miss: true
-          key: >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
-      - name: Install additional OS dependencies
-        timeout-minutes: 10
-        run: |
-          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
-          sudo apt-get update \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
-          sudo apt-get -y install \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
-            bluez \
-            ffmpeg \
-            libturbojpeg \
-            libxml2-utils
       - name: Check out code from GitHub
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           persist-credentials: false
+      - name: Install additional OS dependencies
+        timeout-minutes: 10
+        uses: ./.github/actions/cache-apt-packages
+        with:
+          packages: >-
+            bluez
+            ffmpeg
+            libturbojpeg
+            libxml2-utils
+          version: ${{ env.APT_CACHE_VERSION }}
+          execute_install_scripts: true
       - name: Set up Python ${{ matrix.python-version }}
         id: python
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -1105,34 +1029,22 @@ jobs:
         python-version: ${{ fromJson(needs.info.outputs.python_versions) }}
         mariadb-group: ${{ fromJson(needs.info.outputs.mariadb_groups) }}
     steps:
-      - name: Restore apt cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
-        with:
-          path: |
-            ${{ env.APT_CACHE_DIR }}
-            ${{ env.APT_LIST_CACHE_DIR }}
-          fail-on-cache-miss: true
-          key: >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
-      - name: Install additional OS dependencies
-        timeout-minutes: 10
-        run: |
-          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
-          sudo apt-get update \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
-          sudo apt-get -y install \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
-            bluez \
-            ffmpeg \
-            libturbojpeg \
-            libmariadb-dev-compat \
-            libxml2-utils
       - name: Check out code from GitHub
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           persist-credentials: false
+      - name: Install additional OS dependencies
+        timeout-minutes: 10
+        uses: ./.github/actions/cache-apt-packages
+        with:
+          packages: >-
+            bluez
+            ffmpeg
+            libturbojpeg
+            libmariadb-dev-compat
+            libxml2-utils
+          version: ${{ env.APT_CACHE_VERSION }}
+          execute_install_scripts: true
       - name: Set up Python ${{ matrix.python-version }}
         id: python
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -1266,36 +1178,29 @@ jobs:
         python-version: ${{ fromJson(needs.info.outputs.python_versions) }}
         postgresql-group: ${{ fromJson(needs.info.outputs.postgresql_groups) }}
     steps:
-      - name: Restore apt cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
-        with:
-          path: |
-            ${{ env.APT_CACHE_DIR }}
-            ${{ env.APT_LIST_CACHE_DIR }}
-          fail-on-cache-miss: true
-          key: >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
-      - name: Install additional OS dependencies
-        timeout-minutes: 10
-        run: |
-          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
-          sudo apt-get update \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
-          sudo apt-get -y install \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
-            bluez \
-            ffmpeg \
-            libturbojpeg \
-            libxml2-utils
-          sudo /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh -y
-          sudo apt-get -y install \
-            postgresql-server-dev-14
       - name: Check out code from GitHub
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           persist-credentials: false
+      - name: Install additional OS dependencies
+        timeout-minutes: 10
+        uses: ./.github/actions/cache-apt-packages
+        with:
+          packages: >-
+            bluez
+            ffmpeg
+            libturbojpeg
+            libxml2-utils
+          version: ${{ env.APT_CACHE_VERSION }}
+          execute_install_scripts: true
+      - name: Set up PostgreSQL apt repository
+        run: sudo /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh -y
+      - name: Cache PostgreSQL development headers
+        timeout-minutes: 10
+        uses: ./.github/actions/cache-apt-packages
+        with:
+          packages: postgresql-server-dev-14
+          version: ${{ env.APT_CACHE_VERSION }}
       - name: Set up Python ${{ matrix.python-version }}
         id: python
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
@@ -1449,33 +1354,21 @@ jobs:
         python-version: ${{ fromJson(needs.info.outputs.python_versions) }}
         group: ${{ fromJson(needs.info.outputs.test_groups) }}
     steps:
-      - name: Restore apt cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
-        with:
-          path: |
-            ${{ env.APT_CACHE_DIR }}
-            ${{ env.APT_LIST_CACHE_DIR }}
-          fail-on-cache-miss: true
-          key: >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ needs.info.outputs.apt_cache_key }}
-      - name: Install additional OS dependencies
-        timeout-minutes: 10
-        run: |
-          sudo rm /etc/apt/sources.list.d/microsoft-prod.list
-          sudo apt-get update \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR}
-          sudo apt-get -y install \
-            -o Dir::Cache=${APT_CACHE_DIR} \
-            -o Dir::State::Lists=${APT_LIST_CACHE_DIR} \
-            bluez \
-            ffmpeg \
-            libturbojpeg \
-            libxml2-utils
       - name: Check out code from GitHub
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
           persist-credentials: false
+      - name: Install additional OS dependencies
+        timeout-minutes: 10
+        uses: ./.github/actions/cache-apt-packages
+        with:
+          packages: >-
+            bluez
+            ffmpeg
+            libturbojpeg
+            libxml2-utils
+          version: ${{ env.APT_CACHE_VERSION }}
+          execute_install_scripts: true
       - name: Set up Python ${{ matrix.python-version }}
         id: python
         uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0

.github/workflows/stale.yml

@@ -27,7 +27,7 @@ jobs:
       # - No PRs marked as no-stale
       # - No issues (-1)
       - name: 60 days stale PRs policy
-        uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f # v10.2.0
+        uses: actions/stale@eb5cf3af3ac0a1aa4c9c45633dd1ae542a27a899 # v10.3.0
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           days-before-stale: 60
@@ -55,11 +55,11 @@ jobs:
       - name: Generate app token
         id: token
         # Pinned to a specific version of the action for security reasons
-        # v1.7.0
-        uses: tibdex/github-app-token@3beb63f4bd073e61482598c45c71c1019b59b73a
+        # v3.2.0
+        uses: actions/create-github-app-token@bcd2ba49218906704ab6c1aa796996da409d3eb1
         with:
-          app_id: ${{ secrets.ISSUE_TRIAGE_APP_ID }} # zizmor: ignore[secrets-outside-env]
-          private_key: ${{ secrets.ISSUE_TRIAGE_APP_PEM }} # zizmor: ignore[secrets-outside-env]
+          app-id: ${{ secrets.ISSUE_TRIAGE_APP_ID }} # zizmor: ignore[secrets-outside-env]
+          private-key: ${{ secrets.ISSUE_TRIAGE_APP_PEM }} # zizmor: ignore[secrets-outside-env]
 
       # The 90 day stale policy for issues
       # Used for:
@@ -67,7 +67,7 @@ jobs:
       # - No issues marked as no-stale or help-wanted
       # - No PRs (-1)
       - name: 90 days stale issues
-        uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f # v10.2.0
+        uses: actions/stale@eb5cf3af3ac0a1aa4c9c45633dd1ae542a27a899 # v10.3.0
         with:
           repo-token: ${{ steps.token.outputs.token }}
           days-before-stale: 90
@@ -97,7 +97,7 @@ jobs:
       # - No Issues marked as no-stale or help-wanted
       # - No PRs (-1)
       - name: Needs more information stale issues policy
-        uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f # v10.2.0
+        uses: actions/stale@eb5cf3af3ac0a1aa4c9c45633dd1ae542a27a899 # v10.3.0
         with:
           repo-token: ${{ steps.token.outputs.token }}
           only-labels: "needs-more-information"

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.15.13
+    rev: v0.15.14
     hooks:
       - id: ruff-check
         args:

.strict-typing

@@ -337,6 +337,7 @@ homeassistant.components.led_ble.*
 homeassistant.components.lektrico.*
 homeassistant.components.letpot.*
 homeassistant.components.lg_infrared.*
+homeassistant.components.lg_tv_rs232.*
 homeassistant.components.libre_hardware_monitor.*
 homeassistant.components.lidarr.*
 homeassistant.components.liebherr.*
@@ -428,6 +429,7 @@ homeassistant.components.otp.*
 homeassistant.components.ouman_eh_800.*
 homeassistant.components.overkiz.*
 homeassistant.components.overseerr.*
+homeassistant.components.ovhcloud_ai_endpoints.*
 homeassistant.components.p1_monitor.*
 homeassistant.components.paj_gps.*
 homeassistant.components.panel_custom.*
@@ -565,6 +567,7 @@ homeassistant.components.technove.*
 homeassistant.components.tedee.*
 homeassistant.components.telegram_bot.*
 homeassistant.components.teleinfo.*
+homeassistant.components.teltonika.*
 homeassistant.components.teslemetry.*
 homeassistant.components.text.*
 homeassistant.components.thethingsnetwork.*

AGENTS.md

@@ -33,6 +33,7 @@ This repository contains the core of Home Assistant, a Python 3 based home autom
 - Avoid using conditions/branching in tests. Instead, either split tests or adjust the test parametrization to cover all cases without branching.
 - If multiple tests share most of their code, use `pytest.mark.parametrize` to merge them into a single parameterized test instead of duplicating the body. Use `pytest.param` with an `id` parameter to name the test cases clearly.
 - We use Syrupy for snapshot testing. Leverage `.ambr` snapshots instead of repetitive and exhaustive generation of test data within Python code itself.
+- Hardcoded `entity_id`s in tests are fine. If the same one is repeated, use a constant.
 
 ## Good practices
 

CODEOWNERS

@@ -987,6 +987,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/lg_netcast/ @Drafteed @splinter98
 /homeassistant/components/lg_thinq/ @LG-ThinQ-Integration
 /tests/components/lg_thinq/ @LG-ThinQ-Integration
+/homeassistant/components/lg_tv_rs232/ @balloob
+/tests/components/lg_tv_rs232/ @balloob
 /homeassistant/components/libre_hardware_monitor/ @Sab44
 /tests/components/libre_hardware_monitor/ @Sab44
 /homeassistant/components/lichess/ @aryanhasgithub
@@ -1290,6 +1292,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/openhome/ @bazwilliams
 /homeassistant/components/openrgb/ @felipecrs
 /tests/components/openrgb/ @felipecrs
+/homeassistant/components/opensensemap/ @AlCalzone
+/tests/components/opensensemap/ @AlCalzone
 /homeassistant/components/opensky/ @joostlek
 /tests/components/opensky/ @joostlek
 /homeassistant/components/opentherm_gw/ @mvn23
@@ -1317,6 +1321,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/overkiz/ @imicknl
 /homeassistant/components/overseerr/ @joostlek @AmGarera
 /tests/components/overseerr/ @joostlek @AmGarera
+/homeassistant/components/ovhcloud_ai_endpoints/ @Crocmagnon
+/tests/components/ovhcloud_ai_endpoints/ @Crocmagnon
 /homeassistant/components/ovo_energy/ @timmo001
 /tests/components/ovo_energy/ @timmo001
 /homeassistant/components/p1_monitor/ @klaasnicolaas
@@ -2048,14 +2054,16 @@ CLAUDE.md @home-assistant/core
 /tests/components/yamaha_musiccast/ @vigonotion @micha91
 /homeassistant/components/yandex_transport/ @rishatik92 @devbis
 /tests/components/yandex_transport/ @rishatik92 @devbis
-/homeassistant/components/yardian/ @h3l1o5
-/tests/components/yardian/ @h3l1o5
+/homeassistant/components/yardian/ @aeon-matrix
+/tests/components/yardian/ @aeon-matrix
 /homeassistant/components/yeelight/ @zewelor @shenxn @starkillerOG @alexyao2015
 /tests/components/yeelight/ @zewelor @shenxn @starkillerOG @alexyao2015
 /homeassistant/components/yeelightsunflower/ @lindsaymarkward
 /homeassistant/components/yi/ @bachya
 /homeassistant/components/yolink/ @matrixd2
 /tests/components/yolink/ @matrixd2
+/homeassistant/components/yoto/ @cdnninja @piitaya
+/tests/components/yoto/ @cdnninja @piitaya
 /homeassistant/components/youless/ @gjong
 /tests/components/youless/ @gjong
 /homeassistant/components/youtube/ @joostlek

homeassistant/components/air_quality/triggers.yaml

@@ -1,7 +1,7 @@
 .trigger_common_fields:
   behavior: &trigger_behavior
     required: true
-    default: any
+    default: each
     selector:
       automation_behavior:
         mode: trigger

homeassistant/components/alarm_control_panel/triggers.yaml

@@ -5,7 +5,7 @@
   fields: &trigger_common_fields
     behavior:
       required: true
-      default: any
+      default: each
       selector:
         automation_behavior:
           mode: trigger

homeassistant/components/alexa_devices/__init__.py

@@ -1,9 +1,13 @@
 """Alexa Devices integration."""
 
+import asyncio
+import contextlib
+
 from homeassistant.const import CONF_COUNTRY, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import aiohttp_client, config_validation as cv
+from homeassistant.helpers import aiohttp_client, config_validation as cv, httpx_client
 from homeassistant.helpers.typing import ConfigType
+from homeassistant.util.ssl import SSL_ALPN_HTTP11_HTTP2
 
 from .const import _LOGGER, CONF_LOGIN_DATA, CONF_SITE, COUNTRY_DOMAINS, DOMAIN
 from .coordinator import AmazonConfigEntry, AmazonDevicesCoordinator
@@ -12,6 +16,8 @@ from .services import async_setup_services
 PLATFORMS = [
     Platform.BINARY_SENSOR,
     Platform.BUTTON,
+    Platform.EVENT,
+    Platform.MEDIA_PLAYER,
     Platform.NOTIFY,
     Platform.SENSOR,
     Platform.SWITCH,
@@ -34,6 +40,28 @@ async def async_setup_entry(hass: HomeAssistant, entry: AmazonConfigEntry) -> bo
 
     await coordinator.async_config_entry_first_refresh()
 
+    await coordinator.sync_history_state()
+    await coordinator.sync_media_state()
+
+    async def _on_http2_reauth_required() -> None:
+        entry.async_start_reauth(hass)
+
+    async def _cancel_http2() -> None:
+        http2_task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await http2_task
+
+    alexa_httpx_client = httpx_client.get_async_client(
+        hass,
+        alpn_protocols=SSL_ALPN_HTTP11_HTTP2,
+    )
+
+    http2_task = await coordinator.api.start_http2_processing(
+        alexa_httpx_client, on_reauth_required=_on_http2_reauth_required
+    )
+
+    entry.async_on_unload(_cancel_http2)
+
     entry.runtime_data = coordinator
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)

homeassistant/components/alexa_devices/coordinator.py

@@ -8,13 +8,18 @@ from aioamazondevices.exceptions import (
     CannotConnect,
     CannotRetrieveData,
 )
-from aioamazondevices.structures import AmazonDevice
+from aioamazondevices.structures import (
+    AmazonDevice,
+    AmazonMediaState,
+    AmazonVocalRecord,
+    AmazonVolumeState,
+)
 from aiohttp import ClientSession
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.debounce import Debouncer
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
@@ -73,6 +78,18 @@ class AmazonDevicesCoordinator(DataUpdateCoordinator[dict[str, AmazonDevice]]):
             if routine.domain == Platform.BUTTON
         }
 
+        self._vocal_records: dict[str, AmazonVocalRecord] = {}
+        self.api.on_history_event.append(self.history_state_event_handler)
+        self.api.on_history_event.freeze()
+
+        self._volume_states: dict[str, AmazonVolumeState] = {}
+        self.api.on_volume_state_event.append(self.volume_state_event_handler)
+        self.api.on_volume_state_event.freeze()
+
+        self._media_states: dict[str, AmazonMediaState] = {}
+        self.api.on_media_state_event.append(self.media_state_event_handler)
+        self.api.on_media_state_event.freeze()
+
     async def _async_update_data(self) -> dict[str, AmazonDevice]:
         """Update device data."""
         try:
@@ -149,3 +166,66 @@ class AmazonDevicesCoordinator(DataUpdateCoordinator[dict[str, AmazonDevice]]):
             )
             if entity_id:
                 entity_registry.async_remove(entity_id)
+
+    async def sync_history_state(self) -> None:
+        """Sync history state."""
+        try:
+            self._vocal_records = await self.api.sync_history_state()
+        except CannotAuthenticate as e:
+            raise ConfigEntryAuthFailed(
+                translation_domain=DOMAIN,
+                translation_key="invalid_auth",
+                translation_placeholders={"error": repr(e)},
+            ) from e
+        except CannotConnect as e:
+            raise ConfigEntryNotReady(
+                translation_domain=DOMAIN,
+                translation_key="cannot_connect_with_error",
+                translation_placeholders={"error": repr(e)},
+            ) from e
+        except BaseException as e:
+            raise ConfigEntryNotReady(
+                translation_domain=DOMAIN,
+                translation_key="cannot_retrieve_data_with_error",
+                translation_placeholders={"error": repr(e)},
+            ) from e
+
+    async def history_state_event_handler(
+        self, vocal_records: dict[str, AmazonVocalRecord]
+    ) -> None:
+        """Handle pushed vocal record events."""
+        self._vocal_records = {**self._vocal_records, **vocal_records}
+        self.async_update_listeners()
+
+    @property
+    def vocal_records(self) -> dict[str, AmazonVocalRecord]:
+        """Vocal records of devices."""
+        return self._vocal_records
+
+    async def sync_media_state(self) -> None:
+        """Sync media state."""
+        await self.api.sync_media_state()
+
+    async def media_state_event_handler(
+        self, media_state: dict[str, AmazonMediaState]
+    ) -> None:
+        """Handle pushed media state changed events."""
+        self._media_states = media_state
+        self.async_update_listeners()
+
+    @property
+    def media_states(self) -> dict[str, AmazonMediaState]:
+        """Media state of devices."""
+        return self._media_states
+
+    async def volume_state_event_handler(
+        self, volume_states: dict[str, AmazonVolumeState]
+    ) -> None:
+        """Handle pushed volume change events."""
+        self._volume_states = volume_states
+        self.async_update_listeners()
+
+    @property
+    def volume_states(self) -> dict[str, AmazonVolumeState]:
+        """Volumes of devices."""
+        return self._volume_states

homeassistant/components/alexa_devices/event.py

@@ -0,0 +1,86 @@
+"""Support for events."""
+
+from typing import Final
+
+from homeassistant.components.event import EventEntity, EventEntityDescription
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .const import _LOGGER
+from .coordinator import AmazonConfigEntry, AmazonDevicesCoordinator
+from .entity import AmazonEntity
+
+# Coordinator is used to centralize the data updates
+PARALLEL_UPDATES = 0
+
+EVENTS: Final = {
+    EventEntityDescription(
+        key="voice_event",
+        translation_key="voice_event",
+    ),
+}
+
+EVENT_TYPE = "triggered"
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: AmazonConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Alexa Devices events based on a config entry."""
+    coordinator = entry.runtime_data
+
+    known_devices: set[str] = set()
+
+    def _check_device() -> None:
+        current_devices = set(coordinator.data)
+        new_devices = current_devices - known_devices
+        if new_devices:
+            known_devices.update(new_devices)
+            async_add_entities(
+                AlexaVoiceEvent(coordinator, serial_num, event_desc)
+                for event_desc in EVENTS
+                for serial_num in new_devices
+            )
+
+    _check_device()
+    entry.async_on_unload(coordinator.async_add_listener(_check_device))
+
+
+class AlexaVoiceEvent(AmazonEntity, EventEntity):
+    """Representation of an Alexa voice event."""
+
+    _attr_event_types = [EVENT_TYPE]
+    coordinator: AmazonDevicesCoordinator
+    _last_seen_timestamp: int | None = None
+
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Handle updated data from the coordinator."""
+
+        if not (
+            vocal_record := self.coordinator.vocal_records.get(
+                self.device.serial_number
+            )
+        ):
+            _LOGGER.debug(
+                "No vocal record found for device %s [%s]",
+                self.device.account_name,
+                self.device.serial_number,
+            )
+            return
+
+        if vocal_record.timestamp == self._last_seen_timestamp:
+            return
+
+        self._last_seen_timestamp = vocal_record.timestamp
+        self._trigger_event(
+            EVENT_TYPE,
+            {
+                "intent": vocal_record.intent,
+                "voice_command": vocal_record.title,
+                "voice_reply": vocal_record.sub_title,
+            },
+        )
+        self.async_write_ha_state()

homeassistant/components/alexa_devices/icons.json

@@ -1,5 +1,10 @@
 {
   "entity": {
+    "event": {
+      "voice_event": {
+        "default": "mdi:chat-processing"
+      }
+    },
     "sensor": {
       "voc_index": {
         "default": "mdi:molecule"

homeassistant/components/alexa_devices/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["aioamazondevices"],
   "quality_scale": "platinum",
-  "requirements": ["aioamazondevices==13.7.0"]
+  "requirements": ["aioamazondevices==13.8.0"]
 }

homeassistant/components/alexa_devices/media_player.py

@@ -0,0 +1,294 @@
+"""Media player platform for Alexa Devices."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Final
+
+from aioamazondevices.structures import (
+    AmazonMediaControls,
+    AmazonMediaState,
+    AmazonVolumeState,
+)
+
+from homeassistant.components.media_player import (
+    MediaPlayerDeviceClass,
+    MediaPlayerEnqueue,
+    MediaPlayerEntity,
+    MediaPlayerEntityDescription,
+    MediaPlayerEntityFeature,
+    MediaPlayerState,
+    MediaType,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .const import _LOGGER
+from .coordinator import AmazonConfigEntry, AmazonDevicesCoordinator
+from .entity import AmazonEntity
+from .utils import alexa_api_call
+
+PARALLEL_UPDATES = 1
+
+STANDARD_SUPPORTED_FEATURES = (
+    MediaPlayerEntityFeature.VOLUME_SET
+    | MediaPlayerEntityFeature.VOLUME_STEP
+    | MediaPlayerEntityFeature.VOLUME_MUTE
+    | MediaPlayerEntityFeature.STOP
+    | MediaPlayerEntityFeature.PLAY_MEDIA
+)
+
+
+@dataclass(frozen=True, kw_only=True)
+class AmazonDevicesMediaPlayerEntityDescription(MediaPlayerEntityDescription):
+    """Describes an Alexa Devices media player entity."""
+
+
+MEDIA_PLAYERS: Final = (
+    AmazonDevicesMediaPlayerEntityDescription(
+        key="media",
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: AmazonConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Alexa Devices media player entities from a config entry."""
+    coordinator = entry.runtime_data
+
+    known_devices: set[str] = set()
+
+    def _check_device() -> None:
+        """Add entities for newly discovered devices."""
+        new_entities: list[AlexaDevicesMediaPlayer] = []
+
+        for serial_num, device in coordinator.data.items():
+            if serial_num in known_devices or not device.media_player_supported:
+                continue
+
+            known_devices.add(serial_num)
+            new_entities.extend(
+                AlexaDevicesMediaPlayer(coordinator, serial_num, description)
+                for description in MEDIA_PLAYERS
+            )
+
+        if new_entities:
+            async_add_entities(new_entities)
+
+    remove_listener = coordinator.async_add_listener(_check_device)
+    entry.async_on_unload(remove_listener)
+    _check_device()
+
+
+class AlexaDevicesMediaPlayer(AmazonEntity, MediaPlayerEntity):
+    """Representation of an Alexa device media player."""
+
+    entity_description: AmazonDevicesMediaPlayerEntityDescription
+
+    _attr_name = None  # Uses the device name
+    _attr_device_class = MediaPlayerDeviceClass.SPEAKER
+    _attr_volume_step = 0.05
+
+    def __init__(
+        self,
+        coordinator: AmazonDevicesCoordinator,
+        serial_num: str,
+        description: AmazonDevicesMediaPlayerEntityDescription,
+    ) -> None:
+        """Initialize."""
+        self._prev_volume: int | None = None
+        super().__init__(coordinator, serial_num, description)
+
+    @property
+    def media_state(self) -> AmazonMediaState | None:
+        """Return the media state relating to device."""
+        if not self.coordinator or not self.coordinator.media_states:
+            return None
+        return self.coordinator.media_states.get(self._serial_num)
+
+    @property
+    def volume_state(self) -> AmazonVolumeState | None:
+        """Volume settings for device."""
+        if not self.coordinator or not self.coordinator.volume_states:
+            return None
+        return self.coordinator.volume_states.get(self._serial_num)
+
+    @property
+    def supported_features(self) -> MediaPlayerEntityFeature:
+        """Return dynamically supported features based on current media."""
+        features = STANDARD_SUPPORTED_FEATURES
+
+        if self.media_state is None:
+            return features
+
+        if self.media_state.pause_enabled:
+            features |= MediaPlayerEntityFeature.PLAY | MediaPlayerEntityFeature.PAUSE
+
+        if self.media_state.next_enabled:
+            features |= MediaPlayerEntityFeature.NEXT_TRACK
+
+        if self.media_state.previous_enabled:
+            features |= MediaPlayerEntityFeature.PREVIOUS_TRACK
+
+        return features
+
+    @property
+    def state(self) -> MediaPlayerState | None:
+        """Return the current state of the player."""
+        if not self.media_state:
+            return MediaPlayerState.IDLE
+        if self.media_state.player_state == "PLAYING":
+            return MediaPlayerState.PLAYING
+        if self.media_state.player_state == "PAUSED":
+            return MediaPlayerState.PAUSED
+
+        return MediaPlayerState.IDLE
+
+    @property
+    def volume_level(self) -> float | None:
+        """Return the volume level (0.0 to 1.0)."""
+        if not self.volume_state or self.volume_state.volume is None:
+            return None
+        return self.volume_state.volume / 100
+
+    @property
+    def is_volume_muted(self) -> bool | None:
+        """Return True if the volume is muted."""
+        if not self.volume_state:
+            return None
+        return self.volume_state.volume == 0
+
+    @property
+    def media_title(self) -> str | None:
+        """Track title."""
+        if not self.media_state:
+            return None
+        return self.media_state.now_playing_title
+
+    @property
+    def media_artist(self) -> str | None:
+        """Artist name."""
+        if not self.media_state:
+            return None
+        return self.media_state.now_playing_line1
+
+    @property
+    def media_album_name(self) -> str | None:
+        """Album name."""
+        if not self.media_state:
+            return None
+        return self.media_state.now_playing_line2
+
+    @property
+    def media_image_url(self) -> str | None:
+        """Album art URL."""
+        if not self.media_state:
+            return None
+        return self.media_state.now_playing_url
+
+    @property
+    def media_duration(self) -> int | None:
+        """Duration in seconds."""
+        if not self.media_state:
+            return None
+        return self.media_state.media_length
+
+    @property
+    def media_position(self) -> int | None:
+        """Current playback position in seconds."""
+        if not self.media_state:
+            return None
+        return self.media_state.media_position
+
+    @property
+    def media_position_updated_at(self) -> datetime | None:
+        """When media_position was last updated — HA uses this to interpolate the progress bar."""
+        if not self.media_state:
+            return None
+        return self.media_state.media_position_updated_at
+
+    @property
+    def media_content_type(self) -> MediaType | None:
+        """Content type — tells HA what kind of media is playing."""
+        if self.state in [MediaPlayerState.PLAYING, MediaPlayerState.PAUSED]:
+            return MediaType.MUSIC
+        return None
+
+    async def async_play_media(
+        self,
+        media_type: MediaType | str,
+        media_id: str,
+        enqueue: MediaPlayerEnqueue | None = None,
+        announce: bool | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Play a piece of media."""
+        await self.async_call_alexa_music(media_id, media_type)
+
+    @alexa_api_call
+    async def async_call_alexa_music(
+        self, search_phrase: str, provider_id: str
+    ) -> None:
+        """Call alexa music."""
+        await self.coordinator.api.call_alexa_music(
+            self.device, search_phrase, provider_id
+        )
+
+    @alexa_api_call
+    async def async_set_device_volume(self, volume: int) -> None:
+        """Set the device volume."""
+        _LOGGER.debug(
+            "Setting volume for %s to %s%%",
+            self.device.serial_number,
+            volume,
+        )
+        await self.coordinator.api.set_device_volume(self.device, volume)
+
+    async def async_set_volume_level(self, volume: float) -> None:
+        """Set the volume level (0.0 to 1.0)."""
+        device_volume = round(volume * 100)
+        await self.async_set_device_volume(device_volume)
+
+    async def async_mute_volume(self, mute: bool) -> None:
+        """Mute or un-mute the volume."""
+        # Whilst you can mute a device by asking it there appears to be
+        # no way to do this programmatically so set volume to 0
+        if not self.volume_state or self.volume_state.volume is None:
+            return
+        if mute:
+            self._prev_volume = self.volume_state.volume
+            target_volume = 0
+        else:
+            if self._prev_volume is None:
+                return
+            target_volume = self._prev_volume
+        await self.async_set_volume_level(target_volume / 100)
+
+    @alexa_api_call
+    async def _send_media_command(self, command: AmazonMediaControls) -> None:
+        _LOGGER.debug(
+            "Sending media command '%s' to %s", command, self.device.serial_number
+        )
+        await self.coordinator.api.send_media_command(self.device, command)
+
+    async def async_media_stop(self) -> None:
+        """Send stop command."""
+        await self._send_media_command(AmazonMediaControls.Stop)
+
+    async def async_media_pause(self) -> None:
+        """Send pause command."""
+        await self._send_media_command(AmazonMediaControls.Pause)
+
+    async def async_media_play(self) -> None:
+        """Send play command."""
+        await self._send_media_command(AmazonMediaControls.Play)
+
+    async def async_media_next_track(self) -> None:
+        """Send next track command."""
+        await self._send_media_command(AmazonMediaControls.Next)
+
+    async def async_media_previous_track(self) -> None:
+        """Send previous track command."""
+        await self._send_media_command(AmazonMediaControls.Previous)

homeassistant/components/alexa_devices/strings.json

@@ -58,6 +58,18 @@
     }
   },
   "entity": {
+    "event": {
+      "voice_event": {
+        "name": "Voice event",
+        "state_attributes": {
+          "event_type": {
+            "state": {
+              "triggered": "Triggered"
+            }
+          }
+        }
+      }
+    },
     "notify": {
       "announce": {
         "name": "Announce"

homeassistant/components/anthropic/__init__.py

@@ -230,13 +230,13 @@ async def async_migrate_entry(hass: HomeAssistant, entry: AnthropicConfigEntry)
 
     if entry.version == 2 and entry.minor_version == 3:
         # Remove Temperature parameter
-        CONF_TEMPERATURE = "temperature"
+        temperature_key = "temperature"
 
         for subentry in entry.subentries.values():
             data = subentry.data.copy()
-            if CONF_TEMPERATURE not in data:
+            if temperature_key not in data:
                 continue
-            data.pop(CONF_TEMPERATURE, None)
+            data.pop(temperature_key, None)
             hass.config_entries.async_update_subentry(entry, subentry, data=data)
 
         hass.config_entries.async_update_entry(entry, minor_version=4)

homeassistant/components/apcupsd/const.py

@@ -7,27 +7,3 @@ CONNECTION_TIMEOUT: int = 10
 
 # Field name of last self test retrieved from apcupsd.
 LAST_S_TEST: Final = "laststest"
-
-# Mapping of deprecated sensor keys (as reported by apcupsd,
-# lower-cased) to their deprecation
-# repair issue translation keys.
-DEPRECATED_SENSORS: Final = {
-    "apc": "apc_deprecated",
-    "end apc": "date_deprecated",
-    "date": "date_deprecated",
-    "apcmodel": "available_via_device_info",
-    "model": "available_via_device_info",
-    "firmware": "available_via_device_info",
-    "version": "available_via_device_info",
-    "upsname": "available_via_device_info",
-    "serialno": "available_via_device_info",
-}
-
-AVAILABLE_VIA_DEVICE_ATTR: Final = {
-    "apcmodel": "model",
-    "model": "model",
-    "firmware": "hw_version",
-    "version": "sw_version",
-    "upsname": "name",
-    "serialno": "serial_number",
-}

homeassistant/components/apcupsd/sensor.py

@@ -1,11 +1,10 @@
 """Support for APCUPSd sensors."""
 
 import logging
+from typing import Final
 
 import dateutil
 
-from homeassistant.components.automation import automations_with_entity
-from homeassistant.components.script import scripts_with_entity
 from homeassistant.components.sensor import (
     SensorDeviceClass,
     SensorEntity,
@@ -24,11 +23,9 @@ from homeassistant.const import (
     UnitOfTime,
 )
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-import homeassistant.helpers.issue_registry as ir
 
-from .const import AVAILABLE_VIA_DEVICE_ATTR, DEPRECATED_SENSORS, DOMAIN, LAST_S_TEST
+from .const import LAST_S_TEST
 from .coordinator import APCUPSdConfigEntry, APCUPSdCoordinator
 from .entity import APCUPSdEntity
 
@@ -36,6 +33,20 @@ PARALLEL_UPDATES = 0
 
 _LOGGER = logging.getLogger(__name__)
 
+# List of useless sensors to ignore, since they are either provided in device
+# information, or not useful at all
+IGNORED_SENSORS: Final = {
+    "apc",
+    "end apc",
+    "date",
+    "apcmodel",
+    "model",
+    "firmware",
+    "version",
+    "upsname",
+    "serialno",
+}
+
 SENSORS: dict[str, SensorEntityDescription] = {
     "alarmdel": SensorEntityDescription(
         key="alarmdel",
@@ -49,18 +60,6 @@ SENSORS: dict[str, SensorEntityDescription] = {
         device_class=SensorDeviceClass.TEMPERATURE,
         state_class=SensorStateClass.MEASUREMENT,
     ),
-    "apc": SensorEntityDescription(
-        key="apc",
-        translation_key="apc_status",
-        entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
-    "apcmodel": SensorEntityDescription(
-        key="apcmodel",
-        translation_key="apc_model",
-        entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
     "badbatts": SensorEntityDescription(
         key="badbatts",
         translation_key="bad_batteries",
@@ -100,12 +99,6 @@ SENSORS: dict[str, SensorEntityDescription] = {
         state_class=SensorStateClass.TOTAL_INCREASING,
         device_class=SensorDeviceClass.DURATION,
     ),
-    "date": SensorEntityDescription(
-        key="date",
-        translation_key="date",
-        entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
     "dipsw": SensorEntityDescription(
         key="dipsw",
         translation_key="dip_switch_settings",
@@ -132,23 +125,11 @@ SENSORS: dict[str, SensorEntityDescription] = {
         translation_key="wake_delay",
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
-    "end apc": SensorEntityDescription(
-        key="end apc",
-        translation_key="date_and_time",
-        entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
     "extbatts": SensorEntityDescription(
         key="extbatts",
         translation_key="external_batteries",
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
-    "firmware": SensorEntityDescription(
-        key="firmware",
-        translation_key="firmware_version",
-        entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
     "hitrans": SensorEntityDescription(
         key="hitrans",
         translation_key="transfer_high",
@@ -264,12 +245,6 @@ SENSORS: dict[str, SensorEntityDescription] = {
         translation_key="min_time",
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
-    "model": SensorEntityDescription(
-        key="model",
-        translation_key="model",
-        entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
     "nombattv": SensorEntityDescription(
         key="nombattv",
         translation_key="battery_nominal_voltage",
@@ -358,12 +333,6 @@ SENSORS: dict[str, SensorEntityDescription] = {
         entity_registry_enabled_default=False,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
-    "serialno": SensorEntityDescription(
-        key="serialno",
-        translation_key="serial_number",
-        entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
     "starttime": SensorEntityDescription(
         key="starttime",
         translation_key="startup_time",
@@ -404,18 +373,6 @@ SENSORS: dict[str, SensorEntityDescription] = {
         translation_key="ups_mode",
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
-    "upsname": SensorEntityDescription(
-        key="upsname",
-        translation_key="ups_name",
-        entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
-    "version": SensorEntityDescription(
-        key="version",
-        translation_key="version",
-        entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
     "xoffbat": SensorEntityDescription(
         key="xoffbat",
         translation_key="transfer_from_battery",
@@ -481,9 +438,10 @@ async def async_setup_entry(
     # as unknown initially.
     #
     # We also sort the resources to ensure the order of entities
-    # created is deterministic since "APCMODEL" and "MODEL"
-    # resources map to the same "Model" name.
+    # created is deterministic
     for resource in sorted(available_resources | {LAST_S_TEST}):
+        if resource in IGNORED_SENSORS:
+            continue
         if resource not in SENSORS:
             _LOGGER.warning("Invalid resource from APCUPSd: %s", resource.upper())
             continue
@@ -561,63 +519,3 @@ class APCUPSdSensor(APCUPSdEntity, SensorEntity):
         self._attr_native_value, inferred_unit = infer_unit(data)
         if not self.native_unit_of_measurement:
             self._attr_native_unit_of_measurement = inferred_unit
-
-    async def async_added_to_hass(self) -> None:
-        """Handle when entity is added to Home Assistant.
-
-        If this is a deprecated sensor entity, create a repair issue to guide
-        the user to disable it.
-        """
-        await super().async_added_to_hass()
-
-        if not self.enabled:
-            return
-
-        reason = DEPRECATED_SENSORS.get(self.entity_description.key)
-        if not reason:
-            return
-
-        automations = automations_with_entity(self.hass, self.entity_id)
-        scripts = scripts_with_entity(self.hass, self.entity_id)
-        if not automations and not scripts:
-            return
-
-        entity_registry = er.async_get(self.hass)
-        items = [
-            f"- [{entry.name or entry.original_name or entity_id}]"
-            f"(/config/{integration}/edit/"
-            f"{entry.unique_id or entity_id.split('.', 1)[-1]})"
-            for integration, entities in (
-                ("automation", automations),
-                ("script", scripts),
-            )
-            for entity_id in entities
-            if (entry := entity_registry.async_get(entity_id))
-        ]
-        placeholders = {
-            "entity_name": str(self.name or self.entity_id),
-            "entity_id": self.entity_id,
-            "items": "\n".join(items),
-        }
-        if via_attr := AVAILABLE_VIA_DEVICE_ATTR.get(self.entity_description.key):
-            placeholders["available_via_device_attr"] = via_attr
-        if device_entry := self.device_entry:
-            placeholders["device_id"] = device_entry.id
-
-        ir.async_create_issue(
-            self.hass,
-            DOMAIN,
-            f"{reason}_{self.entity_id}",
-            breaks_in_ha_version="2026.6.0",
-            is_fixable=False,
-            severity=ir.IssueSeverity.WARNING,
-            translation_key=reason,
-            translation_placeholders=placeholders,
-        )
-
-    async def async_will_remove_from_hass(self) -> None:
-        """Handle when entity will be removed from Home Assistant."""
-        await super().async_will_remove_from_hass()
-
-        if issue_key := DEPRECATED_SENSORS.get(self.entity_description.key):
-            ir.async_delete_issue(self.hass, DOMAIN, f"{issue_key}_{self.entity_id}")

homeassistant/components/apcupsd/strings.json

@@ -241,19 +241,5 @@
     "cannot_connect": {
       "message": "Cannot connect to APC UPS Daemon."
     }
-  },
-  "issues": {
-    "apc_deprecated": {
-      "description": "The {entity_name} sensor (`{entity_id}`) is deprecated because it exposes internal details of the APC UPS Daemon response.\n\nIt is still referenced in the following automations or scripts:\n{items}\n\nUpdate those automations or scripts to use supported APC UPS entities instead. Reload the APC UPS Daemon integration afterwards to resolve this issue.",
-      "title": "{entity_name} sensor is deprecated"
-    },
-    "available_via_device_info": {
-      "description": "The {entity_name} sensor (`{entity_id}`) is deprecated because the same value is available from the device registry via `device_attr(\"{device_id}\", \"{available_via_device_attr}\")`.\n\nIt is still referenced in the following automations or scripts:\n{items}\n\nUpdate those automations or scripts to use the `device_attr` helper instead of this sensor. Reload the APC UPS Daemon integration afterwards to resolve this issue.",
-      "title": "{entity_name} sensor is deprecated"
-    },
-    "date_deprecated": {
-      "description": "The {entity_name} sensor (`{entity_id}`) is deprecated because the timestamp is already available from other APC UPS sensors via their last updated time.\n\nIt is still referenced in the following automations or scripts:\n{items}\n\nUpdate those automations or scripts to reference any entity's `last_updated` attribute instead (for example, `states.binary_sensor.apcups_online_status.last_updated`). Reload the APC UPS Daemon integration afterwards to resolve this issue.",
-      "title": "{entity_name} sensor is deprecated"
-    }
   }
 }

homeassistant/components/aranet/sensor.py

@@ -193,7 +193,11 @@ async def async_setup_entry(
             Aranet4BluetoothSensorEntity, async_add_entities
         )
     )
-    entry.async_on_unload(entry.runtime_data.async_register_processor(processor))
+    entry.async_on_unload(
+        entry.runtime_data.async_register_processor(
+            processor, AranetSensorEntityDescription
+        )
+    )
 
 
 class Aranet4BluetoothSensorEntity(

homeassistant/components/assist_satellite/triggers.yaml

@@ -5,7 +5,7 @@
   fields:
     behavior:
       required: true
-      default: any
+      default: each
       selector:
         automation_behavior:
           mode: trigger

homeassistant/components/asuswrt/router.py

@@ -49,6 +49,20 @@ SENSORS_TYPE_COUNT = "sensors_count"
 
 _LOGGER = logging.getLogger(__name__)
 
+_ENTITY_MIGRATION_ID = {
+    "sensor_connected_device": "Devices Connected",
+    "sensor_rx_bytes": "Download",
+    "sensor_tx_bytes": "Upload",
+    "sensor_rx_rates": "Download Speed",
+    "sensor_tx_rates": "Upload Speed",
+    "sensor_load_avg1": "Load Avg (1m)",
+    "sensor_load_avg5": "Load Avg (5m)",
+    "sensor_load_avg15": "Load Avg (15m)",
+    "2.4GHz": "2.4GHz Temperature",
+    "5.0GHz": "5GHz Temperature",
+    "CPU": "CPU Temperature",
+}
+
 
 class AsusWrtSensorDataHandler:
     """Data handler for AsusWrt sensor."""
@@ -187,20 +201,6 @@ class AsusWrtRouter:
 
     def _migrate_entities_unique_id(self) -> None:
         """Migrate router entities to new unique id format."""
-        _ENTITY_MIGRATION_ID = {
-            "sensor_connected_device": "Devices Connected",
-            "sensor_rx_bytes": "Download",
-            "sensor_tx_bytes": "Upload",
-            "sensor_rx_rates": "Download Speed",
-            "sensor_tx_rates": "Upload Speed",
-            "sensor_load_avg1": "Load Avg (1m)",
-            "sensor_load_avg5": "Load Avg (5m)",
-            "sensor_load_avg15": "Load Avg (15m)",
-            "2.4GHz": "2.4GHz Temperature",
-            "5.0GHz": "5GHz Temperature",
-            "CPU": "CPU Temperature",
-        }
-
         entity_reg = er.async_get(self.hass)
         router_entries = er.async_entries_for_config_entry(
             entity_reg, self._entry.entry_id

homeassistant/components/avea/light.py

@@ -1,5 +1,6 @@
 """Light platform for Avea."""
 
+from collections.abc import Callable
 from contextlib import suppress
 import logging
 from typing import Any
@@ -19,6 +20,7 @@ from homeassistant.core import DOMAIN as HOMEASSISTANT_DOMAIN, HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
 from homeassistant.exceptions import PlatformNotReady
 from homeassistant.helpers import issue_registry as ir
+from homeassistant.helpers.device_registry import CONNECTION_BLUETOOTH, DeviceInfo
 from homeassistant.helpers.entity_platform import (
     AddConfigEntryEntitiesCallback,
     AddEntitiesCallback,
@@ -27,7 +29,7 @@ from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 from homeassistant.util import color as color_util
 
 from . import AveaConfigEntry
-from .const import DOMAIN, INTEGRATION_TITLE, UNKNOWN_NAME
+from .const import DOMAIN, INTEGRATION_TITLE, MODEL, UNKNOWN_NAME
 
 _LOGGER = logging.getLogger(__name__)
 UPDATE_EXCEPTIONS = (BleakError, OSError, RuntimeError)
@@ -42,6 +44,13 @@ def _normalize_name(name: str | None) -> str | None:
     return name
 
 
+def _read_device_info_value(read: Callable[[], str | None]) -> str | None:
+    """Read a device information value from an Avea bulb."""
+    with suppress(*UPDATE_EXCEPTIONS):
+        return _normalize_name(read())
+    return None
+
+
 def _ha_brightness_to_avea(brightness: int) -> int:
     """Convert Home Assistant brightness to Avea brightness."""
     return round((brightness / 255) * AVEA_MAX_BRIGHTNESS)
@@ -96,7 +105,8 @@ async def async_setup_entry(
 ) -> None:
     """Set up the Avea light platform."""
     async_add_entities(
-        [AveaLight(entry.runtime_data, entry.title)], update_before_add=True
+        [AveaLight(entry.runtime_data, entry.data[CONF_ADDRESS])],
+        update_before_add=True,
     )
 
 
@@ -180,14 +190,42 @@ class AveaLight(LightEntity):
     """Representation of an Avea."""
 
     _attr_color_mode = ColorMode.HS
+    _attr_has_entity_name = True
+    _attr_name = None
     _attr_supported_color_modes = {ColorMode.HS}
 
-    def __init__(self, light: avea.Bulb, entry_title: str) -> None:
+    def __init__(self, light: avea.Bulb, address: str) -> None:
         """Initialize an AveaLight."""
         self._light = light
-        self._attr_name = entry_title
+        self._attr_unique_id = address
         self._attr_brightness = light.brightness
         self._last_brightness = 255
+        self._device_info_updated = False
+        self._attr_device_info = DeviceInfo(
+            connections={(CONNECTION_BLUETOOTH, address)},
+            model=MODEL,
+        )
+
+    def _update_device_info(self) -> None:
+        """Fetch device information from the Avea bulb."""
+        device_info = self._attr_device_info
+        assert device_info is not None
+
+        manufacturer = _read_device_info_value(self._light.get_manufacturer_name)
+        hardware_revision = _read_device_info_value(self._light.get_hardware_revision)
+        firmware_version = _read_device_info_value(self._light.get_fw_version)
+        serial_number = _read_device_info_value(self._light.get_serial_number)
+
+        if manufacturer:
+            device_info["manufacturer"] = manufacturer
+        if hardware_revision:
+            device_info["hw_version"] = hardware_revision
+        if firmware_version:
+            device_info["sw_version"] = firmware_version
+        if serial_number:
+            device_info["serial_number"] = serial_number
+
+        self._device_info_updated = True
 
     def turn_on(self, **kwargs: Any) -> None:
         """Instruct the light to turn on."""
@@ -214,6 +252,8 @@ class AveaLight(LightEntity):
         connected = self._light.connect()
 
         try:
+            if not self._device_info_updated:
+                self._update_device_info()
             brightness = self._light.get_brightness()
             rgb_color = self._light.get_rgb()
         finally:

homeassistant/components/aws_s3/__init__.py

@@ -51,7 +51,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: S3ConfigEntry) -> bool:
                 translation_key="invalid_bucket_name",
             ) from err
     except ValueError as err:
-        # pylint: disable-next=home-assistant-exception-translation-key-missing
         raise ConfigEntryError(
             translation_domain=DOMAIN,
             translation_key="invalid_endpoint_url",

homeassistant/components/aws_s3/strings.json

@@ -7,7 +7,7 @@
       "cannot_connect": "[%key:component::aws_s3::exceptions::cannot_connect::message%]",
       "invalid_bucket_name": "[%key:component::aws_s3::exceptions::invalid_bucket_name::message%]",
       "invalid_credentials": "[%key:component::aws_s3::exceptions::invalid_credentials::message%]",
-      "invalid_endpoint_url": "Invalid endpoint URL. Please make sure it's a valid AWS S3 endpoint URL."
+      "invalid_endpoint_url": "[%key:component::aws_s3::exceptions::invalid_endpoint_url::message%]"
     },
     "step": {
       "user": {
@@ -48,6 +48,9 @@
     },
     "invalid_credentials": {
       "message": "Bucket cannot be accessed using provided combination of access key ID and secret access key."
+    },
+    "invalid_endpoint_url": {
+      "message": "Invalid endpoint URL. Please make sure it's a valid AWS S3 endpoint URL."
     }
   }
 }

homeassistant/components/axis/config_flow.py

@@ -2,7 +2,7 @@
 
 from collections.abc import Mapping
 from ipaddress import ip_address
-from typing import Any
+from typing import TYPE_CHECKING, Any
 from urllib.parse import urlsplit
 
 import voluptuous as vol
@@ -49,6 +49,9 @@ from .const import (
 from .errors import AuthenticationRequired, CannotConnect
 from .hub import AxisHub, get_axis_api
 
+if TYPE_CHECKING:
+    import axis
+
 AXIS_OUI = {"00:40:8c", "ac:cc:8e", "b8:a4:4f", "e8:27:25"}
 DEFAULT_PORT = 443
 DEFAULT_PROTOCOL = "https"
@@ -93,7 +96,8 @@ class AxisFlowHandler(ConfigFlow, domain=DOMAIN):
                 errors["base"] = "cannot_connect"
 
             else:
-                serial = api.vapix.serial_number
+                if (serial := self._get_serial_number(api)) is None:
+                    return self.async_abort(reason="no_serial_number")
                 config = {
                     CONF_PROTOCOL: user_input[CONF_PROTOCOL],
                     CONF_HOST: user_input[CONF_HOST],
@@ -258,6 +262,19 @@ class AxisFlowHandler(ConfigFlow, domain=DOMAIN):
 
         return await self.async_step_user()
 
+    @staticmethod
+    def _get_serial_number(api: axis.AxisDevice) -> str | None:
+        """Retrieve the device serial number from the Axis API.
+
+        Tries basic_device_info first, then property_handler. Returns None if not found.
+        """
+        vapix = api.vapix
+        if vapix.basic_device_info.initialized:
+            return vapix.basic_device_info["0"].serial_number
+        if vapix.params.property_handler.initialized:
+            return vapix.params.property_handler["0"].system_serial_number
+        return None
+
 
 class AxisOptionsFlowHandler(OptionsFlow):
     """Handle Axis device options."""

homeassistant/components/axis/strings.json

@@ -3,6 +3,7 @@
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
       "link_local_address": "Link local addresses are not supported",
+      "no_serial_number": "Could not retrieve a serial number from the device. Please check device connectivity and try again.",
       "not_axis_device": "Discovered device not an Axis device",
       "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
       "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",

homeassistant/components/battery/triggers.yaml

@@ -1,7 +1,7 @@
 .trigger_common_fields:
   behavior: &trigger_behavior
     required: true
-    default: any
+    default: each
     selector:
       automation_behavior:
         mode: trigger

homeassistant/components/blebox/__init__.py

@@ -32,6 +32,7 @@ PLATFORMS = [
     Platform.LIGHT,
     Platform.SENSOR,
     Platform.SWITCH,
+    Platform.UPDATE,
 ]
 
 PARALLEL_UPDATES = 0

homeassistant/components/blebox/cover.py

@@ -3,7 +3,7 @@
 from typing import Any
 
 import blebox_uniapi.cover
-from blebox_uniapi.cover import BleboxCoverState
+from blebox_uniapi.cover import BleboxCoverState, UnifiedCoverType
 
 from homeassistant.components.cover import (
     ATTR_POSITION,
@@ -25,6 +25,19 @@ BLEBOX_TO_COVER_DEVICE_CLASSES = {
     "shutter": CoverDeviceClass.SHUTTER,
 }
 
+UNIFIED_COVER_TYPE_TO_DEVICE_CLASS = {
+    UnifiedCoverType.AWNING: CoverDeviceClass.AWNING,
+    UnifiedCoverType.BLIND: CoverDeviceClass.BLIND,
+    UnifiedCoverType.CURTAIN: CoverDeviceClass.CURTAIN,
+    UnifiedCoverType.DAMPER: CoverDeviceClass.DAMPER,
+    UnifiedCoverType.DOOR: CoverDeviceClass.DOOR,
+    UnifiedCoverType.GARAGE: CoverDeviceClass.GARAGE,
+    UnifiedCoverType.GATE: CoverDeviceClass.GATE,
+    UnifiedCoverType.SHADE: CoverDeviceClass.SHADE,
+    UnifiedCoverType.SHUTTER: CoverDeviceClass.SHUTTER,
+    UnifiedCoverType.WINDOW: CoverDeviceClass.WINDOW,
+}
+
 BLEBOX_TO_HASS_COVER_STATES = {
     None: None,
     # all blebox covers
@@ -59,7 +72,6 @@ class BleBoxCoverEntity(BleBoxEntity[blebox_uniapi.cover.Cover], CoverEntity):
     def __init__(self, feature: blebox_uniapi.cover.Cover) -> None:
         """Initialize a BleBox cover feature."""
         super().__init__(feature)
-        self._attr_device_class = BLEBOX_TO_COVER_DEVICE_CLASSES[feature.device_class]
         self._attr_supported_features = (
             CoverEntityFeature.OPEN | CoverEntityFeature.CLOSE
         )
@@ -76,6 +88,21 @@ class BleBoxCoverEntity(BleBoxEntity[blebox_uniapi.cover.Cover], CoverEntity):
                 | CoverEntityFeature.CLOSE_TILT
             )
 
+        if feature.tilt_only:
+            self._attr_supported_features &= ~(
+                CoverEntityFeature.OPEN
+                | CoverEntityFeature.CLOSE
+                | CoverEntityFeature.SET_POSITION
+                | CoverEntityFeature.STOP
+            )
+
+    @property
+    def device_class(self) -> CoverDeviceClass | None:
+        """Return the device class based on cover type when available."""
+        if (cover_type := self._feature.cover_type) is not None:
+            return UNIFIED_COVER_TYPE_TO_DEVICE_CLASS[cover_type]
+        return BLEBOX_TO_COVER_DEVICE_CLASSES[self._feature.device_class]
+
     @property
     def current_cover_position(self) -> int | None:
         """Return the current cover position."""
@@ -118,7 +145,8 @@ class BleBoxCoverEntity(BleBoxEntity[blebox_uniapi.cover.Cover], CoverEntity):
 
     async def async_open_cover_tilt(self, **kwargs: Any) -> None:
         """Fully open the cover tilt."""
-        await self._feature.async_set_tilt_position(0)
+        position = 50 if self._feature.is_tilt_180 else 0
+        await self._feature.async_set_tilt_position(position)
 
     async def async_close_cover_tilt(self, **kwargs: Any) -> None:
         """Fully close the cover tilt."""

homeassistant/components/blebox/manifest.json

@@ -7,6 +7,6 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["blebox_uniapi"],
-  "requirements": ["blebox-uniapi==2.5.3"],
+  "requirements": ["blebox-uniapi==2.5.4"],
   "zeroconf": ["_bbxsrv._tcp.local."]
 }

homeassistant/components/blebox/update.py

@@ -0,0 +1,141 @@
+"""BleBox update entities implementation."""
+
+from datetime import timedelta
+from typing import Any, Final
+
+from blebox_uniapi.error import ConnectionError as BleBoxConnectionError, Error
+import blebox_uniapi.update
+
+from homeassistant.components.update import (
+    UpdateDeviceClass,
+    UpdateEntity,
+    UpdateEntityFeature,
+)
+from homeassistant.core import CALLBACK_TYPE, HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.event import async_call_later
+
+from . import BleBoxConfigEntry
+from .entity import BleBoxEntity
+
+SCAN_INTERVAL = timedelta(hours=1)
+
+
+_POLL_INTERVAL_SECONDS: Final = 10
+_MAX_POLL_ATTEMPTS: Final = 30
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: BleBoxConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up a BleBox update entry."""
+    entities = [
+        BleBoxUpdateEntity(feature)
+        for feature in config_entry.runtime_data.features.get("updates", [])
+    ]
+    async_add_entities(entities, True)
+
+
+class BleBoxUpdateEntity(BleBoxEntity[blebox_uniapi.update.Update], UpdateEntity):
+    """Representation of BleBox updates."""
+
+    _attr_device_class = UpdateDeviceClass.FIRMWARE
+    _attr_supported_features = (
+        UpdateEntityFeature.INSTALL | UpdateEntityFeature.PROGRESS
+    )
+
+    def __init__(self, feature: blebox_uniapi.update.Update) -> None:
+        """Initialize the update entity."""
+        super().__init__(feature)
+        self._in_progress_old_version: str | None = None
+        self._poll_cancel: CALLBACK_TYPE | None = None
+        self._poll_attempts: int = 0
+
+    @property
+    def in_progress(self) -> bool:
+        """Return True while the device hasn't yet rebooted to the new firmware."""
+        return (
+            self._in_progress_old_version is not None
+            and self._in_progress_old_version == self._feature.installed_version
+        )
+
+    def _sync_sw_version(self) -> None:
+        """Sync installed firmware version to the device registry."""
+        if self.device_entry:
+            dr.async_get(self.hass).async_update_device(
+                self.device_entry.id,
+                sw_version=self._feature.installed_version,
+            )
+
+    async def async_update(self) -> None:
+        """Update state and refresh sw_version in device registry."""
+        try:
+            await self._feature.async_update()
+        except Error as ex:
+            raise HomeAssistantError(ex) from ex
+        self._sync_sw_version()
+
+    @property
+    def installed_version(self) -> str | None:
+        """Version installed and in use."""
+        return self._feature.installed_version
+
+    @property
+    def latest_version(self) -> str | None:
+        """Latest version available for install."""
+        return self._feature.latest_version
+
+    def _cancel_poll(self) -> None:
+        if self._poll_cancel is not None:
+            self._poll_cancel()
+            self._poll_cancel = None
+
+    def _reset_progress(self) -> None:
+        self._in_progress_old_version = None
+        self._poll_attempts = 0
+        self.async_write_ha_state()
+
+    async def async_install(
+        self, version: str | None, backup: bool, **kwargs: Any
+    ) -> None:
+        """Install an update."""
+        self._cancel_poll()
+        self._in_progress_old_version = self._feature.installed_version
+        self._poll_attempts = 0
+        self.async_write_ha_state()
+        try:
+            await self._feature.async_install()
+        except Error as ex:
+            self._reset_progress()
+            raise HomeAssistantError(ex) from ex
+        self._poll_cancel = async_call_later(
+            self.hass, _POLL_INTERVAL_SECONDS, self._poll_until_updated
+        )
+
+    async def async_will_remove_from_hass(self) -> None:
+        """Cancel any pending poll timer when the entity is removed."""
+        self._cancel_poll()
+
+    async def _poll_until_updated(self, _now: Any) -> None:
+        """Poll device until the installed version changes after OTA reboot."""
+        self._poll_cancel = None
+        self._poll_attempts += 1
+        try:
+            await self._feature.async_update()
+        except BleBoxConnectionError:
+            pass
+        except Error:
+            self._reset_progress()
+            return
+        else:
+            self._sync_sw_version()
+        if self.in_progress and self._poll_attempts < _MAX_POLL_ATTEMPTS:
+            self._poll_cancel = async_call_later(
+                self.hass, _POLL_INTERVAL_SECONDS, self._poll_until_updated
+            )
+        else:
+            self._reset_progress()

homeassistant/components/bluemaestro/sensor.py

@@ -124,7 +124,9 @@ async def async_setup_entry(
             BlueMaestroBluetoothSensorEntity, async_add_entities
         )
     )
-    entry.async_on_unload(coordinator.async_register_processor(processor))
+    entry.async_on_unload(
+        coordinator.async_register_processor(processor, SensorEntityDescription)
+    )
 
 
 class BlueMaestroBluetoothSensorEntity(

homeassistant/components/bluetooth/config_flow.py

@@ -22,6 +22,7 @@ from homeassistant.config_entries import (
     ConfigFlowResult,
     OptionsFlow,
 )
+from homeassistant.const import CONF_SOURCE
 from homeassistant.core import callback
 from homeassistant.helpers.schema_config_entry_flow import (
     SchemaCommonFlowHandler,
@@ -40,7 +41,6 @@ from .const import (
     CONF_DETAILS,
     CONF_MODE,
     CONF_PASSIVE,
-    CONF_SOURCE,
     CONF_SOURCE_CONFIG_ENTRY_ID,
     CONF_SOURCE_DEVICE_ID,
     CONF_SOURCE_DOMAIN,

homeassistant/components/bluetooth/const.py

@@ -22,9 +22,6 @@ CONF_PASSIVE = "passive"
 
 DEFAULT_MODE = BluetoothScanningMode.AUTO.value
 
-
-# pylint: disable-next=home-assistant-duplicate-const
-CONF_SOURCE: Final = "source"
 CONF_SOURCE_DOMAIN: Final = "source_domain"
 CONF_SOURCE_MODEL: Final = "source_model"
 CONF_SOURCE_CONFIG_ENTRY_ID: Final = "source_config_entry_id"

homeassistant/components/bluetooth/manager.py

@@ -21,7 +21,11 @@ from habluetooth import (
 )
 
 from homeassistant import config_entries
-from homeassistant.const import EVENT_HOMEASSISTANT_STOP, EVENT_LOGGING_CHANGED
+from homeassistant.const import (
+    CONF_SOURCE,
+    EVENT_HOMEASSISTANT_STOP,
+    EVENT_LOGGING_CHANGED,
+)
 from homeassistant.core import (
     CALLBACK_TYPE,
     Event,
@@ -33,7 +37,6 @@ from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.util.package import is_docker_env
 
 from .const import (
-    CONF_SOURCE,
     CONF_SOURCE_CONFIG_ENTRY_ID,
     CONF_SOURCE_DEVICE_ID,
     CONF_SOURCE_DOMAIN,

homeassistant/components/bluetooth/manifest.json

@@ -17,10 +17,10 @@
   "requirements": [
     "bleak==3.0.2",
     "bleak-retry-connector==4.6.1",
-    "bluetooth-adapters==2.1.0",
+    "bluetooth-adapters==2.3.0",
     "bluetooth-auto-recovery==1.6.4",
     "bluetooth-data-tools==1.29.18",
-    "dbus-fast==5.0.9",
-    "habluetooth==6.7.3"
+    "dbus-fast==5.0.15",
+    "habluetooth==6.7.9"
   ]
 }

homeassistant/components/bthome/const.py

@@ -17,6 +17,7 @@ BTHOME_BLE_EVENT: Final = "bthome_ble_event"
 
 EVENT_CLASS_BUTTON: Final = "button"
 EVENT_CLASS_DIMMER: Final = "dimmer"
+EVENT_CLASS_COMMAND: Final = "command"
 
 CONF_EVENT_CLASS: Final = "event_class"
 CONF_EVENT_PROPERTIES: Final = "event_properties"

homeassistant/components/bthome/device_trigger.py

@@ -28,6 +28,7 @@ from .const import (
     DOMAIN,
     EVENT_CLASS,
     EVENT_CLASS_BUTTON,
+    EVENT_CLASS_COMMAND,
     EVENT_CLASS_DIMMER,
     EVENT_TYPE,
 )
@@ -43,6 +44,7 @@ EVENT_TYPES_BY_EVENT_CLASS = {
         "hold_press",
     },
     EVENT_CLASS_DIMMER: {"rotate_left", "rotate_right"},
+    EVENT_CLASS_COMMAND: {"off", "on", "toggle", "step_up", "step_down"},
 }
 
 TRIGGER_SCHEMA = DEVICE_TRIGGER_BASE_SCHEMA.extend(

homeassistant/components/bthome/event.py

@@ -16,6 +16,7 @@ from . import format_discovered_event_class, format_event_dispatcher_name
 from .const import (
     DOMAIN,
     EVENT_CLASS_BUTTON,
+    EVENT_CLASS_COMMAND,
     EVENT_CLASS_DIMMER,
     EVENT_PROPERTIES,
     EVENT_TYPE,
@@ -43,6 +44,11 @@ DESCRIPTIONS_BY_EVENT_CLASS = {
         translation_key="dimmer",
         event_types=["rotate_left", "rotate_right"],
     ),
+    EVENT_CLASS_COMMAND: EventEntityDescription(
+        key=EVENT_CLASS_COMMAND,
+        translation_key="command",
+        event_types=["off", "on", "toggle", "step_up", "step_down"],
+    ),
 }
 
 

homeassistant/components/bthome/manifest.json

@@ -20,5 +20,5 @@
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/bthome",
   "iot_class": "local_push",
-  "requirements": ["bthome-ble==3.17.0"]
+  "requirements": ["bthome-ble==3.23.2"]
 }

homeassistant/components/bthome/sensor.py

@@ -192,6 +192,12 @@ SENSOR_DESCRIPTIONS = {
         native_unit_of_measurement=LIGHT_LUX,
         state_class=SensorStateClass.MEASUREMENT,
     ),
+    # Light level (-)
+    (BTHomeExtendedSensorDeviceClass.LIGHT_LEVEL, None): SensorEntityDescription(
+        key=str(BTHomeExtendedSensorDeviceClass.LIGHT_LEVEL),
+        state_class=SensorStateClass.MEASUREMENT,
+        translation_key="light_level",
+    ),
     # Mass sensor (kg)
     (BTHomeSensorDeviceClass.MASS, Units.MASS_KILOGRAMS): SensorEntityDescription(
         key=f"{BTHomeSensorDeviceClass.MASS}_{Units.MASS_KILOGRAMS}",
@@ -287,6 +293,12 @@ SENSOR_DESCRIPTIONS = {
         state_class=SensorStateClass.MEASUREMENT,
         translation_key="rotational_speed",
     ),
+    # Settings revision (-)
+    (BTHomeExtendedSensorDeviceClass.SETTINGS_REVISION, None): SensorEntityDescription(
+        key=str(BTHomeExtendedSensorDeviceClass.SETTINGS_REVISION),
+        entity_category=EntityCategory.DIAGNOSTIC,
+        translation_key="settings_revision",
+    ),
     # Signal Strength (RSSI) (dB)
     (
         BTHomeSensorDeviceClass.SIGNAL_STRENGTH,

homeassistant/components/bthome/strings.json

@@ -36,13 +36,19 @@
       "long_double_press": "Long Double Press",
       "long_press": "Long Press",
       "long_triple_press": "Long Triple Press",
+      "off": "Off",
+      "on": "On",
       "press": "Press",
       "rotate_left": "Rotate Left",
       "rotate_right": "Rotate Right",
+      "step_down": "Step Down",
+      "step_up": "Step Up",
+      "toggle": "Toggle",
       "triple_press": "Triple Press"
     },
     "trigger_type": {
       "button": "Button \"{subtype}\"",
+      "command": "Command \"{subtype}\"",
       "dimmer": "Dimmer \"{subtype}\""
     }
   },
@@ -68,6 +74,19 @@
           }
         }
       },
+      "command": {
+        "state_attributes": {
+          "event_type": {
+            "state": {
+              "off": "Off",
+              "on": "On",
+              "step_down": "Step down",
+              "step_up": "Step up",
+              "toggle": "Toggle"
+            }
+          }
+        }
+      },
       "dimmer": {
         "state_attributes": {
           "event_type": {
@@ -98,6 +117,9 @@
       "gyroscope": {
         "name": "Gyroscope"
       },
+      "light_level": {
+        "name": "Light level"
+      },
       "packet_id": {
         "name": "Packet ID"
       },
@@ -110,6 +132,9 @@
       "rotational_speed": {
         "name": "Rotational speed"
       },
+      "settings_revision": {
+        "name": "Settings revision"
+      },
       "text": {
         "name": "Text"
       },

homeassistant/components/cast/config_flow.py

@@ -32,8 +32,16 @@ OPTIONS_SCHEMA = KNOWN_HOSTS_SCHEMA.extend(
         vol.Required(CONF_MORE_OPTIONS): section(
             vol.Schema(
                 {
-                    vol.Optional(CONF_UUID): str,
-                    vol.Optional(CONF_IGNORE_CEC): str,
+                    vol.Optional(CONF_UUID): SelectSelector(
+                        SelectSelectorConfig(
+                            custom_value=True, options=[], multiple=True
+                        ),
+                    ),
+                    vol.Optional(CONF_IGNORE_CEC): SelectSelector(
+                        SelectSelectorConfig(
+                            custom_value=True, options=[], multiple=True
+                        ),
+                    ),
                 }
             ),
             SectionConfig(collapsed=True),
@@ -109,13 +117,11 @@ class CastOptionsFlowHandler(OptionsFlow):
     ) -> ConfigFlowResult:
         """Manage the Google Cast options."""
         if user_input is not None:
-            ignore_cec = _string_to_list(
-                user_input[CONF_MORE_OPTIONS].get(CONF_IGNORE_CEC, "")
+            ignore_cec = _trim_items(
+                user_input[CONF_MORE_OPTIONS].get(CONF_IGNORE_CEC, [])
             )
             known_hosts = _trim_items(user_input.get(CONF_KNOWN_HOSTS, []))
-            wanted_uuid = _string_to_list(
-                user_input[CONF_MORE_OPTIONS].get(CONF_UUID, "")
-            )
+            wanted_uuid = _trim_items(user_input[CONF_MORE_OPTIONS].get(CONF_UUID, []))
             updated_config = dict(self.config_entry.data)
             updated_config[CONF_IGNORE_CEC] = ignore_cec
             updated_config[CONF_KNOWN_HOSTS] = known_hosts
@@ -132,9 +138,7 @@ class CastOptionsFlowHandler(OptionsFlow):
         for key in (CONF_UUID, CONF_IGNORE_CEC):
             if key not in self.config_entry.data:
                 continue
-            suggested[CONF_MORE_OPTIONS][key] = _list_to_string(
-                self.config_entry.data[key]
-            )
+            suggested[CONF_MORE_OPTIONS][key] = self.config_entry.data[key]
 
         return self.async_show_form(
             step_id="init",
@@ -143,16 +147,5 @@ class CastOptionsFlowHandler(OptionsFlow):
         )
 
 
-def _list_to_string(items: list[str]) -> str:
-    comma_separated_string = ""
-    if items:
-        comma_separated_string = ",".join(items)
-    return comma_separated_string
-
-
-def _string_to_list(string: str) -> list[str]:
-    return [x.strip() for x in string.split(",") if x.strip()]
-
-
 def _trim_items(items: list[str]) -> list[str]:
     return [x.strip() for x in items if x.strip()]

homeassistant/components/cert_expiry/diagnostics.py

@@ -0,0 +1,57 @@
+"""Diagnostics for the cert_expiry integration."""
+
+from typing import Any
+
+from homeassistant.components.diagnostics import async_redact_data
+from homeassistant.const import CONF_HOST
+from homeassistant.core import HomeAssistant
+
+from .coordinator import CertExpiryConfigEntry
+
+TO_REDACT = {CONF_HOST, "name", "title", "unique_id"}
+
+
+async def async_get_config_entry_diagnostics(
+    _hass: HomeAssistant,
+    entry: CertExpiryConfigEntry,
+) -> dict[str, Any]:
+    """Return diagnostics for a config entry."""
+    entry_diagnostics = entry.as_dict()
+
+    coordinator = getattr(entry, "runtime_data", None)
+
+    coordinator_diagnostics: dict[str, Any] = {
+        "host": None,
+        "port": None,
+        "name": None,
+        "expiry_datetime": None,
+        "is_cert_valid": None,
+        "cert_error": None,
+        "last_update_success": None,
+    }
+
+    if coordinator is not None:
+        expiry = coordinator.data.isoformat() if coordinator.data else None
+        cert_error = (
+            (
+                f"{type(coordinator.cert_error).__module__}."
+                f"{type(coordinator.cert_error).__qualname__}"
+            )
+            if coordinator.cert_error
+            else None
+        )
+
+        coordinator_diagnostics = {
+            "host": coordinator.host,
+            "port": coordinator.port,
+            "name": coordinator.name,
+            "expiry_datetime": expiry,
+            "is_cert_valid": coordinator.is_cert_valid,
+            "cert_error": cert_error,
+            "last_update_success": coordinator.last_update_success,
+        }
+
+    return {
+        "entry": async_redact_data(entry_diagnostics, TO_REDACT),
+        "coordinator": async_redact_data(coordinator_diagnostics, TO_REDACT),
+    }

homeassistant/components/cert_expiry/quality_scale.yaml

@@ -0,0 +1,81 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: Integration does not register custom actions.
+  appropriate-polling:
+    status: done
+    comment: Certificates are checked every 12 hours via DataUpdateCoordinator.
+  brands: done
+  common-modules: done
+  config-flow-test-coverage:
+    status: done
+    comment: test_abort_on_socket_failed can be parametrized and should end in CREATE_ENTRY to test flow recovery.
+  config-flow: done
+  dependency-transparency:
+    status: exempt
+    comment: Integration has no external library dependencies.
+  docs-actions:
+    status: exempt
+    comment: Integration does not register custom actions.
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: Integration does not subscribe to events.
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: todo
+  unique-config-entry: done
+  # Silver
+  action-exceptions:
+    status: exempt
+    comment: Integration does not register custom actions.
+  config-entry-unloading: done
+  docs-configuration-parameters: todo
+  docs-installation-parameters: todo
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: todo
+  reauthentication-flow:
+    status: exempt
+    comment: Config flow only collects host/port; the integration does not authenticate.
+  test-coverage:
+    status: todo
+    comment: Consider creating a mock_config_entry fixture and use that throughout tests.
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery: todo
+  discovery-update-info: todo
+  docs-data-update: todo
+  docs-examples: todo
+  docs-known-limitations: todo
+  docs-supported-devices: todo
+  docs-supported-functions: todo
+  docs-troubleshooting: todo
+  docs-use-cases: todo
+  dynamic-devices:
+    status: exempt
+    comment: Integration supports a single device per config entry.
+  entity-category:
+    status: todo
+    comment: Extra state attributes (is_valid, error) should be moved to separate entities in the future.
+  entity-device-class: done
+  entity-disabled-by-default: todo
+  entity-translations: done
+  exception-translations: todo
+  icon-translations: todo
+  reconfiguration-flow: done
+  repair-issues: todo
+  stale-devices:
+    status: exempt
+    comment: Integration supports a single device per config entry.
+  # Platinum
+  async-dependency: todo
+  inject-websession: todo
+  strict-typing: todo

homeassistant/components/cert_expiry/strings.json

@@ -16,6 +16,10 @@
           "host": "[%key:common::config_flow::data::host%]",
           "port": "[%key:common::config_flow::data::port%]"
         },
+        "data_description": {
+          "host": "The hostname or IP address of the server to monitor.",
+          "port": "The port to connect to on the server."
+        },
         "title": "Reconfigure the certificate to test"
       },
       "user": {
@@ -24,6 +28,10 @@
           "name": "The name of the certificate",
           "port": "[%key:common::config_flow::data::port%]"
         },
+        "data_description": {
+          "host": "The hostname or IP address of the server to monitor.",
+          "port": "The port to connect to on the server."
+        },
         "title": "Define the certificate to test"
       }
     }

homeassistant/components/climate/trigger.py

@@ -7,7 +7,7 @@ from homeassistant.core import HomeAssistant, State
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.automation import DomainSpec
 from homeassistant.helpers.trigger import (
-    ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST,
+    ENTITY_STATE_TRIGGER_SCHEMA_WITH_BEHAVIOR,
     EntityNumericalStateChangedTriggerBase,
     EntityNumericalStateChangedTriggerWithUnitBase,
     EntityNumericalStateCrossedThresholdTriggerBase,
@@ -26,7 +26,7 @@ from .const import ATTR_HUMIDITY, ATTR_HVAC_ACTION, DOMAIN, HVACAction, HVACMode
 
 CONF_HVAC_MODE = "hvac_mode"
 
-HVAC_MODE_CHANGED_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST.extend(
+HVAC_MODE_CHANGED_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA_WITH_BEHAVIOR.extend(
     {
         vol.Required(CONF_OPTIONS): {
             vol.Required(CONF_HVAC_MODE): vol.All(

homeassistant/components/climate/triggers.yaml

@@ -5,7 +5,7 @@
   fields:
     behavior: &trigger_behavior
       required: true
-      default: any
+      default: each
       selector:
         automation_behavior:
           mode: trigger

homeassistant/components/cloud/google_config.py

@@ -275,9 +275,13 @@ class CloudGoogleConfig(AbstractConfig):
             )
         )
 
-    def should_expose(self, state: State) -> bool:
-        """If a state object should be exposed."""
-        return self._should_expose_entity_id(state.entity_id)
+    def should_expose(self, entity_id: str) -> bool:
+        """If an entity should be exposed."""
+        entity_filter: EntityFilter = self._config[CONF_FILTER]
+        if not entity_filter.empty_filter:
+            return entity_filter(entity_id)
+
+        return async_should_expose(self.hass, CLOUD_GOOGLE, entity_id)
 
     def _should_expose_legacy(self, entity_id: str) -> bool:
         """If an entity ID should be exposed."""
@@ -308,14 +312,6 @@ class CloudGoogleConfig(AbstractConfig):
             and _supported_legacy(self.hass, entity_id)
         )
 
-    def _should_expose_entity_id(self, entity_id: str) -> bool:
-        """If an entity should be exposed."""
-        entity_filter: EntityFilter = self._config[CONF_FILTER]
-        if not entity_filter.empty_filter:
-            return entity_filter(entity_id)
-
-        return async_should_expose(self.hass, CLOUD_GOOGLE, entity_id)
-
     @property
     def agent_user_id(self) -> str:
         """Return Agent User Id to use for query responses."""
@@ -467,7 +463,7 @@ class CloudGoogleConfig(AbstractConfig):
 
         entity_id = event.data["entity_id"]
 
-        if not self._should_expose_entity_id(entity_id):
+        if not self.should_expose(entity_id):
             return
 
         self.async_schedule_google_sync_all()
@@ -490,8 +486,7 @@ class CloudGoogleConfig(AbstractConfig):
 
         # Check if any exposed entity uses the device area
         if not any(
-            entity_entry.area_id is None
-            and self._should_expose_entity_id(entity_entry.entity_id)
+            entity_entry.area_id is None and self.should_expose(entity_entry.entity_id)
             for entity_entry in er.async_entries_for_device(
                 er.async_get(self.hass), event.data["device_id"]
             )

homeassistant/components/color_extractor/const.py

@@ -5,3 +5,5 @@ ATTR_URL = "color_extract_url"
 
 DOMAIN = "color_extractor"
 DEFAULT_NAME = "Color extractor"
+
+SERVICE_GET_COLOR = "get_color"

homeassistant/components/color_extractor/icons.json

@@ -1,5 +1,8 @@
 {
   "services": {
+    "get_color": {
+      "service": "mdi:select-color"
+    },
     "turn_on": {
       "service": "mdi:lightbulb-on"
     }

homeassistant/components/color_extractor/services.py

@@ -3,6 +3,7 @@
 import asyncio
 import io
 import logging
+from typing import Any
 
 import aiohttp
 from colorthief import ColorThief
@@ -15,15 +16,16 @@ from homeassistant.components.light import (
     LIGHT_TURN_ON_SCHEMA,
 )
 from homeassistant.const import SERVICE_TURN_ON
-from homeassistant.core import HomeAssistant, ServiceCall, callback
+from homeassistant.core import HomeAssistant, ServiceCall, SupportsResponse, callback
+from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import aiohttp_client, config_validation as cv
 
-from .const import ATTR_PATH, ATTR_URL, DOMAIN
+from .const import ATTR_PATH, ATTR_URL, DOMAIN, SERVICE_GET_COLOR
 
 _LOGGER = logging.getLogger(__name__)
 
 # Extend the existing light.turn_on service schema
-SERVICE_SCHEMA = vol.All(
+TURN_ON_SERVICE_SCHEMA = vol.All(
     cv.has_at_least_one_key(ATTR_URL, ATTR_PATH),
     cv.make_entity_service_schema(
         {
@@ -34,6 +36,14 @@ SERVICE_SCHEMA = vol.All(
     ),
 )
 
+GET_COLOR_SERVICE_SCHEMA = vol.All(
+    cv.has_at_least_one_key(ATTR_URL, ATTR_PATH),
+    {
+        vol.Exclusive(ATTR_PATH, "color_extractor"): cv.isfile,
+        vol.Exclusive(ATTR_URL, "color_extractor"): cv.url,
+    },
+)
+
 
 def _get_file(file_path: str) -> str:
     """Get a PIL acceptable input file reference.
@@ -145,6 +155,50 @@ async def async_handle_service(service_call: ServiceCall) -> None:
         )
 
 
+async def async_handle_get_color(
+    service_call: ServiceCall,
+) -> dict[str, Any]:
+    """Handle get_color service call."""
+    service_data = dict(service_call.data)
+
+    try:
+        if ATTR_URL in service_data:
+            image_type = "URL"
+            image_reference = service_data.pop(ATTR_URL)
+            color = await _async_extract_color_from_url(
+                service_call.hass, image_reference
+            )
+
+        elif ATTR_PATH in service_data:
+            image_type = "file path"
+            image_reference = service_data.pop(ATTR_PATH)
+            color = await service_call.hass.async_add_executor_job(
+                _extract_color_from_path, service_call.hass, image_reference
+            )
+
+    except UnidentifiedImageError as ex:
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="invalid_image",
+            translation_placeholders={
+                "image_type": image_type,
+                "image_reference": image_reference,
+            },
+        ) from ex
+
+    if color is None:
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="invalid_image",
+            translation_placeholders={
+                "image_type": image_type,
+                "image_reference": image_reference,
+            },
+        )
+
+    return {"color": color}
+
+
 @callback
 def async_setup_services(hass: HomeAssistant) -> None:
     """Register the services."""
@@ -153,5 +207,13 @@ def async_setup_services(hass: HomeAssistant) -> None:
         DOMAIN,
         SERVICE_TURN_ON,
         async_handle_service,
-        schema=SERVICE_SCHEMA,
+        schema=TURN_ON_SERVICE_SCHEMA,
+    )
+
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_GET_COLOR,
+        async_handle_get_color,
+        schema=GET_COLOR_SERVICE_SCHEMA,
+        supports_response=SupportsResponse.ONLY,
     )

homeassistant/components/color_extractor/services.yaml

@@ -11,3 +11,13 @@ turn_on:
       example: /opt/images/logo.png
       selector:
         text:
+get_color:
+  fields:
+    color_extract_url:
+      example: https://www.example.com/images/logo.png
+      selector:
+        text:
+    color_extract_path:
+      example: /opt/images/logo.png
+      selector:
+        text:

homeassistant/components/color_extractor/strings.json

@@ -6,7 +6,26 @@
       }
     }
   },
+  "exceptions": {
+    "invalid_image": {
+      "message": "Bad image {image_reference} from {image_type} provided, are you sure it's an image?"
+    }
+  },
   "services": {
+    "get_color": {
+      "description": "Gets the predominant RGB color found in the image provided by URL or file path.",
+      "fields": {
+        "color_extract_path": {
+          "description": "The full system path to the image we want to extract RGB values from. Must be allowed in allowlist_external_dirs.",
+          "name": "[%key:common::config_flow::data::path%]"
+        },
+        "color_extract_url": {
+          "description": "The URL of the image we want to extract RGB values from. Must be allowed in allowlist_external_urls.",
+          "name": "[%key:common::config_flow::data::url%]"
+        }
+      },
+      "name": "Get predominant color"
+    },
     "turn_on": {
       "description": "Sets the light RGB to the predominant color found in the image provided by URL or file path.",
       "fields": {

homeassistant/components/config/config_entries.py

@@ -175,7 +175,6 @@ class ConfigManagerFlowIndexView(
         vol.Schema(
             {
                 vol.Required("handler"): vol.Any(str, list),
-                vol.Optional("show_advanced_options", default=False): cv.boolean,
                 vol.Optional("entry_id"): cv.string,
             },
             extra=vol.ALLOW_EXTRA,
@@ -302,7 +301,6 @@ class SubentryManagerFlowIndexView(
         vol.Schema(
             {
                 vol.Required("handler"): vol.All(vol.Coerce(tuple), (str, str)),
-                vol.Optional("show_advanced_options", default=False): cv.boolean,
             },
             extra=vol.ALLOW_EXTRA,
         )

homeassistant/components/config/core.py

@@ -60,7 +60,9 @@ class CheckConfigView(HomeAssistantView):
         vol.Optional("location_name"): str,
         vol.Optional("longitude"): cv.longitude,
         vol.Optional("radius"): cv.positive_int,
-        vol.Optional("time_zone"): cv.time_zone,
+        # Validated by async_set_time_zone in the executor to avoid
+        # blocking I/O loading zoneinfo data on the event loop.
+        vol.Optional("time_zone"): str,
         vol.Optional("update_units"): bool,
         vol.Optional("unit_system"): unit_system.validate_unit_system,
     }

homeassistant/components/counter/triggers.yaml

@@ -5,7 +5,7 @@
   fields:
     behavior:
       required: true
-      default: any
+      default: each
       selector:
         automation_behavior:
           mode: trigger

homeassistant/components/cover/triggers.yaml

@@ -1,7 +1,7 @@
 .trigger_common_fields: &trigger_common_fields
   behavior:
     required: true
-    default: any
+    default: each
     selector:
       automation_behavior:
         mode: trigger

homeassistant/components/data_grand_lyon/manifest.json

@@ -6,6 +6,6 @@
   "documentation": "https://www.home-assistant.io/integrations/data_grand_lyon",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "quality_scale": "silver",
+  "quality_scale": "platinum",
   "requirements": ["data-grand-lyon-ha==0.7.0"]
 }

homeassistant/components/data_grand_lyon/quality_scale.yaml

@@ -49,13 +49,15 @@ rules:
     status: exempt
     comment: This is a service integration; there are no discoverable devices.
   docs-data-update: done
-  docs-examples: todo
+  docs-examples: done
   docs-known-limitations: done
   docs-supported-devices: done
   docs-supported-functions: done
   docs-troubleshooting: done
   docs-use-cases: done
-  dynamic-devices: done
+  dynamic-devices:
+    status: exempt
+    comment: This is a service integration; devices are added and removed manually by the user.
   entity-category: done
   entity-device-class: done
   entity-disabled-by-default: done
@@ -66,7 +68,9 @@ rules:
   repair-issues:
     status: exempt
     comment: no known use cases for repair issues or flows, yet
-  stale-devices: done
+  stale-devices:
+    status: exempt
+    comment: This is a service integration; devices are added and removed manually by the user.
 
   # Platinum
   async-dependency: done

homeassistant/components/device_tracker/__init__.py

@@ -3,23 +3,14 @@
 import asyncio
 from typing import Any
 
-from homeassistant.const import ATTR_GPS_ACCURACY, STATE_HOME  # noqa: F401
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import STATE_HOME
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import discovery
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.typing import ConfigType
+from homeassistant.util.hass_dict import HassKey
 
-from .config_entry import (  # noqa: F401
-    DATA_COMPONENT,
-    BaseScannerEntity,
-    BaseTrackerEntity,
-    ScannerEntity,
-    ScannerEntityDescription,
-    TrackerEntity,
-    TrackerEntityDescription,
-    async_setup_entry,
-    async_unload_entry,
-)
 from .const import (  # noqa: F401
     ATTR_ATTRIBUTES,
     ATTR_BATTERY,
@@ -31,6 +22,7 @@ from .const import (  # noqa: F401
     ATTR_LOCATION_NAME,
     ATTR_MAC,
     ATTR_SOURCE_TYPE,
+    CONF_ASSOCIATED_ZONE,
     CONF_CONSIDER_HOME,
     CONF_NEW_DEVICE_DEFAULTS,
     CONF_SCAN_INTERVAL,
@@ -45,6 +37,14 @@ from .const import (  # noqa: F401
     SCAN_INTERVAL,
     SourceType,
 )
+from .entity import (  # noqa: F401
+    BaseScannerEntity,
+    BaseTrackerEntity,
+    ScannerEntity,
+    ScannerEntityDescription,
+    TrackerEntity,
+    TrackerEntityDescription,
+)
 from .legacy import (  # noqa: F401
     PLATFORM_SCHEMA,
     PLATFORM_SCHEMA_BASE,
@@ -60,6 +60,8 @@ from .legacy import (  # noqa: F401
     see,
 )
 
+DATA_COMPONENT: HassKey[EntityComponent[BaseTrackerEntity]] = HassKey(DOMAIN)
+
 
 def is_on(hass: HomeAssistant, entity_id: str) -> bool:
     """Return the state if any or a specified device is home."""
@@ -108,3 +110,23 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
         eager_start=True,
     )
     return True
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Set up an entry."""
+    component: EntityComponent[BaseTrackerEntity] | None = hass.data.get(DOMAIN)
+
+    if component is not None:
+        return await component.async_setup_entry(entry)
+
+    component = hass.data[DATA_COMPONENT] = EntityComponent[BaseTrackerEntity](
+        LOGGER, DOMAIN, hass
+    )
+    component.register_shutdown()
+
+    return await component.async_setup_entry(entry)
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Unload an entry."""
+    return await hass.data[DATA_COMPONENT].async_unload_entry(entry)

homeassistant/components/device_tracker/config_entry.py

@@ -1,500 +1,45 @@
 """Code to set up a device tracker platform using a config entry."""
 
-import asyncio
-from typing import Any, final
+from functools import partial
 
-from propcache.api import cached_property
-
-from homeassistant.components import zone
-from homeassistant.components.zone import ATTR_PASSIVE, ATTR_RADIUS
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
-    ATTR_BATTERY_LEVEL,
-    ATTR_GPS_ACCURACY,
-    ATTR_LATITUDE,
-    ATTR_LONGITUDE,
-    STATE_HOME,
-    STATE_NOT_HOME,
-    EntityCategory,
-)
-from homeassistant.core import Event, HomeAssistant, State, callback
-from homeassistant.helpers import device_registry as dr, entity_registry as er
-from homeassistant.helpers.device_registry import (
-    DeviceInfo,
-    EventDeviceRegistryUpdatedData,
-)
-from homeassistant.helpers.dispatcher import async_dispatcher_send
-from homeassistant.helpers.entity import Entity, EntityDescription
-from homeassistant.helpers.entity_component import EntityComponent
-from homeassistant.helpers.entity_platform import EntityPlatform
-from homeassistant.helpers.typing import StateType
-from homeassistant.util.hass_dict import HassKey
-
-from .const import (
-    ATTR_HOST_NAME,
-    ATTR_IN_ZONES,
-    ATTR_IP,
-    ATTR_MAC,
-    ATTR_SOURCE_TYPE,
-    CONNECTED_DEVICE_REGISTERED,
-    DOMAIN,
-    LOGGER,
-    SourceType,
+from homeassistant.helpers.deprecation import (
+    DeprecatedAlias,
+    all_with_deprecated_constants,
+    check_if_deprecated_constant,
+    dir_with_deprecated_constants,
 )
 
-DATA_COMPONENT: HassKey[EntityComponent[BaseTrackerEntity]] = HassKey(DOMAIN)
-DATA_KEY: HassKey[dict[str, tuple[str, str]]] = HassKey(f"{DOMAIN}_mac")
-
-# mypy: disallow-any-generics
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Set up an entry."""
-    component: EntityComponent[BaseTrackerEntity] | None = hass.data.get(DOMAIN)
-
-    if component is not None:
-        return await component.async_setup_entry(entry)
-
-    component = hass.data[DATA_COMPONENT] = EntityComponent[BaseTrackerEntity](
-        LOGGER, DOMAIN, hass
-    )
-    component.register_shutdown()
-
-    return await component.async_setup_entry(entry)
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
-    """Unload an entry."""
-    return await hass.data[DATA_COMPONENT].async_unload_entry(entry)
-
-
-@callback
-def _async_connected_device_registered(
-    hass: HomeAssistant, mac: str, ip_address: str | None, hostname: str | None
-) -> None:
-    """Register a newly seen connected device.
-
-    This is currently used by the dhcp integration
-    to listen for newly registered connected devices
-    for discovery.
-    """
-    async_dispatcher_send(
-        hass,
-        CONNECTED_DEVICE_REGISTERED,
-        {
-            ATTR_IP: ip_address,
-            ATTR_MAC: mac,
-            ATTR_HOST_NAME: hostname,
-        },
-    )
-
-
-@callback
-def _async_register_mac(
-    hass: HomeAssistant,
-    domain: str,
-    mac: str,
-    unique_id: str,
-) -> None:
-    """Register a mac address with a unique ID."""
-    mac = dr.format_mac(mac)
-    if DATA_KEY in hass.data:
-        hass.data[DATA_KEY][mac] = (domain, unique_id)
-        return
-
-    # Setup listening.
-
-    # dict mapping mac -> partial unique ID
-    data = hass.data[DATA_KEY] = {mac: (domain, unique_id)}
-
-    @callback
-    def handle_device_event(ev: Event[EventDeviceRegistryUpdatedData]) -> None:
-        """Enable the online status entity for the mac of a newly created device."""
-        # Only for new devices
-        if ev.data["action"] != "create":
-            return
-
-        dev_reg = dr.async_get(hass)
-        device_entry = dev_reg.async_get(ev.data["device_id"])
-
-        if device_entry is None:
-            # This should not happen, since the device was just created.
-            return
-
-        # Check if device has a mac
-        mac = None
-        for conn in device_entry.connections:
-            if conn[0] == dr.CONNECTION_NETWORK_MAC:
-                mac = conn[1]
-                break
-
-        if mac is None:
-            return
-
-        # Check if we have an entity for this mac
-        if (unique_id := data.get(mac)) is None:
-            return
-
-        ent_reg = er.async_get(hass)
-
-        if (entity_id := ent_reg.async_get_entity_id(DOMAIN, *unique_id)) is None:
-            return
-
-        entity_entry = ent_reg.entities[entity_id]
-
-        # Make sure entity has a config entry and was disabled by the
-        # default disable logic in the integration and new entities
-        # are allowed to be added.
-        if (
-            entity_entry.config_entry_id is None
-            or (
-                (
-                    config_entry := hass.config_entries.async_get_entry(
-                        entity_entry.config_entry_id
-                    )
-                )
-                is not None
-                and config_entry.pref_disable_new_entities
-            )
-            or entity_entry.disabled_by != er.RegistryEntryDisabler.INTEGRATION
-        ):
-            return
-
-        # Enable entity
-        ent_reg.async_update_entity(entity_id, disabled_by=None)
-
-    hass.bus.async_listen(dr.EVENT_DEVICE_REGISTRY_UPDATED, handle_device_event)
-
-
-class BaseTrackerEntity(Entity):
-    """Represent a tracked device.
-
-    Not intended to be directly inherited by integrations. Integrations should
-    inherit TrackerEntity, BaseScannerEntity or ScannerEntity instead.
-    """
-
-    _attr_device_info: None = None
-    _attr_entity_category = EntityCategory.DIAGNOSTIC
-    _attr_source_type: SourceType
-
-    @cached_property
-    def battery_level(self) -> int | None:
-        """Return the battery level of the device.
-
-        Percentage from 0-100.
-        """
-        return None
-
-    @property
-    def source_type(self) -> SourceType:
-        """Return the source type, eg gps or router, of the device."""
-        if hasattr(self, "_attr_source_type"):
-            return self._attr_source_type
-        raise NotImplementedError
-
-    @property
-    def state_attributes(self) -> dict[str, StateType]:
-        """Return the device state attributes."""
-        attr: dict[str, StateType] = {ATTR_SOURCE_TYPE: self.source_type}
-
-        if self.battery_level is not None:
-            attr[ATTR_BATTERY_LEVEL] = self.battery_level
-
-        return attr
-
-
-class TrackerEntityDescription(EntityDescription, frozen_or_thawed=True):
-    """A class that describes tracker entities."""
-
-
-CACHED_TRACKER_PROPERTIES_WITH_ATTR_ = {
-    "in_zones",
-    "latitude",
-    "location_accuracy",
-    "location_name",
-    "longitude",
-}
-
-
-class TrackerEntity(
-    BaseTrackerEntity, cached_properties=CACHED_TRACKER_PROPERTIES_WITH_ATTR_
-):
-    """Base class for a tracked device."""
-
-    entity_description: TrackerEntityDescription
-    _attr_in_zones: list[str] | None = None
-    _attr_latitude: float | None = None
-    _attr_location_accuracy: float = 0
-    _attr_location_name: str | None = None
-    _attr_longitude: float | None = None
-    _attr_source_type: SourceType = SourceType.GPS
-
-    __active_zone: State | None = None
-    __in_zones: list[str] | None = None
-
-    @cached_property
-    def should_poll(self) -> bool:
-        """No polling for entities that have location pushed."""
-        return False
-
-    @property
-    def force_update(self) -> bool:
-        """All updates need to be written to the state machine if we're not polling."""
-        return not self.should_poll
-
-    @cached_property
-    def in_zones(self) -> list[str] | None:
-        """Return the entity_id of zones the device is currently in.
-
-        The list may be in any order; the base class sorts it by zone radius
-        and discards zones which do not exist. Ignored if latitude and
-        longitude are both set.
-        """
-        return self._attr_in_zones
-
-    @cached_property
-    def location_accuracy(self) -> float:
-        """Return the location accuracy of the device.
-
-        Value in meters.
-        """
-        return self._attr_location_accuracy
-
-    @cached_property
-    def location_name(self) -> str | None:
-        """Return a location name for the current location of the device."""
-        return self._attr_location_name
-
-    @cached_property
-    def latitude(self) -> float | None:
-        """Return latitude value of the device."""
-        return self._attr_latitude
-
-    @cached_property
-    def longitude(self) -> float | None:
-        """Return longitude value of the device."""
-        return self._attr_longitude
-
-    @callback
-    def _async_write_ha_state(self) -> None:
-        """Calculate active zones."""
-        if self.available and self.latitude is not None and self.longitude is not None:
-            self.__active_zone, self.__in_zones = zone.async_in_zones(
-                self.hass, self.latitude, self.longitude, self.location_accuracy
-            )
-        elif (zones := self.in_zones) is not None:
-            zone_states = sorted(
-                (
-                    zone_state
-                    for entity_id in zones
-                    if (zone_state := self.hass.states.get(entity_id)) is not None
-                ),
-                key=lambda z: z.attributes[ATTR_RADIUS],
-            )
-            self.__active_zone = next(
-                (z for z in zone_states if not z.attributes.get(ATTR_PASSIVE)),
-                None,
-            )
-            self.__in_zones = [z.entity_id for z in zone_states]
-        else:
-            self.__active_zone = None
-            self.__in_zones = None
-        super()._async_write_ha_state()
-
-    @property
-    def state(self) -> str | None:
-        """Return the state of the device."""
-        if self.location_name is not None:
-            return self.location_name
-
-        if (
-            self.latitude is not None and self.longitude is not None
-        ) or self.__in_zones is not None:
-            zone_state = self.__active_zone
-            if zone_state is None:
-                state = STATE_NOT_HOME
-            elif zone_state.entity_id == zone.ENTITY_ID_HOME:
-                state = STATE_HOME
-            else:
-                state = zone_state.name
-            return state
-
-        return None
-
-    @final
-    @property
-    def state_attributes(self) -> dict[str, Any]:
-        """Return the device state attributes."""
-        attr: dict[str, Any] = {ATTR_IN_ZONES: self.__in_zones or []}
-        attr.update(super().state_attributes)
-
-        if self.latitude is not None and self.longitude is not None:
-            attr[ATTR_LATITUDE] = self.latitude
-            attr[ATTR_LONGITUDE] = self.longitude
-            attr[ATTR_GPS_ACCURACY] = self.location_accuracy
-
-        return attr
-
-
-class BaseScannerEntity(BaseTrackerEntity):
-    """Base class for a tracked device that can be connected or disconnected.
-
-    Unlike ScannerEntity, this entity does not make assumptions about MAC
-    addresses being used to identify the device.
-    """
-
-    @property
-    def state(self) -> str | None:
-        """Return the state of the device."""
-        if self.is_connected is None:
-            return None
-        if self.is_connected:
-            return STATE_HOME
-        return STATE_NOT_HOME
-
-    @property
-    def is_connected(self) -> bool | None:
-        """Return true if the device is connected."""
-        raise NotImplementedError
-
-
-class ScannerEntityDescription(EntityDescription, frozen_or_thawed=True):
-    """A class that describes tracker entities."""
-
-
-CACHED_SCANNER_PROPERTIES_WITH_ATTR_ = {
-    "ip_address",
-    "mac_address",
-    "hostname",
-}
-
-
-class ScannerEntity(
-    BaseScannerEntity, cached_properties=CACHED_SCANNER_PROPERTIES_WITH_ATTR_
-):
-    """Base class for a tracked device that is on a scanned network."""
-
-    entity_description: ScannerEntityDescription
-    _attr_hostname: str | None = None
-    _attr_ip_address: str | None = None
-    _attr_mac_address: str | None = None
-    _attr_source_type: SourceType = SourceType.ROUTER
-
-    @cached_property
-    def ip_address(self) -> str | None:
-        """Return the primary ip address of the device."""
-        return self._attr_ip_address
-
-    @cached_property
-    def mac_address(self) -> str | None:
-        """Return the mac address of the device."""
-        return self._attr_mac_address
-
-    @cached_property
-    def hostname(self) -> str | None:
-        """Return hostname of the device."""
-        return self._attr_hostname
-
-    @property
-    def unique_id(self) -> str | None:
-        """Return unique ID of the entity."""
-        return self.mac_address
-
-    @final
-    @property
-    def device_info(self) -> DeviceInfo | None:
-        """Device tracker entities should not create device registry entries."""
-        return None
-
-    @property
-    def entity_registry_enabled_default(self) -> bool:
-        """Return if entity is enabled by default."""
-        # If mac_address is None, we can never find a device entry.
-        return (
-            # Do not disable if we won't activate our attach to device logic
-            self.mac_address is None
-            or self.device_info is not None
-            # Disable if we automatically attach but there is no device
-            or self.find_device_entry() is not None
-        )
-
-    @callback
-    def add_to_platform_start(
-        self,
-        hass: HomeAssistant,
-        platform: EntityPlatform,
-        parallel_updates: asyncio.Semaphore | None,
-    ) -> None:
-        """Start adding an entity to a platform."""
-        super().add_to_platform_start(hass, platform, parallel_updates)
-        if self.mac_address and self.unique_id:
-            _async_register_mac(
-                hass,
-                platform.platform_name,
-                self.mac_address,
-                self.unique_id,
-            )
-            if self.is_connected and self.ip_address:
-                _async_connected_device_registered(
-                    hass,
-                    self.mac_address,
-                    self.ip_address,
-                    self.hostname,
-                )
-
-    @callback
-    def find_device_entry(self) -> dr.DeviceEntry | None:
-        """Return device entry."""
-        assert self.mac_address is not None
-
-        return dr.async_get(self.hass).async_get_device(
-            connections={(dr.CONNECTION_NETWORK_MAC, self.mac_address)}
-        )
-
-    async def async_internal_added_to_hass(self) -> None:
-        """Handle added to Home Assistant."""
-        # Entities without a unique ID don't have a device
-        if (
-            not self.registry_entry
-            or not self.platform.config_entry
-            or not self.mac_address
-            or (device_entry := self.find_device_entry()) is None
-            # Entities should not have a device info. We opt them out
-            # of this logic if they do.
-            or self.device_info
-        ):
-            if self.device_info:
-                LOGGER.debug("Entity %s unexpectedly has a device info", self.entity_id)
-            await super().async_internal_added_to_hass()
-            return
-
-        # Attach entry to device
-        if self.registry_entry.device_id != device_entry.id:
-            self.registry_entry = er.async_get(self.hass).async_update_entity(
-                self.entity_id, device_id=device_entry.id
-            )
-
-        # Attach device to config entry
-        if self.platform.config_entry.entry_id not in device_entry.config_entries:
-            dr.async_get(self.hass).async_update_device(
-                device_entry.id,
-                add_config_entry_id=self.platform.config_entry.entry_id,
-            )
-
-        # Do this last or else the entity registry update listener has been installed
-        await super().async_internal_added_to_hass()
-
-    @final
-    @property
-    def state_attributes(self) -> dict[str, StateType]:
-        """Return the device state attributes."""
-        attr = super().state_attributes
-
-        if ip_address := self.ip_address:
-            attr[ATTR_IP] = ip_address
-        if (mac_address := self.mac_address) is not None:
-            attr[ATTR_MAC] = mac_address
-        if (hostname := self.hostname) is not None:
-            attr[ATTR_HOST_NAME] = hostname
-
-        return attr
+from . import (
+    BaseTrackerEntity as _BaseTrackerEntity,
+    ScannerEntity as _ScannerEntity,
+    SourceType as _SourceType,
+    TrackerEntity as _TrackerEntity,
+    TrackerEntityDescription as _TrackerEntityDescription,
+)
+
+_DEPRECATED_TrackerEntity = DeprecatedAlias(
+    _TrackerEntity, "homeassistant.components.device_tracker.TrackerEntity", "2027.6"
+)
+_DEPRECATED_ScannerEntity = DeprecatedAlias(
+    _ScannerEntity, "homeassistant.components.device_tracker.ScannerEntity", "2027.6"
+)
+_DEPRECATED_BaseTrackerEntity = DeprecatedAlias(
+    _BaseTrackerEntity,
+    "homeassistant.components.device_tracker.BaseTrackerEntity",
+    "2027.6",
+)
+_DEPRECATED_TrackerEntityDescription = DeprecatedAlias(
+    _TrackerEntityDescription,
+    "homeassistant.components.device_tracker.TrackerEntityDescription",
+    "2027.6",
+)
+_DEPRECATED_SourceType = DeprecatedAlias(
+    _SourceType, "homeassistant.components.device_tracker.SourceType", "2027.6"
+)
+
+# These can be removed if no deprecated aliases are in this module anymore
+__getattr__ = partial(check_if_deprecated_constant, module_globals=globals())
+__dir__ = partial(
+    dir_with_deprecated_constants, module_globals_keys=[*globals().keys()]
+)
+__all__ = all_with_deprecated_constants(globals())

homeassistant/components/device_tracker/const.py

@@ -36,6 +36,8 @@ DEFAULT_CONSIDER_HOME: Final = timedelta(seconds=180)
 
 CONF_NEW_DEVICE_DEFAULTS: Final = "new_device_defaults"
 
+CONF_ASSOCIATED_ZONE: Final = "associated_zone"
+
 ATTR_ATTRIBUTES: Final = "attributes"
 ATTR_BATTERY: Final = "battery"
 ATTR_DEV_ID: Final = "dev_id"

homeassistant/components/device_tracker/entity.py

@@ -0,0 +1,624 @@
+"""Provide functionality to keep track of devices."""
+
+import asyncio
+from typing import TYPE_CHECKING, Any, final
+
+from propcache.api import cached_property
+
+from homeassistant.components import zone
+from homeassistant.components.zone import ATTR_PASSIVE, ATTR_RADIUS
+from homeassistant.const import (
+    ATTR_BATTERY_LEVEL,
+    ATTR_GPS_ACCURACY,
+    ATTR_LATITUDE,
+    ATTR_LONGITUDE,
+    STATE_HOME,
+    STATE_NOT_HOME,
+    EntityCategory,
+)
+from homeassistant.core import (
+    CALLBACK_TYPE,
+    Event,
+    EventStateChangedData,
+    HomeAssistant,
+    State,
+    callback,
+)
+from homeassistant.helpers import (
+    device_registry as dr,
+    entity_registry as er,
+    issue_registry as ir,
+)
+from homeassistant.helpers.device_registry import (
+    DeviceInfo,
+    EventDeviceRegistryUpdatedData,
+)
+from homeassistant.helpers.dispatcher import async_dispatcher_send
+from homeassistant.helpers.entity import Entity, EntityDescription
+from homeassistant.helpers.entity_platform import EntityPlatform
+from homeassistant.helpers.event import async_track_state_change_event
+from homeassistant.util.hass_dict import HassKey
+
+from .const import (
+    ATTR_HOST_NAME,
+    ATTR_IN_ZONES,
+    ATTR_IP,
+    ATTR_MAC,
+    ATTR_SOURCE_TYPE,
+    CONF_ASSOCIATED_ZONE,
+    CONNECTED_DEVICE_REGISTERED,
+    DOMAIN,
+    LOGGER,
+    SourceType,
+)
+
+DATA_KEY: HassKey[dict[str, tuple[str, str]]] = HassKey(f"{DOMAIN}_mac")
+
+
+@callback
+def _async_connected_device_registered(
+    hass: HomeAssistant, mac: str, ip_address: str | None, hostname: str | None
+) -> None:
+    """Register a newly seen connected device.
+
+    This is currently used by the dhcp integration
+    to listen for newly registered connected devices
+    for discovery.
+    """
+    async_dispatcher_send(
+        hass,
+        CONNECTED_DEVICE_REGISTERED,
+        {
+            ATTR_IP: ip_address,
+            ATTR_MAC: mac,
+            ATTR_HOST_NAME: hostname,
+        },
+    )
+
+
+@callback
+def _async_register_mac(
+    hass: HomeAssistant,
+    domain: str,
+    mac: str,
+    unique_id: str,
+) -> None:
+    """Register a mac address with a unique ID."""
+    mac = dr.format_mac(mac)
+    if DATA_KEY in hass.data:
+        hass.data[DATA_KEY][mac] = (domain, unique_id)
+        return
+
+    # Setup listening.
+
+    # dict mapping mac -> partial unique ID
+    data = hass.data[DATA_KEY] = {mac: (domain, unique_id)}
+
+    @callback
+    def handle_device_event(ev: Event[EventDeviceRegistryUpdatedData]) -> None:
+        """Enable the online status entity for the mac of a newly created device."""
+        # Only for new devices
+        if ev.data["action"] != "create":
+            return
+
+        dev_reg = dr.async_get(hass)
+        device_entry = dev_reg.async_get(ev.data["device_id"])
+
+        if device_entry is None:
+            # This should not happen, since the device was just created.
+            return
+
+        # Check if device has a mac
+        mac = None
+        for conn in device_entry.connections:
+            if conn[0] == dr.CONNECTION_NETWORK_MAC:
+                mac = conn[1]
+                break
+
+        if mac is None:
+            return
+
+        # Check if we have an entity for this mac
+        if (unique_id := data.get(mac)) is None:
+            return
+
+        ent_reg = er.async_get(hass)
+
+        if (entity_id := ent_reg.async_get_entity_id(DOMAIN, *unique_id)) is None:
+            return
+
+        entity_entry = ent_reg.entities[entity_id]
+
+        # Make sure entity has a config entry and was disabled by the
+        # default disable logic in the integration and new entities
+        # are allowed to be added.
+        if (
+            entity_entry.config_entry_id is None
+            or (
+                (
+                    config_entry := hass.config_entries.async_get_entry(
+                        entity_entry.config_entry_id
+                    )
+                )
+                is not None
+                and config_entry.pref_disable_new_entities
+            )
+            or entity_entry.disabled_by != er.RegistryEntryDisabler.INTEGRATION
+        ):
+            return
+
+        # Enable entity
+        ent_reg.async_update_entity(entity_id, disabled_by=None)
+
+    hass.bus.async_listen(dr.EVENT_DEVICE_REGISTRY_UPDATED, handle_device_event)
+
+
+class BaseTrackerEntity(Entity):
+    """Represent a tracked device.
+
+    Not intended to be directly inherited by integrations. Integrations should
+    inherit TrackerEntity, BaseScannerEntity or ScannerEntity instead.
+    """
+
+    _attr_device_info: None = None
+    _attr_entity_category = EntityCategory.DIAGNOSTIC
+    _attr_source_type: SourceType
+
+    @cached_property
+    def battery_level(self) -> int | None:
+        """Return the battery level of the device.
+
+        Percentage from 0-100.
+        """
+        return None
+
+    @property
+    def source_type(self) -> SourceType:
+        """Return the source type, eg gps or router, of the device."""
+        if hasattr(self, "_attr_source_type"):
+            return self._attr_source_type
+        raise NotImplementedError
+
+    @property
+    def state_attributes(self) -> dict[str, Any]:
+        """Return the device state attributes."""
+        attr: dict[str, Any] = {ATTR_SOURCE_TYPE: self.source_type}
+
+        if self.battery_level is not None:
+            attr[ATTR_BATTERY_LEVEL] = self.battery_level
+
+        return attr
+
+
+class TrackerEntityDescription(EntityDescription, frozen_or_thawed=True):
+    """A class that describes tracker entities."""
+
+
+CACHED_TRACKER_PROPERTIES_WITH_ATTR_ = {
+    "in_zones",
+    "latitude",
+    "location_accuracy",
+    "location_name",
+    "longitude",
+}
+
+
+class TrackerEntity(
+    BaseTrackerEntity, cached_properties=CACHED_TRACKER_PROPERTIES_WITH_ATTR_
+):
+    """Base class for a tracked device."""
+
+    entity_description: TrackerEntityDescription
+    _attr_in_zones: list[str] | None = None
+    _attr_latitude: float | None = None
+    _attr_location_accuracy: float = 0
+    _attr_location_name: str | None = None
+    _attr_longitude: float | None = None
+    _attr_source_type: SourceType = SourceType.GPS
+
+    __active_zone: State | None = None
+    __in_zones: list[str] | None = None
+
+    @cached_property
+    def should_poll(self) -> bool:
+        """No polling for entities that have location pushed."""
+        return False
+
+    @property
+    def force_update(self) -> bool:
+        """All updates need to be written to the state machine if we're not polling."""
+        return not self.should_poll
+
+    @cached_property
+    def in_zones(self) -> list[str] | None:
+        """Return the entity_id of zones the device is currently in.
+
+        The list may be in any order; the base class sorts it by zone radius
+        and discards zones which do not exist. Takes precedence over latitude
+        and longitude when set (including when set to an empty list).
+        """
+        return self._attr_in_zones
+
+    @cached_property
+    def location_accuracy(self) -> float:
+        """Return the location accuracy of the device.
+
+        Value in meters.
+        """
+        return self._attr_location_accuracy
+
+    @cached_property
+    def location_name(self) -> str | None:
+        """Return a location name for the current location of the device."""
+        return self._attr_location_name
+
+    @cached_property
+    def latitude(self) -> float | None:
+        """Return latitude value of the device."""
+        return self._attr_latitude
+
+    @cached_property
+    def longitude(self) -> float | None:
+        """Return longitude value of the device."""
+        return self._attr_longitude
+
+    @callback
+    def _async_write_ha_state(self) -> None:
+        """Calculate active zones."""
+        if (zones := self.in_zones) is not None:
+            zone_states = sorted(
+                (
+                    zone_state
+                    for entity_id in zones
+                    if (zone_state := self.hass.states.get(entity_id)) is not None
+                ),
+                key=lambda z: z.attributes[ATTR_RADIUS],
+            )
+            self.__active_zone = next(
+                (z for z in zone_states if not z.attributes.get(ATTR_PASSIVE)),
+                None,
+            )
+            self.__in_zones = [z.entity_id for z in zone_states]
+        elif (
+            self.available and self.latitude is not None and self.longitude is not None
+        ):
+            self.__active_zone, self.__in_zones = zone.async_in_zones(
+                self.hass, self.latitude, self.longitude, self.location_accuracy
+            )
+        else:
+            self.__active_zone = None
+            self.__in_zones = None
+        super()._async_write_ha_state()
+
+    @property
+    def state(self) -> str | None:
+        """Return the state of the device."""
+        if self.location_name is not None:
+            return self.location_name
+
+        if (
+            self.latitude is not None and self.longitude is not None
+        ) or self.__in_zones is not None:
+            zone_state = self.__active_zone
+            if zone_state is None:
+                state = STATE_NOT_HOME
+            elif zone_state.entity_id == zone.ENTITY_ID_HOME:
+                state = STATE_HOME
+            else:
+                state = zone_state.name
+            return state
+
+        return None
+
+    @final
+    @property
+    def state_attributes(self) -> dict[str, Any]:
+        """Return the device state attributes."""
+        attr: dict[str, Any] = {ATTR_IN_ZONES: self.__in_zones or []}
+        attr.update(super().state_attributes)
+
+        if self.latitude is not None and self.longitude is not None:
+            attr[ATTR_LATITUDE] = self.latitude
+            attr[ATTR_LONGITUDE] = self.longitude
+            attr[ATTR_GPS_ACCURACY] = self.location_accuracy
+
+        return attr
+
+
+class BaseScannerEntity(BaseTrackerEntity):
+    """Base class for a tracked device that can be connected or disconnected.
+
+    Unlike ScannerEntity, this entity does not make assumptions about MAC
+    addresses being used to identify the device.
+    """
+
+    _scanner_option_associated_zone: str = zone.ENTITY_ID_HOME
+    _scanner_option_associated_zone_unsub: CALLBACK_TYPE | None = None
+
+    async def async_internal_added_to_hass(self) -> None:
+        """Call when the scanner entity is added to hass."""
+        await super().async_internal_added_to_hass()
+        if not self.registry_entry:
+            return
+        self._async_read_entity_options()
+
+    async def async_internal_will_remove_from_hass(self) -> None:
+        """Call when the scanner entity is about to be removed from hass."""
+        await super().async_internal_will_remove_from_hass()
+        if not self.registry_entry:
+            return
+        if self._scanner_option_associated_zone_unsub is not None:
+            self._scanner_option_associated_zone_unsub()
+            self._scanner_option_associated_zone_unsub = None
+        self._async_clear_associated_zone_issue()
+
+    @callback
+    def async_registry_entry_updated(self) -> None:
+        """Run when the entity registry entry has been updated."""
+        self._async_read_entity_options()
+
+    @callback
+    def _async_read_entity_options(self) -> None:
+        """Read entity options from the entity registry.
+
+        Called when the entity registry entry has been updated and before the
+        scanner entity is added to the state machine.
+        """
+        assert self.registry_entry
+        if (scanner_options := self.registry_entry.options.get(DOMAIN)) and (
+            associated_zone := scanner_options.get(CONF_ASSOCIATED_ZONE)
+        ):
+            new_zone = associated_zone
+        else:
+            new_zone = zone.ENTITY_ID_HOME
+
+        if new_zone == self._scanner_option_associated_zone:
+            return
+
+        # Tear down tracking for the previous zone.
+        if self._scanner_option_associated_zone_unsub is not None:
+            self._scanner_option_associated_zone_unsub()
+            self._scanner_option_associated_zone_unsub = None
+        self._async_clear_associated_zone_issue()
+
+        self._scanner_option_associated_zone = new_zone
+
+        # zone.home is always present so no tracking or issue handling needed.
+        if new_zone == zone.ENTITY_ID_HOME:
+            return
+
+        self._scanner_option_associated_zone_unsub = async_track_state_change_event(
+            self.hass, new_zone, self._async_associated_zone_state_changed
+        )
+        if self.hass.states.get(new_zone) is None:
+            self._async_create_associated_zone_issue()
+
+    @callback
+    def _async_associated_zone_state_changed(
+        self, event: Event[EventStateChangedData]
+    ) -> None:
+        """Open or clear the repair issue when the associated zone appears or disappears."""
+        if event.data["new_state"] is None:
+            self._async_create_associated_zone_issue()
+        else:
+            self._async_clear_associated_zone_issue()
+        self.async_write_ha_state()
+
+    @callback
+    def _async_create_associated_zone_issue(self) -> None:
+        """Create a repair issue prompting the user to reconfigure the scanner."""
+        ir.async_create_issue(
+            self.hass,
+            DOMAIN,
+            self._associated_zone_issue_id,
+            is_fixable=False,
+            severity=ir.IssueSeverity.WARNING,
+            translation_key="associated_zone_missing",
+            translation_placeholders={
+                "entity_id": self.entity_id,
+                "zone": self._scanner_option_associated_zone,
+            },
+        )
+
+    @callback
+    def _async_clear_associated_zone_issue(self) -> None:
+        """Clear the associated-zone-missing repair issue if it exists."""
+        ir.async_delete_issue(self.hass, DOMAIN, self._associated_zone_issue_id)
+
+    @property
+    def _associated_zone_issue_id(self) -> str:
+        """Return the issue id for the associated-zone-missing repair."""
+        if TYPE_CHECKING:
+            assert self.registry_entry
+        return f"associated_zone_missing_{self.registry_entry.id}"
+
+    @property
+    def state(self) -> str | None:
+        """Return the state of the device."""
+        if self.is_connected is None:
+            return None
+        if not self.is_connected:
+            return STATE_NOT_HOME
+        associated_zone = self._scanner_option_associated_zone
+        if associated_zone == zone.ENTITY_ID_HOME:
+            return STATE_HOME
+        if zone_state := self.hass.states.get(associated_zone):
+            return zone_state.name
+        # Configured zone has been removed; state is unknown.
+        return None
+
+    @property
+    def is_connected(self) -> bool | None:
+        """Return true if the device is connected."""
+        raise NotImplementedError
+
+    @final
+    @property
+    def state_attributes(self) -> dict[str, Any]:
+        """Return the device state attributes."""
+        attr: dict[str, Any] = {ATTR_IN_ZONES: []}
+        attr.update(super().state_attributes)
+
+        if not self.is_connected:
+            return attr
+
+        associated_zone = self._scanner_option_associated_zone
+        # If the configured zone has been removed, in_zones stays empty so the
+        # attribute does not claim membership in a zone that no longer exists.
+        if (
+            associated_zone != zone.ENTITY_ID_HOME
+            and self.hass.states.get(associated_zone) is None
+        ):
+            return attr
+
+        attr[ATTR_IN_ZONES] = [
+            associated_zone,
+            *zone.async_get_enclosing_zones(self.hass, associated_zone),
+        ]
+
+        return attr
+
+
+class ScannerEntityDescription(EntityDescription, frozen_or_thawed=True):
+    """A class that describes tracker entities."""
+
+
+CACHED_SCANNER_PROPERTIES_WITH_ATTR_ = {
+    "ip_address",
+    "mac_address",
+    "hostname",
+}
+
+
+class ScannerEntity(
+    BaseScannerEntity, cached_properties=CACHED_SCANNER_PROPERTIES_WITH_ATTR_
+):
+    """Base class for a tracked device that is on a scanned network."""
+
+    entity_description: ScannerEntityDescription
+    _attr_hostname: str | None = None
+    _attr_ip_address: str | None = None
+    _attr_mac_address: str | None = None
+    _attr_source_type: SourceType = SourceType.ROUTER
+
+    @cached_property
+    def ip_address(self) -> str | None:
+        """Return the primary ip address of the device."""
+        return self._attr_ip_address
+
+    @cached_property
+    def mac_address(self) -> str | None:
+        """Return the mac address of the device."""
+        return self._attr_mac_address
+
+    @cached_property
+    def hostname(self) -> str | None:
+        """Return hostname of the device."""
+        return self._attr_hostname
+
+    @property
+    def unique_id(self) -> str | None:
+        """Return unique ID of the entity."""
+        return self.mac_address
+
+    @final
+    @property
+    def device_info(self) -> DeviceInfo | None:
+        """Device tracker entities should not create device registry entries."""
+        return None
+
+    @property
+    def entity_registry_enabled_default(self) -> bool:
+        """Return if entity is enabled by default."""
+        # If mac_address is None, we can never find a device entry.
+        return (
+            # Do not disable if we won't activate our attach to device logic
+            self.mac_address is None
+            or self.device_info is not None
+            # Disable if we automatically attach but there is no device
+            or self.find_device_entry() is not None
+        )
+
+    @callback
+    def add_to_platform_start(
+        self,
+        hass: HomeAssistant,
+        platform: EntityPlatform,
+        parallel_updates: asyncio.Semaphore | None,
+    ) -> None:
+        """Start adding an entity to a platform."""
+        super().add_to_platform_start(hass, platform, parallel_updates)
+        if self.mac_address and self.unique_id:
+            _async_register_mac(
+                hass,
+                platform.platform_name,
+                self.mac_address,
+                self.unique_id,
+            )
+            if self.is_connected and self.ip_address:
+                _async_connected_device_registered(
+                    hass,
+                    self.mac_address,
+                    self.ip_address,
+                    self.hostname,
+                )
+
+    @callback
+    def find_device_entry(self) -> dr.DeviceEntry | None:
+        """Return device entry."""
+        assert self.mac_address is not None
+
+        return dr.async_get(self.hass).async_get_device(
+            connections={(dr.CONNECTION_NETWORK_MAC, self.mac_address)}
+        )
+
+    async def async_internal_added_to_hass(self) -> None:
+        """Handle added to Home Assistant."""
+        # Entities without a unique ID don't have a device
+        if (
+            not self.registry_entry
+            or not self.platform.config_entry
+            or not self.mac_address
+            or (device_entry := self.find_device_entry()) is None
+            # Entities should not have a device info. We opt them out
+            # of this logic if they do.
+            or self.device_info
+        ):
+            if self.device_info:
+                LOGGER.debug("Entity %s unexpectedly has a device info", self.entity_id)
+            await super().async_internal_added_to_hass()
+            return
+
+        # Attach entry to device
+        if self.registry_entry.device_id != device_entry.id:
+            self.registry_entry = er.async_get(self.hass).async_update_entity(
+                self.entity_id, device_id=device_entry.id
+            )
+
+        # Attach device to config entry
+        if self.platform.config_entry.entry_id not in device_entry.config_entries:
+            dr.async_get(self.hass).async_update_device(
+                device_entry.id,
+                add_config_entry_id=self.platform.config_entry.entry_id,
+            )
+
+        # Do this last or else the entity registry update listener has been installed
+        await super().async_internal_added_to_hass()
+
+    # BaseScannerEntity.state_attributes is @final to keep external subclasses
+    # from tampering with it; ScannerEntity is an in-tree subclass that
+    # intentionally extends it with ip/mac/hostname.
+    @final  # type: ignore[misc]
+    @property
+    def state_attributes(self) -> dict[str, Any]:
+        """Return the device state attributes."""
+        attr = super().state_attributes
+
+        if ip_address := self.ip_address:
+            attr[ATTR_IP] = ip_address
+        if (mac_address := self.mac_address) is not None:
+            attr[ATTR_MAC] = mac_address
+        if (hostname := self.hostname) is not None:
+            attr[ATTR_HOST_NAME] = hostname
+
+        return attr

homeassistant/components/device_tracker/legacy.py

@@ -38,6 +38,9 @@ from homeassistant.const import (
 from homeassistant.core import Event, HomeAssistant, ServiceCall, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv, entity_registry as er
+from homeassistant.helpers.entity_platform import (
+    async_create_platform_config_not_supported_issue,
+)
 from homeassistant.helpers.event import (
     async_track_time_interval,
     async_track_utc_time_change,
@@ -379,8 +382,8 @@ async def async_extract_config(
         if platform.type == PLATFORM_TYPE_LEGACY:
             legacy.append(platform)
         else:
-            raise ValueError(
-                f"Unable to determine type for {platform.name}: {platform.type}"
+            async_create_platform_config_not_supported_issue(
+                hass, platform.name, DOMAIN
             )
 
     return legacy

homeassistant/components/device_tracker/strings.json

@@ -44,6 +44,12 @@
       }
     }
   },
+  "issues": {
+    "associated_zone_missing": {
+      "description": "The scanner entity `{entity_id}` is associated with the zone `{zone}`, but that zone has been removed.\n\nTo fix this, reconfigure the scanner to use a different zone or recreate the missing zone.",
+      "title": "Scanner is associated with a removed zone"
+    }
+  },
   "services": {
     "see": {
       "description": "Manually update the records of a seen legacy device tracker in the known_devices.yaml file.",

homeassistant/components/dhcp/manifest.json

@@ -15,8 +15,8 @@
   ],
   "quality_scale": "internal",
   "requirements": [
-    "aiodhcpwatcher==1.2.6",
-    "aiodiscover==3.2.3",
+    "aiodhcpwatcher==1.2.7",
+    "aiodiscover==3.2.4",
     "cached-ipaddress==1.1.1"
   ]
 }

homeassistant/components/door/triggers.yaml

@@ -1,7 +1,7 @@
 .trigger_common_fields: &trigger_common_fields
   behavior:
     required: true
-    default: any
+    default: each
     selector:
       automation_behavior:
         mode: trigger

homeassistant/components/duco/config_flow.py

@@ -15,6 +15,7 @@ from homeassistant.helpers.service_info.dhcp import DhcpServiceInfo
 from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
 
 from .const import DOMAIN
+from .validation import UnsupportedBoardError, async_get_supported_board_info
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -43,6 +44,11 @@ class DucoConfigFlow(ConfigFlow, domain=DOMAIN):
 
         try:
             box_name, _ = await self._validate_input(discovery_info.ip)
+        except UnsupportedBoardError:
+            _LOGGER.debug(
+                "Unsupported Duco board discovered via DHCP at %s", discovery_info.ip
+            )
+            return self.async_abort(reason="unsupported_board")
         except DucoConnectionError:
             return self.async_abort(reason="cannot_connect")
         except DucoError:
@@ -61,6 +67,12 @@ class DucoConfigFlow(ConfigFlow, domain=DOMAIN):
         """Handle zeroconf discovery."""
         try:
             box_name, mac = await self._validate_input(discovery_info.host)
+        except UnsupportedBoardError:
+            _LOGGER.debug(
+                "Unsupported Duco board discovered via zeroconf at %s",
+                discovery_info.host,
+            )
+            return self.async_abort(reason="unsupported_board")
         except DucoConnectionError:
             return self.async_abort(reason="cannot_connect")
         except DucoError:
@@ -102,6 +114,8 @@ class DucoConfigFlow(ConfigFlow, domain=DOMAIN):
         if user_input is not None:
             try:
                 box_name, mac = await self._validate_input(user_input[CONF_HOST])
+            except UnsupportedBoardError:
+                errors["base"] = "unsupported_board"
             except DucoConnectionError:
                 errors["base"] = "cannot_connect"
             except DucoError:
@@ -133,6 +147,8 @@ class DucoConfigFlow(ConfigFlow, domain=DOMAIN):
         if user_input is not None:
             try:
                 box_name, mac = await self._validate_input(user_input[CONF_HOST])
+            except UnsupportedBoardError:
+                errors["base"] = "unsupported_board"
             except DucoConnectionError:
                 errors["base"] = "cannot_connect"
             except DucoError:
@@ -162,6 +178,6 @@ class DucoConfigFlow(ConfigFlow, domain=DOMAIN):
             session=async_get_clientsession(self.hass),
             host=host,
         )
-        board_info = await client.async_get_board_info()
+        board_info = await async_get_supported_board_info(client)
         lan_info = await client.async_get_lan_info()
         return board_info.box_name, lan_info.mac

homeassistant/components/duco/coordinator.py

@@ -4,7 +4,11 @@ from dataclasses import dataclass
 import logging
 
 from duco_connectivity import DucoClient
-from duco_connectivity.exceptions import DucoConnectionError, DucoError
+from duco_connectivity.exceptions import (
+    DucoConnectionError,
+    DucoError,
+    DucoResponseError,
+)
 from duco_connectivity.models import BoardInfo, Node
 
 from homeassistant.config_entries import ConfigEntry
@@ -13,6 +17,7 @@ from homeassistant.exceptions import ConfigEntryError
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 from .const import DOMAIN, SCAN_INTERVAL
+from .validation import UnsupportedBoardError, async_get_supported_board_info
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -52,7 +57,18 @@ class DucoCoordinator(DataUpdateCoordinator[DucoData]):
     async def _async_setup(self) -> None:
         """Fetch board info once during initial setup."""
         try:
-            self.board_info = await self.client.async_get_board_info()
+            self.board_info = await async_get_supported_board_info(self.client)
+        except UnsupportedBoardError as err:
+            raise ConfigEntryError(
+                translation_domain=DOMAIN,
+                translation_key="unsupported_board",
+            ) from err
+        except DucoResponseError as err:
+            raise ConfigEntryError(
+                translation_domain=DOMAIN,
+                translation_key="api_error",
+                translation_placeholders={"error": repr(err)},
+            ) from err
         except DucoConnectionError as err:
             raise UpdateFailed(
                 translation_domain=DOMAIN,
@@ -70,20 +86,6 @@ class DucoCoordinator(DataUpdateCoordinator[DucoData]):
         """Fetch node data from the Duco box."""
         try:
             nodes = await self.client.async_get_nodes()
-        except DucoConnectionError as err:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="cannot_connect",
-                translation_placeholders={"error": repr(err)},
-            ) from err
-        except DucoError as err:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="api_error",
-                translation_placeholders={"error": repr(err)},
-            ) from err
-
-        try:
             lan_info = await self.client.async_get_lan_info()
         except DucoConnectionError as err:
             raise UpdateFailed(

homeassistant/components/duco/strings.json

@@ -6,11 +6,13 @@
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
       "unique_id_mismatch": "The device you entered belongs to a different Duco box.",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
+      "unknown": "[%key:common::config_flow::error::unknown%]",
+      "unsupported_board": "This Duco system is not supported by this integration. The integration requires a Duco Connectivity Board running public API 2.1 or newer."
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
+      "unknown": "[%key:common::config_flow::error::unknown%]",
+      "unsupported_board": "[%key:component::duco::config::abort::unsupported_board%]"
     },
     "step": {
       "discovery_confirm": {
@@ -62,23 +64,23 @@
       "ventilation_state": {
         "name": "Ventilation state",
         "state": {
-          "aut1": "Automatic boost (15 min)",
-          "aut2": "Automatic boost (30 min)",
-          "aut3": "Automatic boost (45 min)",
-          "auto": "Automatic",
-          "cnt1": "Continuous low speed",
-          "cnt2": "Continuous medium speed",
-          "cnt3": "Continuous high speed",
-          "empt": "Empty house",
-          "man1": "Manual low speed (15 min)",
-          "man1x2": "Manual low speed (30 min)",
-          "man1x3": "Manual low speed (45 min)",
-          "man2": "Manual medium speed (15 min)",
-          "man2x2": "Manual medium speed (30 min)",
-          "man2x3": "Manual medium speed (45 min)",
-          "man3": "Manual high speed (15 min)",
-          "man3x2": "Manual high speed (30 min)",
-          "man3x3": "Manual high speed (45 min)"
+          "aut1": "AUT1",
+          "aut2": "AUT2",
+          "aut3": "AUT3",
+          "auto": "AUTO",
+          "cnt1": "CNT1",
+          "cnt2": "CNT2",
+          "cnt3": "CNT3",
+          "empt": "EMPT",
+          "man1": "MAN1",
+          "man1x2": "MAN1x2",
+          "man1x3": "MAN1x3",
+          "man2": "MAN2",
+          "man2x2": "MAN2x2",
+          "man2x3": "MAN2x3",
+          "man3": "MAN3",
+          "man3x2": "MAN3x2",
+          "man3x3": "MAN3x3"
         }
       }
     }
@@ -98,6 +100,9 @@
     },
     "rate_limit_exceeded": {
       "message": "The Duco device has reached its daily write limit. Try again tomorrow."
+    },
+    "unsupported_board": {
+      "message": "[%key:component::duco::config::abort::unsupported_board%]"
     }
   },
   "system_health": {

homeassistant/components/duco/validation.py

@@ -0,0 +1,58 @@
+"""Validation helpers for supported Duco systems."""
+
+from awesomeversion import (
+    AwesomeVersion,
+    AwesomeVersionStrategy,
+    AwesomeVersionStrategyException,
+)
+from duco_connectivity import DucoClient
+from duco_connectivity.exceptions import DucoResponseError
+from duco_connectivity.models import BoardInfo
+
+# Newer Connectivity boards expose /info with PublicApiVersion. We use that
+# endpoint to distinguish supported Connectivity hardware from older
+# Communication board V1 hardware.
+_MIN_PUBLIC_API_VERSION = AwesomeVersion(
+    "2.1", ensure_strategy=AwesomeVersionStrategy.SIMPLEVER
+)
+
+
+class UnsupportedBoardError(Exception):
+    """Raised when the Duco system is not supported by this integration."""
+
+
+def validate_board_support(board_info: BoardInfo) -> None:
+    """Raise UnsupportedBoardError if the board does not meet support requirements."""
+    version = board_info.public_api_version
+    if version is None:
+        raise UnsupportedBoardError("Board did not report a public API version")
+    try:
+        parsed_version = AwesomeVersion(
+            version, ensure_strategy=AwesomeVersionStrategy.SIMPLEVER
+        )
+    except AwesomeVersionStrategyException as err:
+        raise UnsupportedBoardError(
+            f"Board reported malformed public API version: {version}"
+        ) from err
+    if parsed_version < _MIN_PUBLIC_API_VERSION:
+        raise UnsupportedBoardError(
+            "Board public API version "
+            f"{version} is below the supported minimum {_MIN_PUBLIC_API_VERSION}"
+        )
+
+
+async def async_get_supported_board_info(client: DucoClient) -> BoardInfo:
+    """Fetch and validate board info for a supported Duco system."""
+    try:
+        board_info = await client.async_get_board_info()
+    except DucoResponseError as err:
+        if err.status == 404:
+            # Duco indicated that Communication board V1 does not implement
+            # /info, so a 404 is enough to treat the device as unsupported.
+            raise UnsupportedBoardError(
+                "Board does not expose the /info endpoint"
+            ) from err
+        raise
+
+    validate_board_support(board_info)
+    return board_info

homeassistant/components/eafm/config_flow.py

@@ -41,7 +41,7 @@ class UKFloodsFlowHandler(ConfigFlow, domain=DOMAIN):
         self.stations = {}
         for station in stations:
             label = station["label"]
-            rloId = station["RLOIid"]
+            rlo_id = station["RLOIid"]
 
             # API annoyingly sometimes returns a list and some times returns a string
             # E.g. L3121 has a label of ['Scurf Dyke', 'Scurf Dyke Dyke Level']
@@ -50,11 +50,11 @@ class UKFloodsFlowHandler(ConfigFlow, domain=DOMAIN):
 
             # Similar for RLOIid
             # E.g. 0018 has an RLOIid of ['10427', '9154']
-            if isinstance(rloId, list):
-                rloId = rloId[-1]
+            if isinstance(rlo_id, list):
+                rlo_id = rlo_id[-1]
 
-            fullName = label + " - " + rloId
-            self.stations[fullName] = station["stationReference"]
+            full_name = label + " - " + rlo_id
+            self.stations[full_name] = station["stationReference"]
 
         if not self.stations:
             return self.async_abort(reason="no_stations")

homeassistant/components/ecobee/__init__.py

@@ -8,12 +8,16 @@ from pyecobee import (
     ECOBEE_REFRESH_TOKEN,
     ECOBEE_USERNAME,
     Ecobee,
+    EcobeeAuthFailedError,
+    EcobeeAuthMfaRequiredError,
+    EcobeeAuthUnknownError,
     ExpiredTokenError,
 )
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_API_KEY, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.util import Throttle
 
 from .const import _LOGGER, CONF_REFRESH_TOKEN, PLATFORMS
@@ -102,7 +106,26 @@ class EcobeeData:
     async def refresh(self) -> bool:
         """Refresh ecobee tokens and update config entry."""
         _LOGGER.debug("Refreshing ecobee tokens and updating config entry")
-        if await self._hass.async_add_executor_job(self.ecobee.refresh_tokens):
+        try:
+            success = await self._hass.async_add_executor_job(
+                self.ecobee.refresh_tokens
+            )
+        except EcobeeAuthMfaRequiredError as err:
+            raise ConfigEntryAuthFailed(
+                "ecobee account requires MFA; reauthentication needed"
+            ) from err
+        except EcobeeAuthFailedError as err:
+            if self.ecobee.config.get(ECOBEE_USERNAME):
+                raise ConfigEntryAuthFailed(
+                    "ecobee rejected stored credentials"
+                ) from err
+            _LOGGER.error("Ecobee rejected stored credentials: %s", err)
+            return False
+        except EcobeeAuthUnknownError:
+            _LOGGER.exception("Unexpected error refreshing ecobee tokens")
+            return False
+
+        if success:
             data = {}
             if self.ecobee.config.get(ECOBEE_API_KEY):
                 data = {

homeassistant/components/ecobee/config_flow.py

@@ -1,12 +1,22 @@
 """Config flow to configure ecobee."""
 
+from collections.abc import Mapping
 from typing import Any
 
-from pyecobee import ECOBEE_API_KEY, ECOBEE_PASSWORD, ECOBEE_USERNAME, Ecobee
+from pyecobee import (
+    ECOBEE_API_KEY,
+    ECOBEE_PASSWORD,
+    ECOBEE_USERNAME,
+    Ecobee,
+    EcobeeAuthFailedError,
+    EcobeeAuthMfaRequiredError,
+    EcobeeAuthUnknownError,
+    MfaChallenge,
+)
 import voluptuous as vol
 
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_API_KEY, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_API_KEY, CONF_CODE, CONF_PASSWORD, CONF_USERNAME
 
 from .const import CONF_REFRESH_TOKEN, DOMAIN
 
@@ -18,6 +28,9 @@ _USER_SCHEMA = vol.Schema(
     }
 )
 
+_MFA_SCHEMA = vol.Schema({vol.Required(CONF_CODE): str})
+_REAUTH_SCHEMA = vol.Schema({vol.Required(CONF_PASSWORD): str})
+
 
 class EcobeeFlowHandler(ConfigFlow, domain=DOMAIN):
     """Handle an ecobee config flow."""
@@ -25,12 +38,15 @@ class EcobeeFlowHandler(ConfigFlow, domain=DOMAIN):
     VERSION = 1
 
     _ecobee: Ecobee
+    _mfa_challenge: MfaChallenge | None = None
+    _pending_username: str | None = None
+    _pending_password: str | None = None
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle a flow initiated by the user."""
-        errors = {}
+        errors: dict[str, str] = {}
 
         if user_input is not None:
             api_key = user_input.get(CONF_API_KEY)
@@ -38,27 +54,34 @@ class EcobeeFlowHandler(ConfigFlow, domain=DOMAIN):
             password = user_input.get(CONF_PASSWORD)
 
             if api_key and not (username or password):
-                # Use the user-supplied API key to attempt to obtain a PIN from ecobee.
                 self._ecobee = Ecobee(config={ECOBEE_API_KEY: api_key})
                 if await self.hass.async_add_executor_job(self._ecobee.request_pin):
-                    # We have a PIN; move to the next step of the flow.
                     return await self.async_step_authorize()
                 errors["base"] = "pin_request_failed"
             elif username and password and not api_key:
+                self._pending_username = username
+                self._pending_password = password
                 self._ecobee = Ecobee(
                     config={
                         ECOBEE_USERNAME: username,
                         ECOBEE_PASSWORD: password,
                     }
                 )
-                if await self.hass.async_add_executor_job(self._ecobee.refresh_tokens):
-                    config = {
-                        CONF_USERNAME: username,
-                        CONF_PASSWORD: password,
-                        CONF_REFRESH_TOKEN: self._ecobee.refresh_token,
-                    }
-                    return self.async_create_entry(title=DOMAIN, data=config)
-                errors["base"] = "login_failed"
+                try:
+                    success = await self.hass.async_add_executor_job(
+                        self._ecobee.refresh_tokens
+                    )
+                except EcobeeAuthMfaRequiredError as err:
+                    self._mfa_challenge = err.args[0]
+                    return await self.async_step_mfa()
+                except EcobeeAuthFailedError:
+                    errors["base"] = "invalid_auth"
+                except EcobeeAuthUnknownError:
+                    errors["base"] = "unknown"
+                else:
+                    if success:
+                        return self._async_create_or_update_entry()
+                    errors["base"] = "login_failed"
             else:
                 errors["base"] = "invalid_auth"
 
@@ -68,16 +91,46 @@ class EcobeeFlowHandler(ConfigFlow, domain=DOMAIN):
             errors=errors,
         )
 
+    async def async_step_mfa(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Collect an MFA OTP code and complete the login."""
+        assert self._mfa_challenge is not None
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            code = user_input[CONF_CODE].strip()
+            if not code:
+                errors["base"] = "invalid_mfa_code"
+            else:
+                try:
+                    success = await self.hass.async_add_executor_job(
+                        self._ecobee.submit_mfa_code, self._mfa_challenge, code
+                    )
+                except EcobeeAuthFailedError:
+                    errors["base"] = "invalid_mfa_code"
+                except EcobeeAuthUnknownError:
+                    errors["base"] = "unknown"
+                else:
+                    if success:
+                        return self._async_create_or_update_entry()
+                    errors["base"] = "invalid_mfa_code"
+
+        return self.async_show_form(
+            step_id="mfa",
+            data_schema=_MFA_SCHEMA,
+            errors=errors,
+            description_placeholders={"mfa_type": self._mfa_challenge.mfa_type},
+        )
+
     async def async_step_authorize(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
-        """Present the user with the PIN to authorize on ecobee.com."""
-        errors = {}
+        """Present the user with the PIN so that the app can be authorized on ecobee.com."""
+        errors: dict[str, str] = {}
 
         if user_input is not None:
-            # Attempt to obtain tokens from ecobee and finish the flow.
             if await self.hass.async_add_executor_job(self._ecobee.request_tokens):
-                # Refresh token obtained; create the config entry.
                 config = {
                     CONF_API_KEY: self._ecobee.api_key,
                     CONF_REFRESH_TOKEN: self._ecobee.refresh_token,
@@ -93,3 +146,61 @@ class EcobeeFlowHandler(ConfigFlow, domain=DOMAIN):
                 "auth_url": "https://www.ecobee.com/consumerportal/index.html",
             },
         )
+
+    async def async_step_reauth(
+        self, entry_data: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Perform reauth upon an ecobee authentication error."""
+        self._pending_username = entry_data.get(CONF_USERNAME)
+        self._pending_password = entry_data.get(CONF_PASSWORD)
+        return await self.async_step_reauth_confirm()
+
+    async def async_step_reauth_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Re-run the web login. May surface a fresh MFA challenge."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            self._pending_password = user_input[CONF_PASSWORD]
+            self._ecobee = Ecobee(
+                config={
+                    ECOBEE_USERNAME: self._pending_username,
+                    ECOBEE_PASSWORD: self._pending_password,
+                }
+            )
+            try:
+                success = await self.hass.async_add_executor_job(
+                    self._ecobee.refresh_tokens
+                )
+            except EcobeeAuthMfaRequiredError as err:
+                self._mfa_challenge = err.args[0]
+                return await self.async_step_mfa()
+            except EcobeeAuthFailedError:
+                errors["base"] = "invalid_auth"
+            except EcobeeAuthUnknownError:
+                errors["base"] = "unknown"
+            else:
+                if success:
+                    return self._async_create_or_update_entry()
+                errors["base"] = "login_failed"
+
+        return self.async_show_form(
+            step_id="reauth_confirm",
+            data_schema=_REAUTH_SCHEMA,
+            errors=errors,
+            description_placeholders={"username": self._pending_username or ""},
+        )
+
+    def _async_create_or_update_entry(self) -> ConfigFlowResult:
+        """Create a new entry or update the existing one on reauth."""
+        data = {
+            CONF_USERNAME: self._pending_username,
+            CONF_PASSWORD: self._pending_password,
+            CONF_REFRESH_TOKEN: self._ecobee.refresh_token,
+        }
+        if self.source == SOURCE_REAUTH:
+            return self.async_update_reload_and_abort(
+                self._get_reauth_entry(), data=data
+            )
+        return self.async_create_entry(title=DOMAIN, data=data)

homeassistant/components/ecobee/strings.json

@@ -1,18 +1,33 @@
 {
   "config": {
     "abort": {
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
       "single_instance_allowed": "[%key:common::config_flow::abort::single_instance_allowed%]"
     },
     "error": {
       "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "invalid_mfa_code": "The MFA code was not accepted by ecobee; please try again.",
       "login_failed": "Error authenticating with ecobee; please verify your credentials are correct.",
       "pin_request_failed": "Error requesting PIN from ecobee; please verify API key is correct.",
-      "token_request_failed": "Error requesting tokens from ecobee; please try again."
+      "token_request_failed": "Error requesting tokens from ecobee; please try again.",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "step": {
       "authorize": {
         "description": "Please authorize this app at {auth_url} with PIN code:\n\n{pin}\n\nThen, select **Submit**."
       },
+      "mfa": {
+        "data": {
+          "code": "MFA code"
+        },
+        "description": "ecobee requires multi-factor authentication. Enter the {mfa_type} code from your authenticator app."
+      },
+      "reauth_confirm": {
+        "data": {
+          "password": "[%key:common::config_flow::data::password%]"
+        },
+        "description": "Reauthenticate the ecobee account for **{username}**."
+      },
       "user": {
         "data": {
           "api_key": "[%key:common::config_flow::data::api_key%]"

homeassistant/components/edl21/config_flow.py

@@ -3,12 +3,13 @@
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.helpers.selector import SerialPortSelector
 
 from .const import CONF_SERIAL_PORT, DEFAULT_TITLE, DOMAIN
 
 DATA_SCHEMA = vol.Schema(
     {
-        vol.Required(CONF_SERIAL_PORT): str,
+        vol.Required(CONF_SERIAL_PORT): SerialPortSelector(),
     }
 )
 

homeassistant/components/edl21/manifest.json

@@ -4,8 +4,8 @@
   "codeowners": [],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/edl21",
-  "integration_type": "hub",
+  "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["sml"],
-  "requirements": ["pysml==0.1.5"]
+  "requirements": ["pysml==0.1.7"]
 }

homeassistant/components/edl21/sensor.py

@@ -1,7 +1,6 @@
 """Support for EDL21 Smart Meters."""
 
 from collections.abc import Mapping
-from datetime import timedelta
 from typing import Any
 
 from sml import SmlGetListResponse
@@ -29,7 +28,6 @@ from homeassistant.helpers.dispatcher import (
     async_dispatcher_send,
 )
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.util.dt import utcnow
 
 from .const import (
     CONF_SERIAL_PORT,
@@ -39,8 +37,6 @@ from .const import (
     SIGNAL_EDL21_TELEGRAM,
 )
 
-MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=60)
-
 # OBIS format: A-B:C.D.E*F
 SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
     # A=1: Electricity
@@ -391,8 +387,6 @@ class EDL21Entity(SensorEntity):
         self._electricity_id = electricity_id
         self._obis = obis
         self._telegram = telegram
-        self._min_time = MIN_TIME_BETWEEN_UPDATES
-        self._last_update = utcnow()
         self._async_remove_dispatcher = None
         self.entity_description = entity_description
         self._attr_unique_id = f"{electricity_id}_{obis}"
@@ -414,12 +408,7 @@ class EDL21Entity(SensorEntity):
             if self._telegram == telegram:
                 return
 
-            now = utcnow()
-            if now - self._last_update < self._min_time:
-                return
-
             self._telegram = telegram
-            self._last_update = now
             self.async_write_ha_state()
 
         self._async_remove_dispatcher = async_dispatcher_connect(

homeassistant/components/edl21/strings.json

@@ -6,7 +6,10 @@
     "step": {
       "user": {
         "data": {
-          "serial_port": "[%key:common::config_flow::data::usb_path%]"
+          "serial_port": "[%key:common::config_flow::data::port%]"
+        },
+        "data_description": {
+          "serial_port": "Serial port path to connect to"
         },
         "title": "Add your EDL21 smart meter"
       }

homeassistant/components/elkm1/const.py

@@ -40,6 +40,7 @@ ELK_ELEMENTS = {
 EVENT_ELKM1_KEYPAD_KEY_PRESSED = "elkm1.keypad_key_pressed"
 
 
+ATTR_DURATION = "duration"
 ATTR_KEYPAD_ID = "keypad_id"
 ATTR_KEY = "key"
 ATTR_KEY_NAME = "key_name"

homeassistant/components/elkm1/icons.json

@@ -48,6 +48,9 @@
     },
     "speak_word": {
       "service": "mdi:message-minus"
+    },
+    "switch_output_turn_on_for": {
+      "service": "mdi:timer"
     }
   }
 }

homeassistant/components/elkm1/services.yaml

@@ -161,3 +161,15 @@ sensor_zone_trigger:
     entity:
       integration: elkm1
       domain: sensor
+
+switch_output_turn_on_for:
+  target:
+    entity:
+      integration: elkm1
+      domain: switch
+  fields:
+    duration:
+      example: 42
+      required: true
+      selector:
+        duration:

homeassistant/components/elkm1/strings.json

@@ -210,6 +210,16 @@
         }
       },
       "name": "Speak word"
+    },
+    "switch_output_turn_on_for": {
+      "description": "Turns on an output for a specified length of time.",
+      "fields": {
+        "duration": {
+          "description": "Length of time to turn the output on for.",
+          "name": "Duration"
+        }
+      },
+      "name": "Switch output turn on for"
     }
   }
 }

homeassistant/components/elkm1/switch.py

@@ -1,5 +1,7 @@
 """Support for control of ElkM1 outputs (relays)."""
 
+from datetime import timedelta
+from math import ceil
 from typing import Any
 
 from elkm1_lib.const import ThermostatMode, ThermostatSetting
@@ -7,15 +9,29 @@ from elkm1_lib.elements import Element
 from elkm1_lib.elk import Elk
 from elkm1_lib.outputs import Output
 from elkm1_lib.thermostats import Thermostat
+import voluptuous as vol
 
-from homeassistant.components.switch import SwitchEntity
+from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN, SwitchEntity
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import config_validation as cv, service
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.typing import VolDictType
 
 from . import ElkM1ConfigEntry
+from .const import ATTR_DURATION, DOMAIN
 from .entity import ElkAttachedEntity, ElkEntity, create_elk_entities
 from .models import ELKM1Data
 
+SERVICE_SWITCH_OUTPUT_TURN_ON_FOR = "switch_output_turn_on_for"
+
+ELK_OUTPUT_TURN_ON_FOR_SERVICE_SCHEMA: VolDictType = {
+    vol.Required(ATTR_DURATION): vol.All(
+        cv.time_period,
+        vol.Range(min=timedelta(seconds=1), max=timedelta(seconds=65535)),
+    ),
+}
+
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -32,6 +48,15 @@ async def async_setup_entry(
     )
     async_add_entities(entities)
 
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_SWITCH_OUTPUT_TURN_ON_FOR,
+        entity_domain=SWITCH_DOMAIN,
+        schema=ELK_OUTPUT_TURN_ON_FOR_SERVICE_SCHEMA,
+        func="async_switch_output_turn_on_for",
+    )
+
 
 class ElkOutput(ElkAttachedEntity, SwitchEntity):
     """Elk output as switch."""
@@ -51,6 +76,10 @@ class ElkOutput(ElkAttachedEntity, SwitchEntity):
         """Turn off the output."""
         self._element.turn_off()
 
+    async def async_switch_output_turn_on_for(self, duration: timedelta) -> None:
+        """Turn on an output for specified length of time."""
+        self._element.turn_on(ceil(duration.total_seconds()))
+
 
 class ElkThermostatEMHeat(ElkEntity, SwitchEntity):
     """Elk Thermostat emergency heat as switch."""
@@ -79,3 +108,7 @@ class ElkThermostatEMHeat(ElkEntity, SwitchEntity):
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn off the output."""
         self._elk_set(ThermostatMode.EMERGENCY_HEAT)
+
+    async def async_switch_output_turn_on_for(self, duration: timedelta) -> None:
+        """Turn on an output for specified length of time: not supported for thermostat."""
+        raise HomeAssistantError("supported only on ElkM1 output switch entities")

homeassistant/components/esphome/const.py

@@ -27,7 +27,7 @@ DEFAULT_BLUETOOTH_SCANNING_MODE = BluetoothScanningMode.AUTO.value
 
 DEFAULT_PORT: Final = 6053
 
-STABLE_BLE_VERSION_STR = "2025.11.0"
+STABLE_BLE_VERSION_STR = "2026.5.1"
 STABLE_BLE_VERSION = AwesomeVersion(STABLE_BLE_VERSION_STR)
 PROJECT_URLS = {
     "esphome.bluetooth-proxy": "https://esphome.github.io/bluetooth-proxies/",

homeassistant/components/esphome/entity.py

@@ -53,7 +53,7 @@ def async_static_info_updated(
     platform: entity_platform.EntityPlatform,
     async_add_entities: AddEntitiesCallback,
     info_type: type[_InfoT],
-    entity_type: type[_EntityT],
+    entity_type: Callable[[RuntimeEntryData, EntityInfo, type[_StateT]], _EntityT],
     state_type: type[_StateT],
     infos: list[EntityInfo],
 ) -> None:
@@ -188,7 +188,7 @@ async def platform_async_setup_entry(
     async_add_entities: AddEntitiesCallback,
     *,
     info_type: type[_InfoT],
-    entity_type: type[_EntityT],
+    entity_type: Callable[[RuntimeEntryData, EntityInfo, type[_StateT]], _EntityT],
     state_type: type[_StateT],
     info_filter: Callable[[_InfoT], bool] | None = None,
 ) -> None:
@@ -196,6 +196,11 @@ async def platform_async_setup_entry(
 
     This method is in charge of receiving, distributing and storing
     info and state updates.
+
+    `entity_type` is any callable that builds an entity from
+    `(entry_data, info, state_type)`. A regular entity class satisfies this,
+    and platforms with multiple entity classes can pass a factory function
+    that picks the class per static info.
     """
     entry_data = entry.runtime_data
     entry_data.info[info_type] = {}

homeassistant/components/esphome/infrared.py

@@ -1,28 +1,34 @@
 """Infrared platform for ESPHome."""
 
-from functools import partial
+import functools
 import logging
+from typing import TYPE_CHECKING
 
-from aioesphomeapi import EntityState, InfraredCapability, InfraredInfo
+from aioesphomeapi import EntityInfo, EntityState, InfraredCapability, InfraredInfo
+from aioesphomeapi.client import InfraredRFReceiveEventModel
 
-from homeassistant.components.infrared import InfraredCommand, InfraredEmitterEntity
-from homeassistant.core import callback
+from homeassistant.components.infrared import (
+    InfraredCommand,
+    InfraredEmitterEntity,
+    InfraredReceivedSignal,
+    InfraredReceiverEntity,
+)
+from homeassistant.core import CALLBACK_TYPE, callback
 
 from .entity import (
     EsphomeEntity,
     convert_api_error_ha_error,
     platform_async_setup_entry,
 )
+from .entry_data import RuntimeEntryData
 
 _LOGGER = logging.getLogger(__name__)
 
 PARALLEL_UPDATES = 0
 
 
-class EsphomeInfraredEntity(
-    EsphomeEntity[InfraredInfo, EntityState], InfraredEmitterEntity
-):
-    """ESPHome infrared emitter entity using native API."""
+class _EsphomeInfraredEntity(EsphomeEntity[InfraredInfo, EntityState]):
+    """Common base for ESPHome infrared entities."""
 
     @callback
     def _on_device_update(self) -> None:
@@ -32,6 +38,10 @@ class EsphomeInfraredEntity(
             # Infrared entities should go available as soon as the device comes online
             self.async_write_ha_state()
 
+
+class EsphomeInfraredEmitterEntity(_EsphomeInfraredEntity, InfraredEmitterEntity):
+    """ESPHome infrared emitter entity using native API."""
+
     @convert_api_error_ha_error
     async def async_send_command(self, command: InfraredCommand) -> None:
         """Send an IR command."""
@@ -46,10 +56,77 @@ class EsphomeInfraredEntity(
         )
 
 
-async_setup_entry = partial(
+class EsphomeInfraredReceiverEntity(_EsphomeInfraredEntity, InfraredReceiverEntity):
+    """ESPHome infrared receiver entity using native API."""
+
+    _unsub_receive: CALLBACK_TYPE | None = None
+
+    async def async_added_to_hass(self) -> None:
+        """Register callbacks including IR receive subscription."""
+        await super().async_added_to_hass()
+        self._async_subscribe_receive()
+
+    async def async_will_remove_from_hass(self) -> None:
+        """Unsubscribe from the device on entity removal."""
+        await super().async_will_remove_from_hass()
+        if self._unsub_receive is not None:
+            self._unsub_receive()
+            self._unsub_receive = None
+
+    @callback
+    def _async_subscribe_receive(self) -> None:
+        """Subscribe to IR receive events if the device is connected."""
+        # Subscribing requires an active API connection; defer to
+        # _on_device_update when the device is not (yet) available.
+        if self._unsub_receive is not None or not self._entry_data.available:
+            return
+        self._unsub_receive = self._client.subscribe_infrared_rf_receive(
+            self._on_infrared_rf_receive
+        )
+
+    @callback
+    def _on_device_update(self) -> None:
+        """Call when device updates or entry data changes."""
+        super()._on_device_update()
+        if self._entry_data.available:
+            self._async_subscribe_receive()
+        elif self._unsub_receive is not None:
+            self._unsub_receive = None
+
+    @callback
+    def _on_infrared_rf_receive(self, event: InfraredRFReceiveEventModel) -> None:
+        """Handle a received IR signal from the device."""
+        if (
+            event.key != self._static_info.key
+            or event.device_id != self._static_info.device_id
+        ):
+            return
+        self._handle_received_signal(InfraredReceivedSignal(timings=event.timings))
+
+
+def _make_infrared_entity(
+    entry_data: RuntimeEntryData,
+    info: EntityInfo,
+    state_type: type[EntityState],
+) -> _EsphomeInfraredEntity:
+    """Build the right infrared entity based on the InfraredInfo capabilities."""
+    if TYPE_CHECKING:
+        assert isinstance(info, InfraredInfo)
+    cls = (
+        EsphomeInfraredReceiverEntity
+        if info.capabilities & InfraredCapability.RECEIVER
+        else EsphomeInfraredEmitterEntity
+    )
+    return cls(entry_data, info, state_type)
+
+
+async_setup_entry = functools.partial(
     platform_async_setup_entry,
     info_type=InfraredInfo,
-    entity_type=EsphomeInfraredEntity,
+    entity_type=_make_infrared_entity,
     state_type=EntityState,
-    info_filter=lambda info: bool(info.capabilities & InfraredCapability.TRANSMITTER),
+    info_filter=lambda info: bool(
+        info.capabilities
+        & (InfraredCapability.TRANSMITTER | InfraredCapability.RECEIVER)
+    ),
 )

homeassistant/components/esphome/manifest.json

@@ -17,7 +17,7 @@
   "mqtt": ["esphome/discover/#"],
   "quality_scale": "platinum",
   "requirements": [
-    "aioesphomeapi==45.2.2",
+    "aioesphomeapi==45.3.1",
     "esphome-dashboard-api==1.3.0",
     "bleak-esphome==3.9.1"
   ],

homeassistant/components/ezviz/select.py

@@ -124,11 +124,11 @@ async def async_setup_entry(
 
     for camera in coordinator.data:
         device_category = coordinator.data[camera].get("device_category")
-        supportExt = coordinator.data[camera].get("supportExt")
+        support_ext = coordinator.data[camera].get("supportExt")
         if (
             device_category == DeviceCatagories.BATTERY_CAMERA_DEVICE_CATEGORY.value
-            and supportExt
-            and str(SupportExt.SupportBatteryManage.value) in supportExt
+            and support_ext
+            and str(SupportExt.SupportBatteryManage.value) in support_ext
         ):
             entities.append(
                 EzvizSelect(coordinator, camera, BATTERY_WORK_MODE_SELECT_TYPE)

homeassistant/components/fan/triggers.yaml

@@ -5,7 +5,7 @@
   fields:
     behavior:
       required: true
-      default: any
+      default: each
       selector:
         automation_behavior:
           mode: trigger

homeassistant/components/fressnapf_tracker/device_tracker.py

@@ -1,6 +1,6 @@
 """Device tracker platform for fressnapf_tracker."""
 
-from homeassistant.components.device_tracker.config_entry import TrackerEntity
+from homeassistant.components.device_tracker import TrackerEntity
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 

homeassistant/components/garage_door/triggers.yaml

@@ -1,7 +1,7 @@
 .trigger_common_fields: &trigger_common_fields
   behavior:
     required: true
-    default: any
+    default: each
     selector:
       automation_behavior:
         mode: trigger

homeassistant/components/gardena_bluetooth/__init__.py

@@ -4,24 +4,14 @@ import logging
 
 from bleak.backends.device import BLEDevice
 from gardena_bluetooth.client import CachedConnection, Client
-from gardena_bluetooth.const import AquaContour, DeviceConfiguration, DeviceInformation
-from gardena_bluetooth.exceptions import (
-    CharacteristicNoAccess,
-    CharacteristicNotFound,
-    CommunicationFailure,
-)
-from gardena_bluetooth.parse import CharacteristicTime, ProductType
+from gardena_bluetooth.const import ProductType
 from gardena_bluetooth.scan import async_get_manufacturer_data
 
 from homeassistant.components import bluetooth
 from homeassistant.const import CONF_ADDRESS, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import device_registry as dr
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.util import dt as dt_util
 
-from .const import DOMAIN
 from .coordinator import (
     DeviceUnavailable,
     GardenaBluetoothConfigEntry,
@@ -39,7 +29,6 @@ PLATFORMS: list[Platform] = [
     Platform.VALVE,
 ]
 LOGGER = logging.getLogger(__name__)
-TIMEOUT = 20.0
 DISCONNECT_DELAY = 5
 
 
@@ -57,15 +46,6 @@ def get_connection(hass: HomeAssistant, address: str) -> CachedConnection:
     return CachedConnection(DISCONNECT_DELAY, _device_lookup)
 
 
-async def _update_timestamp(client: Client, characteristics: CharacteristicTime):
-    try:
-        await client.update_timestamp(characteristics, dt_util.now())
-    except CharacteristicNotFound:
-        pass
-    except CharacteristicNoAccess:
-        LOGGER.debug("No access to update internal time")
-
-
 async def async_setup_entry(
     hass: HomeAssistant, entry: GardenaBluetoothConfigEntry
 ) -> bool:
@@ -73,49 +53,30 @@ async def async_setup_entry(
 
     address = entry.data[CONF_ADDRESS]
 
-    mfg_data = await async_get_manufacturer_data({address})
+    try:
+        mfg_data = await async_get_manufacturer_data({address})
+    except TimeoutError as exc:
+        raise ConfigEntryNotReady("Unable to find product type") from exc
+
     product_type = mfg_data[address].product_type
     if product_type is ProductType.UNKNOWN:
         raise ConfigEntryNotReady("Unable to find product type")
 
     client = Client(get_connection(hass, address), product_type)
-    try:
-        chars = await client.get_all_characteristics()
-
-        sw_version = await client.read_char(DeviceInformation.firmware_version, None)
-        manufacturer = await client.read_char(DeviceInformation.manufacturer_name, None)
-        model = await client.read_char(DeviceInformation.model_number, None)
-
-        name = entry.title
-        name = await client.read_char(DeviceConfiguration.custom_device_name, name)
-        name = await client.read_char(AquaContour.custom_device_name, name)
-
-        await _update_timestamp(client, DeviceConfiguration.unix_timestamp)
-        await _update_timestamp(client, AquaContour.unix_timestamp)
-
-    except (TimeoutError, CommunicationFailure, DeviceUnavailable) as exception:
-        await client.disconnect()
-        raise ConfigEntryNotReady(
-            f"Unable to connect to device {address} due to {exception}"
-        ) from exception
-
-    device = DeviceInfo(
-        identifiers={(DOMAIN, address)},
-        connections={(dr.CONNECTION_BLUETOOTH, address)},
-        name=name,
-        sw_version=sw_version,
-        manufacturer=manufacturer,
-        model=model,
-    )
 
     coordinator = GardenaBluetoothCoordinator(
-        hass, entry, LOGGER, client, set(chars.keys()), device, address
+        hass,
+        entry,
+        LOGGER,
+        client,
+        address,
     )
 
+    await coordinator.async_config_entry_first_refresh()
+
     entry.runtime_data = coordinator
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-    await coordinator.async_refresh()
-
+    await coordinator.async_request_refresh()
     return True
 
 
@@ -123,7 +84,4 @@ async def async_unload_entry(
     hass: HomeAssistant, entry: GardenaBluetoothConfigEntry
 ) -> bool:
     """Unload a config entry."""
-    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
-        await entry.runtime_data.async_shutdown()
-
-    return unload_ok
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/gardena_bluetooth/coordinator.py

@@ -4,17 +4,28 @@ from datetime import timedelta
 import logging
 
 from gardena_bluetooth.client import Client
+from gardena_bluetooth.const import AquaContour, DeviceConfiguration, DeviceInformation
 from gardena_bluetooth.exceptions import (
     CharacteristicNoAccess,
+    CharacteristicNotFound,
+    CommunicationFailure,
     GardenaBluetoothException,
 )
-from gardena_bluetooth.parse import Characteristic, CharacteristicType
+from gardena_bluetooth.parse import (
+    Characteristic,
+    CharacteristicTime,
+    CharacteristicType,
+)
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+from homeassistant.util import dt as dt_util
+
+from .const import DOMAIN
 
 SCAN_INTERVAL = timedelta(seconds=60)
 LOGGER = logging.getLogger(__name__)
@@ -37,8 +48,6 @@ class GardenaBluetoothCoordinator(DataUpdateCoordinator[dict[str, bytes]]):
         config_entry: GardenaBluetoothConfigEntry,
         logger: logging.Logger,
         client: Client,
-        characteristics: set[str],
-        device_info: DeviceInfo,
         address: str,
     ) -> None:
         """Initialize global data updater."""
@@ -52,14 +61,63 @@ class GardenaBluetoothCoordinator(DataUpdateCoordinator[dict[str, bytes]]):
         self.address = address
         self.data = {}
         self.client = client
-        self.characteristics = characteristics
-        self.device_info = device_info
+        self.characteristics: set[str] = set()
+        self.device_info = DeviceInfo(
+            identifiers={(DOMAIN, address)},
+            connections={(dr.CONNECTION_BLUETOOTH, address)},
+            name=config_entry.title,
+        )
 
     async def async_shutdown(self) -> None:
         """Shutdown coordinator and any connection."""
         await super().async_shutdown()
         await self.client.disconnect()
 
+    async def _async_setup(self) -> None:
+        """Set up the coordinator and read initial device metadata."""
+        try:
+            chars = await self.client.get_all_characteristics()
+
+            sw_version = await self.client.read_char(
+                DeviceInformation.firmware_version, None
+            )
+            manufacturer = await self.client.read_char(
+                DeviceInformation.manufacturer_name, None
+            )
+            model = await self.client.read_char(DeviceInformation.model_number, None)
+
+            name = self.config_entry.title
+            name = await self.client.read_char(
+                DeviceConfiguration.custom_device_name, name
+            )
+            name = await self.client.read_char(AquaContour.custom_device_name, name)
+
+            await self._update_timestamp(DeviceConfiguration.unix_timestamp)
+            await self._update_timestamp(AquaContour.unix_timestamp)
+
+            self.characteristics = set(chars.keys())
+            self.device_info = DeviceInfo(
+                {
+                    **self.device_info,
+                    "name": name,
+                    "sw_version": sw_version,
+                    "manufacturer": manufacturer,
+                    "model": model,
+                }
+            )
+        except (TimeoutError, CommunicationFailure, DeviceUnavailable) as exception:
+            raise UpdateFailed(
+                f"Unable to set up Gardena Bluetooth device due to {exception}"
+            ) from exception
+
+    async def _update_timestamp(self, char: CharacteristicTime) -> None:
+        try:
+            await self.client.update_timestamp(char, dt_util.now())
+        except CharacteristicNotFound:
+            pass
+        except CharacteristicNoAccess:
+            LOGGER.debug("No access to update internal time")
+
     async def _async_update_data(self) -> dict[str, bytes]:
         """Poll the device."""
         uuids: set[str] = {