Add windows 98 labs feature

.claude/skills/integrations/SKILL.md

@@ -620,14 +620,12 @@ rules:
 
 ### Config Flow Testing
 - **100% Coverage Required**: All config flow paths must be tested
-- **Patch Boundaries**: Only patch library or client methods when testing config flows. Do not patch methods defined in `config_flow.py`; exercise the flow logic end-to-end.
 - **Test Scenarios**:
   - All flow initiation methods (user, discovery, import)
   - Successful configuration paths
   - Error recovery scenarios
   - Prevention of duplicate entries
   - Flow completion after errors
-  - Reauthentication/reconfigure flows
 
 ### Testing
 - **Integration-specific tests** (recommended):

.gitattributes

@@ -16,7 +16,6 @@ Dockerfile.dev linguist-language=Dockerfile
 CODEOWNERS linguist-generated=true
 Dockerfile linguist-generated=true
 homeassistant/generated/*.py linguist-generated=true
-machine/* linguist-generated=true
 mypy.ini linguist-generated=true
 requirements.txt linguist-generated=true
 requirements_all.txt linguist-generated=true

.github/copilot-instructions.md

@@ -18,11 +18,6 @@ This repository contains the core of Home Assistant, a Python 3 based home autom
 
 - Python 3.14 explicitly allows `except TypeA, TypeB:` without parentheses.
 
-## Testing
-
-When writing or modifying tests, ensure all test function parameters have type annotations.
-Prefer concrete types (for example, `HomeAssistant`, `MockConfigEntry`, etc.) over `Any`.
-
 ## Good practices
 
 Integrations with Platinum or Gold level in the Integration Quality Scale reflect a high standard of code quality and maintainability. When looking for examples of something, these are good places to start. The level is indicated in the manifest.json of the integration.

.github/workflows/builder.yml

@@ -35,7 +35,6 @@ jobs:
       channel: ${{ steps.version.outputs.channel }}
       publish: ${{ steps.version.outputs.publish }}
       architectures: ${{ env.ARCHITECTURES }}
-      base_image_version: ${{ env.BASE_IMAGE_VERSION }}
     steps:
       - name: Checkout the repository
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
@@ -73,7 +72,7 @@ jobs:
       - name: Download Translations
         run: python3 -m script.translations download
         env:
-          LOKALISE_TOKEN: ${{ secrets.LOKALISE_TOKEN }} # zizmor: ignore[secrets-outside-env]
+          LOKALISE_TOKEN: ${{ secrets.LOKALISE_TOKEN }}
 
       - name: Archive translations
         shell: bash
@@ -101,7 +100,7 @@ jobs:
         arch: ${{ fromJson(needs.init.outputs.architectures) }}
         include:
           - arch: amd64
-            os: ubuntu-24.04
+            os: ubuntu-latest
           - arch: aarch64
             os: ubuntu-24.04-arm
     steps:
@@ -196,20 +195,77 @@ jobs:
         run: |
           echo "${GITHUB_SHA};${GITHUB_REF};${GITHUB_EVENT_NAME};${GITHUB_ACTOR}" > rootfs/OFFICIAL_IMAGE
 
-      - name: Build base image
-        uses: home-assistant/builder/actions/build-image@62a1597b84b3461abad9816d9cd92862a2b542c3 # 2026.03.2
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
         with:
-          arch: ${{ matrix.arch }}
-          build-args: |
-            BUILD_FROM=ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant-base:${{ needs.init.outputs.base_image_version }}
-          cache-gha: false
-          container-registry-password: ${{ secrets.GITHUB_TOKEN }}
-          cosign-base-identity: "https://github.com/home-assistant/docker/.*"
-          cosign-base-verify: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant-base:${{ needs.init.outputs.base_image_version }}
-          image: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant
-          image-tags: ${{ needs.init.outputs.version }}
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Install Cosign
+        uses: sigstore/cosign-installer@faadad0cce49287aee09b3a48701e75088a2c6ad # v4.0.0
+        with:
+          cosign-release: "v2.5.3"
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.12.0
+
+      - name: Build variables
+        id: vars
+        shell: bash
+        env:
+          ARCH: ${{ matrix.arch }}
+        run: |
+          echo "base_image=ghcr.io/home-assistant/${ARCH}-homeassistant-base:${BASE_IMAGE_VERSION}" >> "$GITHUB_OUTPUT"
+          echo "cache_image=ghcr.io/home-assistant/${ARCH}-homeassistant:latest" >> "$GITHUB_OUTPUT"
+          echo "created=$(date --rfc-3339=seconds --utc)" >> "$GITHUB_OUTPUT"
+
+      - name: Verify base image signature
+        env:
+          BASE_IMAGE: ${{ steps.vars.outputs.base_image }}
+        run: |
+          cosign verify \
+            --certificate-oidc-issuer https://token.actions.githubusercontent.com \
+            --certificate-identity-regexp "https://github.com/home-assistant/docker/.*" \
+            "${BASE_IMAGE}"
+
+      - name: Verify cache image signature
+        id: cache
+        continue-on-error: true
+        env:
+          CACHE_IMAGE: ${{ steps.vars.outputs.cache_image }}
+        run: |
+          cosign verify \
+            --certificate-oidc-issuer https://token.actions.githubusercontent.com \
+            --certificate-identity-regexp "https://github.com/home-assistant/core/.*" \
+            "${CACHE_IMAGE}"
+
+      - name: Build base image
+        id: build
+        uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6.19.2
+        with:
+          context: .
+          file: ./Dockerfile
+          platforms: ${{ steps.vars.outputs.platform }}
           push: true
-          version: ${{ needs.init.outputs.version }}
+          cache-from: ${{ steps.cache.outcome == 'success' && steps.vars.outputs.cache_image || '' }}
+          build-args: |
+            BUILD_FROM=${{ steps.vars.outputs.base_image }}
+          tags: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
+          outputs: type=image,push=true,compression=zstd,compression-level=9,force-compression=true,oci-mediatypes=true
+          labels: |
+            io.hass.arch=${{ matrix.arch }}
+            io.hass.version=${{ needs.init.outputs.version }}
+            org.opencontainers.image.created=${{ steps.vars.outputs.created }}
+            org.opencontainers.image.version=${{ needs.init.outputs.version }}
+
+      - name: Sign image
+        env:
+          ARCH: ${{ matrix.arch }}
+          VERSION: ${{ needs.init.outputs.version }}
+          DIGEST: ${{ steps.build.outputs.digest }}
+        run: |
+          cosign sign --yes "ghcr.io/home-assistant/${ARCH}-homeassistant:${VERSION}@${DIGEST}"
 
   build_machine:
     name: Build ${{ matrix.machine }} machine core image
@@ -258,38 +314,35 @@ jobs:
         with:
           persist-credentials: false
 
-      - name: Compute extra tags
-        id: tags
-        shell: bash
+      - name: Set build additional args
         env:
           VERSION: ${{ needs.init.outputs.version }}
         run: |
+          # Create general tags
           if [[ "${VERSION}" =~ d ]]; then
-            echo "extra_tags=dev" >> "$GITHUB_OUTPUT"
+            echo "BUILD_ARGS=--additional-tag dev" >> $GITHUB_ENV
           elif [[ "${VERSION}" =~ b ]]; then
-            echo "extra_tags=beta" >> "$GITHUB_OUTPUT"
+            echo "BUILD_ARGS=--additional-tag beta" >> $GITHUB_ENV
           else
-            echo "extra_tags=stable" >> "$GITHUB_OUTPUT"
+            echo "BUILD_ARGS=--additional-tag stable" >> $GITHUB_ENV
           fi
 
-      - name: Build machine image
-        uses: home-assistant/builder/actions/build-image@62a1597b84b3461abad9816d9cd92862a2b542c3 # 2026.03.2
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
         with:
-          arch: ${{ matrix.arch }}
-          build-args: |
-            BUILD_FROM=ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
-          cache-gha: false
-          container-registry-password: ${{ secrets.GITHUB_TOKEN }}
-          context: machine/
-          cosign-base-identity: "https://github.com/home-assistant/core/.*"
-          cosign-base-verify: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
-          file: machine/${{ matrix.machine }}
-          image: ghcr.io/home-assistant/${{ matrix.machine }}-homeassistant
-          image-tags: |
-            ${{ needs.init.outputs.version }}
-            ${{ steps.tags.outputs.extra_tags }}
-          push: true
-          version: ${{ needs.init.outputs.version }}
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build base image
+        uses: home-assistant/builder@6cb4fd3d1338b6e22d0958a4bcb53e0965ea63b4 # 2026.02.1
+        with:
+          image: ${{ matrix.arch }}
+          args: |
+            $BUILD_ARGS \
+            --target /data/machine \
+            --cosign \
+            --machine "${{ needs.init.outputs.version }}=${{ matrix.machine }}"
 
   publish_ha:
     name: Publish version files
@@ -347,19 +400,19 @@ jobs:
         registry: ["ghcr.io/home-assistant", "docker.io/homeassistant"]
     steps:
       - name: Install Cosign
-        uses: sigstore/cosign-installer@ba7bc0a3fef59531c69a25acd34668d6d3fe6f22 # v4.1.0
+        uses: sigstore/cosign-installer@faadad0cce49287aee09b3a48701e75088a2c6ad # v4.0.0
         with:
           cosign-release: "v2.5.3"
 
       - name: Login to DockerHub
         if: matrix.registry == 'docker.io/homeassistant'
-        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
@@ -389,7 +442,7 @@ jobs:
       #   2025.12.0.dev202511250240 -> tags: 2025.12.0.dev202511250240, dev
       - name: Generate Docker metadata
         id: meta
-        uses: docker/metadata-action@030e881283bb7a6894de51c315a6bfe6a94e05cf # v6.0.0
+        uses: docker/metadata-action@c299e40c65443455700f0fdfc63efafe5b349051 # v5.10.0
         with:
           images: ${{ matrix.registry }}/home-assistant
           sep-tags: ","
@@ -403,7 +456,7 @@ jobs:
             type=semver,pattern={{major}}.{{minor}},value=${{ needs.init.outputs.version }},enable=${{ !contains(needs.init.outputs.version, 'd') && !contains(needs.init.outputs.version, 'b') }}
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v3.7.1
+        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.7.1
 
       - name: Copy architecture images to DockerHub
         if: matrix.registry == 'docker.io/homeassistant'
@@ -532,14 +585,14 @@ jobs:
           persist-credentials: false
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
+        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Build Docker image
-        uses: docker/build-push-action@d08e5c354a6adb9ed34480a06d141179aa583294 # v7.0.0
+        uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6.19.2
         with:
           context: . # So action will not pull the repository again
           file: ./script/hassfest/docker/Dockerfile
@@ -552,7 +605,7 @@ jobs:
       - name: Push Docker image
         if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
         id: push
-        uses: docker/build-push-action@d08e5c354a6adb9ed34480a06d141179aa583294 # v7.0.0
+        uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6.19.2
         with:
           context: . # So action will not pull the repository again
           file: ./script/hassfest/docker/Dockerfile
@@ -561,7 +614,7 @@ jobs:
 
       - name: Generate artifact attestation
         if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
-        uses: actions/attest@59d89421af93a897026c735860bf21b6eb4f7b26 # v4.1.0
+        uses: actions/attest-build-provenance@a2bbfa25375fe432b6a289bc6b6cd05ecd0c4c32 # v4.1.0
         with:
           subject-name: ${{ env.HASSFEST_IMAGE_NAME }}
           subject-digest: ${{ steps.push.outputs.digest }}

.github/workflows/ci.yaml

@@ -609,7 +609,7 @@ jobs:
         with:
           persist-credentials: false
       - name: Dependency review
-        uses: actions/dependency-review-action@2031cfc080254a8a887f58cffee85186f0e49e48 # v4.9.0
+        uses: actions/dependency-review-action@05fe4576374b728f0c523d6a13d64c25081e0803 # v4.8.3
         with:
           license-check: false # We use our own license audit checks
 
@@ -852,6 +852,10 @@ jobs:
     needs:
       - info
       - base
+      - gen-requirements-all
+      - hassfest
+      - prek
+      - mypy
     steps:
       - name: Restore apt cache
         uses: actions/cache/restore@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3
@@ -1396,7 +1400,7 @@ jobs:
         with:
           fail_ci_if_error: true
           flags: full-suite
-          token: ${{ secrets.CODECOV_TOKEN }} # zizmor: ignore[secrets-outside-env]
+          token: ${{ secrets.CODECOV_TOKEN }}
 
   pytest-partial:
     name: Run tests Python ${{ matrix.python-version }} (${{ matrix.group }})
@@ -1566,7 +1570,7 @@ jobs:
         uses: codecov/codecov-action@671740ac38dd9b0130fbe1cec585b89eea48d3de # v5.5.2
         with:
           fail_ci_if_error: true
-          token: ${{ secrets.CODECOV_TOKEN }} # zizmor: ignore[secrets-outside-env]
+          token: ${{ secrets.CODECOV_TOKEN }}
 
   upload-test-results:
     name: Upload test results to Codecov

.github/workflows/codeql.yml

@@ -28,11 +28,11 @@ jobs:
           persist-credentials: false
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@0d579ffd059c29b07949a3cce3983f0780820c98 # v4.32.6
+        uses: github/codeql-action/init@89a39a4e59826350b863aa6b6252a07ad50cf83e # v4.32.4
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@0d579ffd059c29b07949a3cce3983f0780820c98 # v4.32.6
+        uses: github/codeql-action/analyze@89a39a4e59826350b863aa6b6252a07ad50cf83e # v4.32.4
         with:
           category: "/language:python"

.github/workflows/stale.yml

@@ -58,8 +58,8 @@ jobs:
         # v1.7.0
         uses: tibdex/github-app-token@3beb63f4bd073e61482598c45c71c1019b59b73a
         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 }}
+          private_key: ${{ secrets.ISSUE_TRIAGE_APP_PEM }}
 
       # The 90 day stale policy for issues
       # Used for:

.github/workflows/translations.yml

@@ -33,6 +33,6 @@ jobs:
 
       - name: Upload Translations
         env:
-          LOKALISE_TOKEN: ${{ secrets.LOKALISE_TOKEN }} # zizmor: ignore[secrets-outside-env]
+          LOKALISE_TOKEN: ${{ secrets.LOKALISE_TOKEN }}
         run: |
           python3 -m script.translations upload

.github/workflows/wheels.yml

@@ -142,7 +142,7 @@ jobs:
           abi: ${{ matrix.abi }}
           tag: musllinux_1_2
           arch: ${{ matrix.arch }}
-          wheels-key: ${{ secrets.WHEELS_KEY }} # zizmor: ignore[secrets-outside-env]
+          wheels-key: ${{ secrets.WHEELS_KEY }}
           env-file: true
           apk: "libffi-dev;openssl-dev;yaml-dev;nasm;zlib-ng-dev"
           skip-binary: aiohttp;multidict;propcache;yarl;SQLAlchemy
@@ -200,7 +200,7 @@ jobs:
           abi: ${{ matrix.abi }}
           tag: musllinux_1_2
           arch: ${{ matrix.arch }}
-          wheels-key: ${{ secrets.WHEELS_KEY }} # zizmor: ignore[secrets-outside-env]
+          wheels-key: ${{ secrets.WHEELS_KEY }}
           env-file: true
           apk: "bluez-dev;libffi-dev;openssl-dev;glib-dev;eudev-dev;libxml2-dev;libxslt-dev;libpng-dev;libjpeg-turbo-dev;tiff-dev;gmp-dev;mpfr-dev;mpc1-dev;ffmpeg-dev;yaml-dev;openblas-dev;fftw-dev;lapack-dev;gfortran;blas-dev;eigen-dev;freetype-dev;glew-dev;harfbuzz-dev;hdf5-dev;libdc1394-dev;libtbb-dev;mesa-dev;openexr-dev;openjpeg-dev;uchardet-dev;nasm;zlib-ng-dev"
           skip-binary: aiohttp;charset-normalizer;grpcio;multidict;SQLAlchemy;propcache;protobuf;pymicro-vad;yarl

.pre-commit-config.yaml

@@ -18,7 +18,7 @@ repos:
         exclude_types: [csv, json, html]
         exclude: ^tests/fixtures/|homeassistant/generated/|tests/components/.*/snapshots/
   - repo: https://github.com/zizmorcore/zizmor-pre-commit
-    rev: v1.23.1
+    rev: v1.22.0
     hooks:
       - id: zizmor
         args:

.strict-typing

@@ -342,7 +342,6 @@ homeassistant.components.lookin.*
 homeassistant.components.lovelace.*
 homeassistant.components.luftdaten.*
 homeassistant.components.lunatone.*
-homeassistant.components.lutron.*
 homeassistant.components.madvr.*
 homeassistant.components.manual.*
 homeassistant.components.mastodon.*
@@ -570,7 +569,6 @@ homeassistant.components.trafikverket_train.*
 homeassistant.components.trafikverket_weatherstation.*
 homeassistant.components.transmission.*
 homeassistant.components.trend.*
-homeassistant.components.trmnl.*
 homeassistant.components.tts.*
 homeassistant.components.twentemilieu.*
 homeassistant.components.unifi.*

AGENTS.md

@@ -15,11 +15,6 @@ This repository contains the core of Home Assistant, a Python 3 based home autom
 
 - Python 3.14 explicitly allows `except TypeA, TypeB:` without parentheses.
 
-## Testing
-
-When writing or modifying tests, ensure all test function parameters have type annotations.
-Prefer concrete types (for example, `HomeAssistant`, `MockConfigEntry`, etc.) over `Any`.
-
 ## Good practices
 
 Integrations with Platinum or Gold level in the Integration Quality Scale reflect a high standard of code quality and maintainability. When looking for examples of something, these are good places to start. The level is indicated in the manifest.json of the integration.

CODEOWNERS

@@ -186,8 +186,6 @@ build.json @home-assistant/supervisor
 /tests/components/auth/ @home-assistant/core
 /homeassistant/components/automation/ @home-assistant/core
 /tests/components/automation/ @home-assistant/core
-/homeassistant/components/autoskope/ @mcisk
-/tests/components/autoskope/ @mcisk
 /homeassistant/components/avea/ @pattyland
 /homeassistant/components/awair/ @ahayworth @ricohageman
 /tests/components/awair/ @ahayworth @ricohageman
@@ -579,8 +577,6 @@ build.json @home-assistant/supervisor
 /tests/components/garages_amsterdam/ @klaasnicolaas
 /homeassistant/components/gardena_bluetooth/ @elupus
 /tests/components/gardena_bluetooth/ @elupus
-/homeassistant/components/gate/ @home-assistant/core
-/tests/components/gate/ @home-assistant/core
 /homeassistant/components/gdacs/ @exxamalte
 /tests/components/gdacs/ @exxamalte
 /homeassistant/components/generic/ @davet2001
@@ -974,8 +970,6 @@ build.json @home-assistant/supervisor
 /tests/components/logbook/ @home-assistant/core
 /homeassistant/components/logger/ @home-assistant/core
 /tests/components/logger/ @home-assistant/core
-/homeassistant/components/lojack/ @devinslick
-/tests/components/lojack/ @devinslick
 /homeassistant/components/london_underground/ @jpbede
 /tests/components/london_underground/ @jpbede
 /homeassistant/components/lookin/ @ANMalko @bdraco
@@ -1075,8 +1069,6 @@ build.json @home-assistant/supervisor
 /tests/components/moon/ @fabaff @frenck
 /homeassistant/components/mopeka/ @bdraco
 /tests/components/mopeka/ @bdraco
-/homeassistant/components/motion/ @home-assistant/core
-/tests/components/motion/ @home-assistant/core
 /homeassistant/components/motion_blinds/ @starkillerOG
 /tests/components/motion_blinds/ @starkillerOG
 /homeassistant/components/motionblinds_ble/ @LennP @jerrybboy
@@ -1190,8 +1182,6 @@ build.json @home-assistant/supervisor
 /tests/components/nzbget/ @chriscla
 /homeassistant/components/obihai/ @dshokouhi @ejpenney
 /tests/components/obihai/ @dshokouhi @ejpenney
-/homeassistant/components/occupancy/ @home-assistant/core
-/tests/components/occupancy/ @home-assistant/core
 /homeassistant/components/octoprint/ @rfleming71
 /tests/components/octoprint/ @rfleming71
 /homeassistant/components/ohmconnect/ @robbiet480
@@ -1616,6 +1606,8 @@ build.json @home-assistant/supervisor
 /tests/components/srp_energy/ @briglx
 /homeassistant/components/starline/ @anonym-tsk
 /tests/components/starline/ @anonym-tsk
+/homeassistant/components/starlink/ @boswelja
+/tests/components/starlink/ @boswelja
 /homeassistant/components/statistics/ @ThomDietrich @gjohansson-ST
 /tests/components/statistics/ @ThomDietrich @gjohansson-ST
 /homeassistant/components/steam_online/ @tkdrob
@@ -1770,8 +1762,6 @@ build.json @home-assistant/supervisor
 /tests/components/trend/ @jpbede
 /homeassistant/components/triggercmd/ @rvmey
 /tests/components/triggercmd/ @rvmey
-/homeassistant/components/trmnl/ @joostlek
-/tests/components/trmnl/ @joostlek
 /homeassistant/components/tts/ @home-assistant/core
 /tests/components/tts/ @home-assistant/core
 /homeassistant/components/tuya/ @Tuya @zlinoliver
@@ -1788,8 +1778,6 @@ build.json @home-assistant/supervisor
 /tests/components/ukraine_alarm/ @PaulAnnekov
 /homeassistant/components/unifi/ @Kane610
 /tests/components/unifi/ @Kane610
-/homeassistant/components/unifi_access/ @imhotep @RaHehl
-/tests/components/unifi_access/ @imhotep @RaHehl
 /homeassistant/components/unifi_direct/ @tofuSCHNITZEL
 /homeassistant/components/unifiled/ @florisvdk
 /homeassistant/components/unifiprotect/ @RaHehl
@@ -1915,8 +1903,6 @@ build.json @home-assistant/supervisor
 /tests/components/wiffi/ @mampfes
 /homeassistant/components/wilight/ @leofig-rj
 /tests/components/wilight/ @leofig-rj
-/homeassistant/components/window/ @home-assistant/core
-/tests/components/window/ @home-assistant/core
 /homeassistant/components/wirelesstag/ @sergeymaysak
 /homeassistant/components/withings/ @joostlek
 /tests/components/withings/ @joostlek

Dockerfile

@@ -10,6 +10,7 @@ LABEL \
     org.opencontainers.image.description="Open-source home automation platform running on Python 3" \
     org.opencontainers.image.documentation="https://www.home-assistant.io/docs/" \
     org.opencontainers.image.licenses="Apache-2.0" \
+    org.opencontainers.image.source="https://github.com/home-assistant/core" \
     org.opencontainers.image.title="Home Assistant" \
     org.opencontainers.image.url="https://www.home-assistant.io/"
 

homeassistant/bootstrap.py

@@ -243,11 +243,7 @@ DEFAULT_INTEGRATIONS = {
     # Integrations providing triggers and conditions for base platforms:
     "door",
     "garage_door",
-    "gate",
     "humidity",
-    "motion",
-    "occupancy",
-    "window",
 }
 DEFAULT_INTEGRATIONS_RECOVERY_MODE = {
     # These integrations are set up if recovery mode is activated.

homeassistant/brands/ubiquiti.json

@@ -1,12 +1,5 @@
 {
   "domain": "ubiquiti",
   "name": "Ubiquiti",
-  "integrations": [
-    "airos",
-    "unifi",
-    "unifi_access",
-    "unifi_direct",
-    "unifiled",
-    "unifiprotect"
-  ]
+  "integrations": ["airos", "unifi", "unifi_direct", "unifiled", "unifiprotect"]
 }

homeassistant/components/aladdin_connect/__init__.py

@@ -46,10 +46,19 @@ async def async_setup_entry(
         api.AsyncConfigEntryAuth(aiohttp_client.async_get_clientsession(hass), session)
     )
 
-    coordinator = AladdinConnectCoordinator(hass, entry, client)
-    await coordinator.async_config_entry_first_refresh()
+    try:
+        doors = await client.get_doors()
+    except aiohttp.ClientResponseError as err:
+        if 400 <= err.status < 500:
+            raise ConfigEntryAuthFailed(err) from err
+        raise ConfigEntryNotReady from err
+    except aiohttp.ClientError as err:
+        raise ConfigEntryNotReady from err
 
-    entry.runtime_data = coordinator
+    entry.runtime_data = {
+        door.unique_id: AladdinConnectCoordinator(hass, entry, client, door)
+        for door in doors
+    }
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
@@ -91,7 +100,7 @@ def remove_stale_devices(
     device_entries = dr.async_entries_for_config_entry(
         device_registry, config_entry.entry_id
     )
-    all_device_ids = set(config_entry.runtime_data.data)
+    all_device_ids = set(config_entry.runtime_data)
 
     for device_entry in device_entries:
         device_id: str | None = None

homeassistant/components/aladdin_connect/coordinator.py

@@ -11,24 +11,22 @@ from genie_partner_sdk.model import GarageDoor
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
 _LOGGER = logging.getLogger(__name__)
-type AladdinConnectConfigEntry = ConfigEntry[AladdinConnectCoordinator]
+type AladdinConnectConfigEntry = ConfigEntry[dict[str, AladdinConnectCoordinator]]
 SCAN_INTERVAL = timedelta(seconds=15)
 
 
-class AladdinConnectCoordinator(DataUpdateCoordinator[dict[str, GarageDoor]]):
+class AladdinConnectCoordinator(DataUpdateCoordinator[GarageDoor]):
     """Coordinator for Aladdin Connect integration."""
 
-    config_entry: AladdinConnectConfigEntry
-
     def __init__(
         self,
         hass: HomeAssistant,
         entry: AladdinConnectConfigEntry,
         client: AladdinConnectClient,
+        garage_door: GarageDoor,
     ) -> None:
         """Initialize the coordinator."""
         super().__init__(
@@ -39,16 +37,18 @@ class AladdinConnectCoordinator(DataUpdateCoordinator[dict[str, GarageDoor]]):
             update_interval=SCAN_INTERVAL,
         )
         self.client = client
+        self.data = garage_door
 
-    async def _async_update_data(self) -> dict[str, GarageDoor]:
+    async def _async_update_data(self) -> GarageDoor:
         """Fetch data from the Aladdin Connect API."""
         try:
-            doors = await self.client.get_doors()
-        except aiohttp.ClientResponseError as err:
-            if 400 <= err.status < 500:
-                raise ConfigEntryAuthFailed(err) from err
-            raise UpdateFailed(f"Error communicating with API: {err}") from err
+            await self.client.update_door(self.data.device_id, self.data.door_number)
         except aiohttp.ClientError as err:
             raise UpdateFailed(f"Error communicating with API: {err}") from err
-
-        return {door.unique_id: door for door in doors}
+        self.data.status = self.client.get_door_status(
+            self.data.device_id, self.data.door_number
+        )
+        self.data.battery_level = self.client.get_battery_status(
+            self.data.device_id, self.data.door_number
+        )
+        return self.data

homeassistant/components/aladdin_connect/cover.py

@@ -7,7 +7,7 @@ from typing import Any
 import aiohttp
 
 from homeassistant.components.cover import CoverDeviceClass, CoverEntity
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
@@ -24,22 +24,11 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the cover platform."""
-    coordinator = entry.runtime_data
-    known_devices: set[str] = set()
+    coordinators = entry.runtime_data
 
-    @callback
-    def _async_add_new_devices() -> None:
-        """Detect and add entities for new doors."""
-        current_devices = set(coordinator.data)
-        new_devices = current_devices - known_devices
-        if new_devices:
-            known_devices.update(new_devices)
-            async_add_entities(
-                AladdinCoverEntity(coordinator, door_id) for door_id in new_devices
-            )
-
-    _async_add_new_devices()
-    entry.async_on_unload(coordinator.async_add_listener(_async_add_new_devices))
+    async_add_entities(
+        AladdinCoverEntity(coordinator) for coordinator in coordinators.values()
+    )
 
 
 class AladdinCoverEntity(AladdinConnectEntity, CoverEntity):
@@ -49,10 +38,10 @@ class AladdinCoverEntity(AladdinConnectEntity, CoverEntity):
     _attr_supported_features = SUPPORTED_FEATURES
     _attr_name = None
 
-    def __init__(self, coordinator: AladdinConnectCoordinator, door_id: str) -> None:
+    def __init__(self, coordinator: AladdinConnectCoordinator) -> None:
         """Initialize the Aladdin Connect cover."""
-        super().__init__(coordinator, door_id)
-        self._attr_unique_id = door_id
+        super().__init__(coordinator)
+        self._attr_unique_id = coordinator.data.unique_id
 
     async def async_open_cover(self, **kwargs: Any) -> None:
         """Issue open command to cover."""
@@ -77,16 +66,16 @@ class AladdinCoverEntity(AladdinConnectEntity, CoverEntity):
     @property
     def is_closed(self) -> bool | None:
         """Update is closed attribute."""
-        if (status := self.door.status) is None:
+        if (status := self.coordinator.data.status) is None:
             return None
         return status == "closed"
 
     @property
     def is_closing(self) -> bool | None:
         """Update is closing attribute."""
-        return self.door.status == "closing"
+        return self.coordinator.data.status == "closing"
 
     @property
     def is_opening(self) -> bool | None:
         """Update is opening attribute."""
-        return self.door.status == "opening"
+        return self.coordinator.data.status == "opening"

homeassistant/components/aladdin_connect/diagnostics.py

@@ -20,13 +20,13 @@ async def async_get_config_entry_diagnostics(
         "config_entry": async_redact_data(config_entry.as_dict(), TO_REDACT),
         "doors": {
             uid: {
-                "device_id": door.device_id,
-                "door_number": door.door_number,
-                "name": door.name,
-                "status": door.status,
-                "link_status": door.link_status,
-                "battery_level": door.battery_level,
+                "device_id": coordinator.data.device_id,
+                "door_number": coordinator.data.door_number,
+                "name": coordinator.data.name,
+                "status": coordinator.data.status,
+                "link_status": coordinator.data.link_status,
+                "battery_level": coordinator.data.battery_level,
             }
-            for uid, door in config_entry.runtime_data.data.items()
+            for uid, coordinator in config_entry.runtime_data.items()
         },
     }

homeassistant/components/aladdin_connect/entity.py

@@ -1,7 +1,6 @@
 """Base class for Aladdin Connect entities."""
 
 from genie_partner_sdk.client import AladdinConnectClient
-from genie_partner_sdk.model import GarageDoor
 
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
@@ -15,28 +14,17 @@ class AladdinConnectEntity(CoordinatorEntity[AladdinConnectCoordinator]):
 
     _attr_has_entity_name = True
 
-    def __init__(self, coordinator: AladdinConnectCoordinator, door_id: str) -> None:
+    def __init__(self, coordinator: AladdinConnectCoordinator) -> None:
         """Initialize Aladdin Connect entity."""
         super().__init__(coordinator)
-        self._door_id = door_id
-        door = self.door
+        device = coordinator.data
         self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, door.unique_id)},
+            identifiers={(DOMAIN, device.unique_id)},
             manufacturer="Aladdin Connect",
-            name=door.name,
+            name=device.name,
         )
-        self._device_id = door.device_id
-        self._number = door.door_number
-
-    @property
-    def available(self) -> bool:
-        """Return True if entity is available."""
-        return super().available and self._door_id in self.coordinator.data
-
-    @property
-    def door(self) -> GarageDoor:
-        """Return the garage door data."""
-        return self.coordinator.data[self._door_id]
+        self._device_id = device.device_id
+        self._number = device.door_number
 
     @property
     def client(self) -> AladdinConnectClient:

homeassistant/components/aladdin_connect/quality_scale.yaml

@@ -57,7 +57,7 @@ rules:
   docs-supported-functions: done
   docs-troubleshooting: done
   docs-use-cases: done
-  dynamic-devices: done
+  dynamic-devices: todo
   entity-category: done
   entity-device-class: done
   entity-disabled-by-default: done

homeassistant/components/aladdin_connect/sensor.py

@@ -14,7 +14,7 @@ from homeassistant.components.sensor import (
     SensorStateClass,
 )
 from homeassistant.const import PERCENTAGE, EntityCategory
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .coordinator import AladdinConnectConfigEntry, AladdinConnectCoordinator
@@ -49,24 +49,13 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Aladdin Connect sensor devices."""
-    coordinator = entry.runtime_data
-    known_devices: set[str] = set()
+    coordinators = entry.runtime_data
 
-    @callback
-    def _async_add_new_devices() -> None:
-        """Detect and add entities for new doors."""
-        current_devices = set(coordinator.data)
-        new_devices = current_devices - known_devices
-        if new_devices:
-            known_devices.update(new_devices)
-            async_add_entities(
-                AladdinConnectSensor(coordinator, door_id, description)
-                for door_id in new_devices
-                for description in SENSOR_TYPES
-            )
-
-    _async_add_new_devices()
-    entry.async_on_unload(coordinator.async_add_listener(_async_add_new_devices))
+    async_add_entities(
+        AladdinConnectSensor(coordinator, description)
+        for coordinator in coordinators.values()
+        for description in SENSOR_TYPES
+    )
 
 
 class AladdinConnectSensor(AladdinConnectEntity, SensorEntity):
@@ -77,15 +66,14 @@ class AladdinConnectSensor(AladdinConnectEntity, SensorEntity):
     def __init__(
         self,
         coordinator: AladdinConnectCoordinator,
-        door_id: str,
         entity_description: AladdinConnectSensorEntityDescription,
     ) -> None:
         """Initialize the Aladdin Connect sensor."""
-        super().__init__(coordinator, door_id)
+        super().__init__(coordinator)
         self.entity_description = entity_description
-        self._attr_unique_id = f"{door_id}-{entity_description.key}"
+        self._attr_unique_id = f"{coordinator.data.unique_id}-{entity_description.key}"
 
     @property
     def native_value(self) -> float | None:
         """Return the state of the sensor."""
-        return self.entity_description.value_fn(self.door)
+        return self.entity_description.value_fn(self.coordinator.data)

homeassistant/components/alarm_control_panel/condition.py

@@ -2,7 +2,6 @@
 
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.automation import DomainSpec
 from homeassistant.helpers.condition import (
     Condition,
     EntityStateConditionBase,
@@ -44,7 +43,7 @@ def make_entity_state_required_features_condition(
     class CustomCondition(EntityStateRequiredFeaturesCondition):
         """Condition for entity state changes."""
 
-        _domain_specs = {domain: DomainSpec()}
+        _domain = domain
         _states = {to_state}
         _required_features = required_features
 

homeassistant/components/alarm_control_panel/trigger.py

@@ -2,7 +2,6 @@
 
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.automation import DomainSpec
 from homeassistant.helpers.entity import get_supported_features
 from homeassistant.helpers.trigger import (
     EntityTargetStateTriggerBase,
@@ -45,7 +44,7 @@ def make_entity_state_trigger_required_features(
     class CustomTrigger(EntityStateTriggerRequiredFeatures):
         """Trigger for entity state changes."""
 
-        _domain_specs = {domain: DomainSpec()}
+        _domains = {domain}
         _to_states = {to_state}
         _required_features = required_features
 

homeassistant/components/alexa_devices/entity.py

@@ -1,5 +1,6 @@
 """Defines a base Alexa Devices entity."""
 
+from aioamazondevices.const.devices import SPEAKER_GROUP_DEVICE_TYPE
 from aioamazondevices.structures import AmazonDevice
 
 from homeassistant.helpers.device_registry import DeviceInfo
@@ -24,15 +25,20 @@ class AmazonEntity(CoordinatorEntity[AmazonDevicesCoordinator]):
         """Initialize the entity."""
         super().__init__(coordinator)
         self._serial_num = serial_num
+        model = self.device.model
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, serial_num)},
             name=self.device.account_name,
-            model=self.device.model,
+            model=model,
             model_id=self.device.device_type,
             manufacturer=self.device.manufacturer or "Amazon",
             hw_version=self.device.hardware_version,
-            sw_version=self.device.software_version,
-            serial_number=serial_num,
+            sw_version=(
+                self.device.software_version
+                if model != SPEAKER_GROUP_DEVICE_TYPE
+                else None
+            ),
+            serial_number=serial_num if model != SPEAKER_GROUP_DEVICE_TYPE else None,
         )
         self.entity_description = description
         self._attr_unique_id = f"{serial_num}-{description.key}"

homeassistant/components/alexa_devices/manifest.json

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

homeassistant/components/alexa_devices/switch.py

@@ -101,10 +101,7 @@ class AmazonSwitchEntity(AmazonEntity, SwitchEntity):
             assert method is not None
 
         await method(self.device, state)
-        self.coordinator.data[self.device.serial_number].sensors[
-            self.entity_description.key
-        ].value = state
-        self.async_write_ha_state()
+        await self.coordinator.async_request_refresh()
 
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the switch on."""

homeassistant/components/analytics/analytics.py

@@ -338,7 +338,6 @@ class Analytics:
 
         hass = self._hass
         supervisor_info = None
-        addons_info: dict[str, Any] | None = None
         operating_system_info: dict[str, Any] = {}
 
         if self._data.uuid is None:
@@ -348,7 +347,6 @@ class Analytics:
         if self.supervisor:
             supervisor_info = hassio.get_supervisor_info(hass)
             operating_system_info = hassio.get_os_info(hass) or {}
-            addons_info = hassio.get_addons_info(hass) or {}
 
         system_info = await async_get_system_info(hass)
         integrations = []
@@ -421,10 +419,13 @@ class Analytics:
 
                 integrations.append(integration.domain)
 
-            if addons_info is not None:
+            if supervisor_info is not None:
                 supervisor_client = hassio.get_supervisor_client(hass)
                 installed_addons = await asyncio.gather(
-                    *(supervisor_client.addons.addon_info(slug) for slug in addons_info)
+                    *(
+                        supervisor_client.addons.addon_info(addon[ATTR_SLUG])
+                        for addon in supervisor_info[ATTR_ADDONS]
+                    )
                 )
                 addons.extend(
                     {

homeassistant/components/anglian_water/sensor.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from dataclasses import dataclass
-from datetime import datetime
 from enum import StrEnum
 
 from pyanglianwater.meter import SmartMeter
@@ -33,14 +32,13 @@ class AnglianWaterSensor(StrEnum):
     YESTERDAY_WATER_COST = "yesterday_water_cost"
     YESTERDAY_SEWERAGE_COST = "yesterday_sewerage_cost"
     LATEST_READING = "latest_reading"
-    LAST_UPDATED = "last_updated"
 
 
 @dataclass(frozen=True, kw_only=True)
 class AnglianWaterSensorEntityDescription(SensorEntityDescription):
     """Describes AnglianWater sensor entity."""
 
-    value_fn: Callable[[SmartMeter], float | datetime | None]
+    value_fn: Callable[[SmartMeter], float]
 
 
 ENTITY_DESCRIPTIONS: tuple[AnglianWaterSensorEntityDescription, ...] = (
@@ -78,13 +76,6 @@ ENTITY_DESCRIPTIONS: tuple[AnglianWaterSensorEntityDescription, ...] = (
         translation_key=AnglianWaterSensor.YESTERDAY_SEWERAGE_COST,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
-    AnglianWaterSensorEntityDescription(
-        key=AnglianWaterSensor.LAST_UPDATED,
-        device_class=SensorDeviceClass.TIMESTAMP,
-        value_fn=lambda entity: entity.last_updated,
-        translation_key=AnglianWaterSensor.LAST_UPDATED,
-        entity_category=EntityCategory.DIAGNOSTIC,
-    ),
 )
 
 
@@ -121,6 +112,6 @@ class AnglianWaterSensorEntity(AnglianWaterEntity, SensorEntity):
         self.entity_description = description
 
     @property
-    def native_value(self) -> float | datetime | None:
+    def native_value(self) -> float | None:
         """Return the state of the sensor."""
         return self.entity_description.value_fn(self.smart_meter)

homeassistant/components/anglian_water/strings.json

@@ -34,9 +34,6 @@
   },
   "entity": {
     "sensor": {
-      "last_updated": {
-        "name": "Last meter reading processed"
-      },
       "latest_reading": {
         "name": "Latest reading"
       },

homeassistant/components/arcam_fmj/__init__.py

@@ -8,55 +8,46 @@ from typing import Any
 from arcam.fmj import ConnectionFailed
 from arcam.fmj.client import Client
 
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, CONF_PORT, Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers.dispatcher import async_dispatcher_send
 
-from .const import DEFAULT_SCAN_INTERVAL
-from .coordinator import ArcamFmjConfigEntry, ArcamFmjCoordinator, ArcamFmjRuntimeData
+from .const import (
+    DEFAULT_SCAN_INTERVAL,
+    SIGNAL_CLIENT_DATA,
+    SIGNAL_CLIENT_STARTED,
+    SIGNAL_CLIENT_STOPPED,
+)
+
+type ArcamFmjConfigEntry = ConfigEntry[Client]
 
 _LOGGER = logging.getLogger(__name__)
 
 
-PLATFORMS = [Platform.BINARY_SENSOR, Platform.MEDIA_PLAYER, Platform.SENSOR]
+PLATFORMS = [Platform.MEDIA_PLAYER]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ArcamFmjConfigEntry) -> bool:
     """Set up config entry."""
-    client = Client(entry.data[CONF_HOST], entry.data[CONF_PORT])
-
-    coordinators: dict[int, ArcamFmjCoordinator] = {}
-    for zone in (1, 2):
-        coordinator = ArcamFmjCoordinator(hass, entry, client, zone)
-        coordinators[zone] = coordinator
-
-    entry.runtime_data = ArcamFmjRuntimeData(client, coordinators)
+    entry.runtime_data = Client(entry.data[CONF_HOST], entry.data[CONF_PORT])
 
     entry.async_create_background_task(
-        hass,
-        _run_client(hass, entry.runtime_data, DEFAULT_SCAN_INTERVAL),
-        "arcam_fmj",
+        hass, _run_client(hass, entry.runtime_data, DEFAULT_SCAN_INTERVAL), "arcam_fmj"
     )
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: ArcamFmjConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Cleanup before removing config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
 
-async def _run_client(
-    hass: HomeAssistant,
-    runtime_data: ArcamFmjRuntimeData,
-    interval: float,
-) -> None:
-    client = runtime_data.client
-    coordinators = runtime_data.coordinators
-
+async def _run_client(hass: HomeAssistant, client: Client, interval: float) -> None:
     def _listen(_: Any) -> None:
-        for coordinator in coordinators.values():
-            coordinator.async_notify_data_updated()
+        async_dispatcher_send(hass, SIGNAL_CLIENT_DATA, client.host)
 
     while True:
         try:
@@ -64,21 +55,16 @@ async def _run_client(
                 await client.start()
 
             _LOGGER.debug("Client connected %s", client.host)
+            async_dispatcher_send(hass, SIGNAL_CLIENT_STARTED, client.host)
 
             try:
-                for coordinator in coordinators.values():
-                    await coordinator.state.start()
-
                 with client.listen(_listen):
-                    for coordinator in coordinators.values():
-                        coordinator.async_notify_connected()
                     await client.process()
             finally:
                 await client.stop()
 
                 _LOGGER.debug("Client disconnected %s", client.host)
-                for coordinator in coordinators.values():
-                    coordinator.async_notify_disconnected()
+                async_dispatcher_send(hass, SIGNAL_CLIENT_STOPPED, client.host)
 
         except ConnectionFailed:
             await asyncio.sleep(interval)

homeassistant/components/arcam_fmj/binary_sensor.py

@@ -1,68 +0,0 @@
-"""Arcam binary sensors for incoming stream info."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from dataclasses import dataclass
-
-from arcam.fmj.state import State
-
-from homeassistant.components.binary_sensor import (
-    BinarySensorEntity,
-    BinarySensorEntityDescription,
-)
-from homeassistant.const import EntityCategory
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import ArcamFmjConfigEntry
-from .entity import ArcamFmjEntity
-
-
-@dataclass(frozen=True, kw_only=True)
-class ArcamFmjBinarySensorEntityDescription(BinarySensorEntityDescription):
-    """Describes an Arcam FMJ binary sensor entity."""
-
-    value_fn: Callable[[State], bool | None]
-
-
-BINARY_SENSORS: tuple[ArcamFmjBinarySensorEntityDescription, ...] = (
-    ArcamFmjBinarySensorEntityDescription(
-        key="incoming_video_interlaced",
-        translation_key="incoming_video_interlaced",
-        entity_category=EntityCategory.DIAGNOSTIC,
-        value_fn=lambda state: (
-            vp.interlaced
-            if (vp := state.get_incoming_video_parameters()) is not None
-            else None
-        ),
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: ArcamFmjConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Arcam FMJ binary sensors from a config entry."""
-    coordinators = config_entry.runtime_data.coordinators
-
-    entities: list[ArcamFmjBinarySensorEntity] = []
-    for coordinator in coordinators.values():
-        entities.extend(
-            ArcamFmjBinarySensorEntity(coordinator, description)
-            for description in BINARY_SENSORS
-        )
-    async_add_entities(entities)
-
-
-class ArcamFmjBinarySensorEntity(ArcamFmjEntity, BinarySensorEntity):
-    """Representation of an Arcam FMJ binary sensor."""
-
-    entity_description: ArcamFmjBinarySensorEntityDescription
-
-    @property
-    def is_on(self) -> bool | None:
-        """Return the binary sensor value."""
-        return self.entity_description.value_fn(self.coordinator.state)

homeassistant/components/arcam_fmj/const.py

@@ -2,6 +2,10 @@
 
 DOMAIN = "arcam_fmj"
 
+SIGNAL_CLIENT_STARTED = "arcam.client_started"
+SIGNAL_CLIENT_STOPPED = "arcam.client_stopped"
+SIGNAL_CLIENT_DATA = "arcam.client_data"
+
 EVENT_TURN_ON = "arcam_fmj.turn_on"
 
 DEFAULT_PORT = 50000

homeassistant/components/arcam_fmj/coordinator.py

@@ -1,97 +0,0 @@
-"""Coordinator for Arcam FMJ integration."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-import logging
-
-from arcam.fmj import ConnectionFailed
-from arcam.fmj.client import Client
-from arcam.fmj.state import State
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-
-from .const import DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-
-@dataclass
-class ArcamFmjRuntimeData:
-    """Runtime data for Arcam FMJ integration."""
-
-    client: Client
-    coordinators: dict[int, ArcamFmjCoordinator]
-
-
-type ArcamFmjConfigEntry = ConfigEntry[ArcamFmjRuntimeData]
-
-
-class ArcamFmjCoordinator(DataUpdateCoordinator[None]):
-    """Coordinator for a single Arcam FMJ zone."""
-
-    config_entry: ArcamFmjConfigEntry
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        config_entry: ArcamFmjConfigEntry,
-        client: Client,
-        zone: int,
-    ) -> None:
-        """Initialize the coordinator."""
-        super().__init__(
-            hass,
-            _LOGGER,
-            config_entry=config_entry,
-            name=f"Arcam FMJ zone {zone}",
-        )
-        self.client = client
-        self.state = State(client, zone)
-        self.last_update_success = False
-
-        name = config_entry.title
-        unique_id = config_entry.unique_id or config_entry.entry_id
-        unique_id_device = unique_id
-        if zone != 1:
-            unique_id_device += f"-{zone}"
-            name += f" Zone {zone}"
-
-        self.device_info = DeviceInfo(
-            identifiers={(DOMAIN, unique_id_device)},
-            manufacturer="Arcam",
-            model="Arcam FMJ AVR",
-            name=name,
-        )
-        self.zone_unique_id = f"{unique_id}-{zone}"
-
-        if zone != 1:
-            self.device_info["via_device"] = (DOMAIN, unique_id)
-
-    async def _async_update_data(self) -> None:
-        """Fetch data for manual refresh."""
-        try:
-            await self.state.update()
-        except ConnectionFailed as err:
-            raise UpdateFailed(
-                f"Connection failed during update for zone {self.state.zn}"
-            ) from err
-
-    @callback
-    def async_notify_data_updated(self) -> None:
-        """Notify that new data has been received from the device."""
-        self.async_set_updated_data(None)
-
-    @callback
-    def async_notify_connected(self) -> None:
-        """Handle client connected."""
-        self.hass.async_create_task(self.async_refresh())
-
-    @callback
-    def async_notify_disconnected(self) -> None:
-        """Handle client disconnected."""
-        self.last_update_success = False
-        self.async_update_listeners()

homeassistant/components/arcam_fmj/entity.py

@@ -1,28 +0,0 @@
-"""Base entity for Arcam FMJ integration."""
-
-from __future__ import annotations
-
-from homeassistant.helpers.entity import EntityDescription
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .coordinator import ArcamFmjCoordinator
-
-
-class ArcamFmjEntity(CoordinatorEntity[ArcamFmjCoordinator]):
-    """Base entity for Arcam FMJ."""
-
-    _attr_has_entity_name = True
-
-    def __init__(
-        self,
-        coordinator: ArcamFmjCoordinator,
-        description: EntityDescription | None = None,
-    ) -> None:
-        """Initialize the entity."""
-        super().__init__(coordinator)
-        self._attr_device_info = coordinator.device_info
-        self._attr_entity_registry_enabled_default = coordinator.state.zn == 1
-        self._attr_unique_id = coordinator.zone_unique_id
-        if description is not None:
-            self._attr_unique_id = f"{self._attr_unique_id}-{description.key}"
-            self.entity_description = description

homeassistant/components/arcam_fmj/icons.json

@@ -1,35 +0,0 @@
-{
-  "entity": {
-    "binary_sensor": {
-      "incoming_video_interlaced": {
-        "default": "mdi:reorder-horizontal"
-      }
-    },
-    "sensor": {
-      "incoming_audio_config": {
-        "default": "mdi:surround-sound"
-      },
-      "incoming_audio_format": {
-        "default": "mdi:dolby"
-      },
-      "incoming_audio_sample_rate": {
-        "default": "mdi:waveform"
-      },
-      "incoming_video_aspect_ratio": {
-        "default": "mdi:aspect-ratio"
-      },
-      "incoming_video_colorspace": {
-        "default": "mdi:palette"
-      },
-      "incoming_video_horizontal_resolution": {
-        "default": "mdi:arrow-expand-horizontal"
-      },
-      "incoming_video_refresh_rate": {
-        "default": "mdi:animation"
-      },
-      "incoming_video_vertical_resolution": {
-        "default": "mdi:arrow-expand-vertical"
-      }
-    }
-  }
-}

homeassistant/components/arcam_fmj/media_player.py

@@ -8,6 +8,7 @@ import logging
 from typing import Any
 
 from arcam.fmj import ConnectionFailed, SourceCodes
+from arcam.fmj.state import State
 
 from homeassistant.components.media_player import (
     BrowseError,
@@ -19,13 +20,20 @@ from homeassistant.components.media_player import (
     MediaType,
 )
 from homeassistant.const import ATTR_ENTITY_ID
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import EVENT_TURN_ON
-from .coordinator import ArcamFmjConfigEntry, ArcamFmjCoordinator
-from .entity import ArcamFmjEntity
+from . import ArcamFmjConfigEntry
+from .const import (
+    DOMAIN,
+    EVENT_TURN_ON,
+    SIGNAL_CLIENT_DATA,
+    SIGNAL_CLIENT_STARTED,
+    SIGNAL_CLIENT_STOPPED,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -36,10 +44,19 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the configuration entry."""
-    coordinators = config_entry.runtime_data.coordinators
+
+    client = config_entry.runtime_data
 
     async_add_entities(
-        [ArcamFmj(coordinators[zone]) for zone in (1, 2)],
+        [
+            ArcamFmj(
+                config_entry.title,
+                State(client, zone),
+                config_entry.unique_id or config_entry.entry_id,
+            )
+            for zone in (1, 2)
+        ],
+        True,
     )
 
 
@@ -60,13 +77,21 @@ def convert_exception[**_P, _R](
     return _convert_exception
 
 
-class ArcamFmj(ArcamFmjEntity, MediaPlayerEntity):
+class ArcamFmj(MediaPlayerEntity):
     """Representation of a media device."""
 
-    def __init__(self, coordinator: ArcamFmjCoordinator) -> None:
+    _attr_should_poll = False
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        device_name: str,
+        state: State,
+        uuid: str,
+    ) -> None:
         """Initialize device."""
-        super().__init__(coordinator)
-        self._state = coordinator.state
+        self._state = state
+        self._attr_name = f"Zone {state.zn}"
         self._attr_supported_features = (
             MediaPlayerEntityFeature.SELECT_SOURCE
             | MediaPlayerEntityFeature.PLAY_MEDIA
@@ -77,8 +102,18 @@ class ArcamFmj(ArcamFmjEntity, MediaPlayerEntity):
             | MediaPlayerEntityFeature.TURN_OFF
             | MediaPlayerEntityFeature.TURN_ON
         )
-        if self._state.zn == 1:
+        if state.zn == 1:
             self._attr_supported_features |= MediaPlayerEntityFeature.SELECT_SOUND_MODE
+        self._attr_unique_id = f"{uuid}-{state.zn}"
+        self._attr_entity_registry_enabled_default = state.zn == 1
+        self._attr_device_info = DeviceInfo(
+            identifiers={
+                (DOMAIN, uuid),
+            },
+            manufacturer="Arcam",
+            model="Arcam FMJ AVR",
+            name=device_name,
+        )
 
     @property
     def state(self) -> MediaPlayerState:
@@ -87,6 +122,49 @@ class ArcamFmj(ArcamFmjEntity, MediaPlayerEntity):
             return MediaPlayerState.ON
         return MediaPlayerState.OFF
 
+    async def async_added_to_hass(self) -> None:
+        """Once registered, add listener for events."""
+        await self._state.start()
+        try:
+            await self._state.update()
+        except ConnectionFailed as connection:
+            _LOGGER.debug("Connection lost during addition: %s", connection)
+
+        @callback
+        def _data(host: str) -> None:
+            if host == self._state.client.host:
+                self.async_write_ha_state()
+
+        @callback
+        def _started(host: str) -> None:
+            if host == self._state.client.host:
+                self.async_schedule_update_ha_state(force_refresh=True)
+
+        @callback
+        def _stopped(host: str) -> None:
+            if host == self._state.client.host:
+                self.async_schedule_update_ha_state(force_refresh=True)
+
+        self.async_on_remove(
+            async_dispatcher_connect(self.hass, SIGNAL_CLIENT_DATA, _data)
+        )
+
+        self.async_on_remove(
+            async_dispatcher_connect(self.hass, SIGNAL_CLIENT_STARTED, _started)
+        )
+
+        self.async_on_remove(
+            async_dispatcher_connect(self.hass, SIGNAL_CLIENT_STOPPED, _stopped)
+        )
+
+    async def async_update(self) -> None:
+        """Force update of state."""
+        _LOGGER.debug("Update state %s", self.name)
+        try:
+            await self._state.update()
+        except ConnectionFailed as connection:
+            _LOGGER.debug("Connection lost during update: %s", connection)
+
     @convert_exception
     async def async_mute_volume(self, mute: bool) -> None:
         """Send mute command."""

homeassistant/components/arcam_fmj/sensor.py

@@ -1,162 +0,0 @@
-"""Arcam sensors for incoming stream info."""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from dataclasses import dataclass
-
-from arcam.fmj import IncomingVideoAspectRatio, IncomingVideoColorspace
-from arcam.fmj.state import IncomingAudioConfig, IncomingAudioFormat, State
-
-from homeassistant.components.sensor import (
-    SensorDeviceClass,
-    SensorEntity,
-    SensorEntityDescription,
-    SensorStateClass,
-)
-from homeassistant.const import EntityCategory, UnitOfFrequency
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import ArcamFmjConfigEntry
-from .entity import ArcamFmjEntity
-
-
-@dataclass(frozen=True, kw_only=True)
-class ArcamFmjSensorEntityDescription(SensorEntityDescription):
-    """Describes an Arcam FMJ sensor entity."""
-
-    value_fn: Callable[[State], int | float | str | None]
-
-
-SENSORS: tuple[ArcamFmjSensorEntityDescription, ...] = (
-    ArcamFmjSensorEntityDescription(
-        key="incoming_video_horizontal_resolution",
-        translation_key="incoming_video_horizontal_resolution",
-        entity_category=EntityCategory.DIAGNOSTIC,
-        state_class=SensorStateClass.MEASUREMENT,
-        native_unit_of_measurement="px",
-        suggested_display_precision=0,
-        value_fn=lambda state: (
-            vp.horizontal_resolution
-            if (vp := state.get_incoming_video_parameters()) is not None
-            else None
-        ),
-    ),
-    ArcamFmjSensorEntityDescription(
-        key="incoming_video_vertical_resolution",
-        translation_key="incoming_video_vertical_resolution",
-        entity_category=EntityCategory.DIAGNOSTIC,
-        state_class=SensorStateClass.MEASUREMENT,
-        native_unit_of_measurement="px",
-        suggested_display_precision=0,
-        value_fn=lambda state: (
-            vp.vertical_resolution
-            if (vp := state.get_incoming_video_parameters()) is not None
-            else None
-        ),
-    ),
-    ArcamFmjSensorEntityDescription(
-        key="incoming_video_refresh_rate",
-        translation_key="incoming_video_refresh_rate",
-        entity_category=EntityCategory.DIAGNOSTIC,
-        device_class=SensorDeviceClass.FREQUENCY,
-        state_class=SensorStateClass.MEASUREMENT,
-        native_unit_of_measurement=UnitOfFrequency.HERTZ,
-        suggested_display_precision=0,
-        value_fn=lambda state: (
-            vp.refresh_rate
-            if (vp := state.get_incoming_video_parameters()) is not None
-            else None
-        ),
-    ),
-    ArcamFmjSensorEntityDescription(
-        key="incoming_video_aspect_ratio",
-        translation_key="incoming_video_aspect_ratio",
-        entity_category=EntityCategory.DIAGNOSTIC,
-        device_class=SensorDeviceClass.ENUM,
-        options=[member.name.lower() for member in IncomingVideoAspectRatio],
-        value_fn=lambda state: (
-            vp.aspect_ratio.name.lower()
-            if (vp := state.get_incoming_video_parameters()) is not None
-            else None
-        ),
-    ),
-    ArcamFmjSensorEntityDescription(
-        key="incoming_video_colorspace",
-        translation_key="incoming_video_colorspace",
-        entity_category=EntityCategory.DIAGNOSTIC,
-        device_class=SensorDeviceClass.ENUM,
-        options=[member.name.lower() for member in IncomingVideoColorspace],
-        value_fn=lambda state: (
-            vp.colorspace.name.lower()
-            if (vp := state.get_incoming_video_parameters()) is not None
-            else None
-        ),
-    ),
-    ArcamFmjSensorEntityDescription(
-        key="incoming_audio_format",
-        translation_key="incoming_audio_format",
-        entity_category=EntityCategory.DIAGNOSTIC,
-        device_class=SensorDeviceClass.ENUM,
-        options=[member.name.lower() for member in IncomingAudioFormat],
-        value_fn=lambda state: (
-            result.name.lower()
-            if (result := state.get_incoming_audio_format()[0]) is not None
-            else None
-        ),
-    ),
-    ArcamFmjSensorEntityDescription(
-        key="incoming_audio_config",
-        translation_key="incoming_audio_config",
-        entity_category=EntityCategory.DIAGNOSTIC,
-        device_class=SensorDeviceClass.ENUM,
-        options=[member.name.lower() for member in IncomingAudioConfig],
-        value_fn=lambda state: (
-            result.name.lower()
-            if (result := state.get_incoming_audio_format()[1]) is not None
-            else None
-        ),
-    ),
-    ArcamFmjSensorEntityDescription(
-        key="incoming_audio_sample_rate",
-        translation_key="incoming_audio_sample_rate",
-        entity_category=EntityCategory.DIAGNOSTIC,
-        device_class=SensorDeviceClass.FREQUENCY,
-        state_class=SensorStateClass.MEASUREMENT,
-        native_unit_of_measurement=UnitOfFrequency.HERTZ,
-        suggested_display_precision=0,
-        value_fn=lambda state: (
-            None
-            if (sample_rate := state.get_incoming_audio_sample_rate()) == 0
-            else sample_rate
-        ),
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: ArcamFmjConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Arcam FMJ sensors from a config entry."""
-    coordinators = config_entry.runtime_data.coordinators
-
-    entities: list[ArcamFmjSensorEntity] = []
-    for coordinator in coordinators.values():
-        entities.extend(
-            ArcamFmjSensorEntity(coordinator, description) for description in SENSORS
-        )
-    async_add_entities(entities)
-
-
-class ArcamFmjSensorEntity(ArcamFmjEntity, SensorEntity):
-    """Representation of an Arcam FMJ sensor."""
-
-    entity_description: ArcamFmjSensorEntityDescription
-
-    @property
-    def native_value(self) -> int | float | str | None:
-        """Return the sensor value."""
-        return self.entity_description.value_fn(self.coordinator.state)

homeassistant/components/arcam_fmj/strings.json

@@ -23,121 +23,5 @@
     "trigger_type": {
       "turn_on": "{entity_name} was requested to turn on"
     }
-  },
-  "entity": {
-    "binary_sensor": {
-      "incoming_video_interlaced": {
-        "name": "Incoming video interlaced"
-      }
-    },
-    "sensor": {
-      "incoming_audio_config": {
-        "name": "Incoming audio configuration",
-        "state": {
-          "auro_10_1": "Auro 10.1",
-          "auro_11_1": "Auro 11.1",
-          "auro_13_1": "Auro 13.1",
-          "auro_2_2_2": "Auro 2.2.2",
-          "auro_5_0": "Auro 5.0",
-          "auro_5_1": "Auro 5.1",
-          "auro_8_0": "Auro 8.0",
-          "auro_9_1": "Auro 9.1",
-          "auro_quad": "Auro quad",
-          "dual_mono": "Dual mono",
-          "dual_mono_lfe": "Dual mono + LFE",
-          "mono": "Mono",
-          "mono_lfe": "Mono + LFE",
-          "stereo_center": "Stereo center",
-          "stereo_center_lfe": "Stereo center + LFE",
-          "stereo_center_surr_lr": "Stereo center surround L/R",
-          "stereo_center_surr_lr_back_lr": "Stereo center surround L/R back L/R",
-          "stereo_center_surr_lr_back_lr_lfe": "Stereo center surround L/R back L/R + LFE",
-          "stereo_center_surr_lr_back_matrix": "Stereo center surround L/R back matrix",
-          "stereo_center_surr_lr_back_matrix_lfe": "Stereo center surround L/R back matrix + LFE",
-          "stereo_center_surr_lr_back_mono": "Stereo center surround L/R back mono",
-          "stereo_center_surr_lr_back_mono_lfe": "Stereo center surround L/R back mono + LFE",
-          "stereo_center_surr_lr_lfe": "Stereo center surround L/R + LFE",
-          "stereo_center_surr_mono": "Stereo center surround mono",
-          "stereo_center_surr_mono_lfe": "Stereo center surround mono + LFE",
-          "stereo_downmix": "Stereo downmix",
-          "stereo_downmix_lfe": "Stereo downmix + LFE",
-          "stereo_lfe": "Stereo + LFE",
-          "stereo_only": "Stereo only",
-          "stereo_only_lo_ro": "Stereo only Lo/Ro",
-          "stereo_only_lo_ro_lfe": "Stereo only Lo/Ro + LFE",
-          "stereo_surr_lr": "Stereo surround L/R",
-          "stereo_surr_lr_back_lr": "Stereo surround L/R back L/R",
-          "stereo_surr_lr_back_lr_lfe": "Stereo surround L/R back L/R + LFE",
-          "stereo_surr_lr_back_matrix": "Stereo surround L/R back matrix",
-          "stereo_surr_lr_back_matrix_lfe": "Stereo surround L/R back matrix + LFE",
-          "stereo_surr_lr_back_mono": "Stereo surround L/R back mono",
-          "stereo_surr_lr_back_mono_lfe": "Stereo surround L/R back mono + LFE",
-          "stereo_surr_lr_lfe": "Stereo surround L/R + LFE",
-          "stereo_surr_mono": "Stereo surround mono",
-          "stereo_surr_mono_lfe": "Stereo surround mono + LFE",
-          "undetected": "Undetected",
-          "unknown": "Unknown"
-        }
-      },
-      "incoming_audio_format": {
-        "name": "Incoming audio format",
-        "state": {
-          "analogue_direct": "Analogue direct",
-          "auro_3d": "Auro-3D",
-          "dolby_atmos": "Dolby Atmos",
-          "dolby_digital": "Dolby Digital",
-          "dolby_digital_ex": "Dolby Digital EX",
-          "dolby_digital_plus": "Dolby Digital Plus",
-          "dolby_digital_surround": "Dolby Digital Surround",
-          "dolby_digital_true_hd": "Dolby TrueHD",
-          "dts": "DTS",
-          "dts_96_24": "DTS 96/24",
-          "dts_core": "DTS Core",
-          "dts_es_discrete": "DTS-ES Discrete",
-          "dts_es_discrete_96_24": "DTS-ES Discrete 96/24",
-          "dts_es_matrix": "DTS-ES Matrix",
-          "dts_es_matrix_96_24": "DTS-ES Matrix 96/24",
-          "dts_hd_high_res_audio": "DTS-HD High Resolution Audio",
-          "dts_hd_master_audio": "DTS-HD Master Audio",
-          "dts_low_bit_rate": "DTS Low Bit Rate",
-          "dts_x": "DTS:X",
-          "imax_enhanced": "IMAX Enhanced",
-          "pcm": "PCM",
-          "pcm_zero": "PCM zero",
-          "undetected": "Undetected",
-          "unsupported": "Unsupported"
-        }
-      },
-      "incoming_audio_sample_rate": {
-        "name": "Incoming audio sample rate"
-      },
-      "incoming_video_aspect_ratio": {
-        "name": "Incoming video aspect ratio",
-        "state": {
-          "aspect_16_9": "16:9",
-          "aspect_4_3": "4:3",
-          "undefined": "Undefined"
-        }
-      },
-      "incoming_video_colorspace": {
-        "name": "Incoming video colorspace",
-        "state": {
-          "dolby_vision": "Dolby Vision",
-          "hdr10": "HDR10",
-          "hdr10_plus": "HDR10+",
-          "hlg": "HLG",
-          "normal": "Normal"
-        }
-      },
-      "incoming_video_horizontal_resolution": {
-        "name": "Incoming video horizontal resolution"
-      },
-      "incoming_video_refresh_rate": {
-        "name": "Incoming video refresh rate"
-      },
-      "incoming_video_vertical_resolution": {
-        "name": "Incoming video vertical resolution"
-      }
-    }
   }
 }

homeassistant/components/assist_pipeline/select.py

@@ -78,13 +78,19 @@ class AssistPipelineSelect(SelectEntity, restore_state.RestoreEntity):
         index: int = 0,
     ) -> None:
         """Initialize a pipeline selector."""
-        if index >= 1:
-            self.entity_description = replace(
-                self.entity_description,
-                key=f"pipeline_{index + 1}",
-                translation_key="pipeline_n",
-                translation_placeholders={"index": str(index + 1)},
-            )
+        if index < 1:
+            # Keep compatibility
+            key_suffix = ""
+            placeholder = ""
+        else:
+            key_suffix = f"_{index + 1}"
+            placeholder = f" {index + 1}"
+
+        self.entity_description = replace(
+            self.entity_description,
+            key=f"pipeline{key_suffix}",
+            translation_placeholders={"index": placeholder},
+        )
 
         self._domain = domain
         self._unique_id_prefix = unique_id_prefix

homeassistant/components/assist_pipeline/strings.json

@@ -7,17 +7,11 @@
     },
     "select": {
       "pipeline": {
-        "name": "Assistant",
+        "name": "Assistant{index}",
         "state": {
           "preferred": "Preferred"
         }
       },
-      "pipeline_n": {
-        "name": "Assistant {index}",
-        "state": {
-          "preferred": "[%key:component::assist_pipeline::entity::select::pipeline::state::preferred%]"
-        }
-      },
       "vad_sensitivity": {
         "name": "Finished speaking detection",
         "state": {

homeassistant/components/august/__init__.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import cast
 
-from aiohttp import ClientError
+from aiohttp import ClientResponseError
 from yalexs.exceptions import AugustApiAIOHTTPError
 from yalexs.manager.exceptions import CannotConnect, InvalidAuth, RequireValidation
 from yalexs.manager.gateway import Config as YaleXSConfig
@@ -13,12 +13,7 @@ from yalexs.manager.gateway import Config as YaleXSConfig
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import EVENT_HOMEASSISTANT_STOP
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import (
-    ConfigEntryAuthFailed,
-    ConfigEntryNotReady,
-    OAuth2TokenRequestError,
-    OAuth2TokenRequestReauthError,
-)
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import device_registry as dr, issue_registry as ir
 from homeassistant.helpers.config_entry_oauth2_flow import (
     ImplementationUnavailableError,
@@ -50,18 +45,11 @@ async def async_setup_entry(hass: HomeAssistant, entry: AugustConfigEntry) -> bo
     august_gateway = AugustGateway(Path(hass.config.config_dir), session, oauth_session)
     try:
         await async_setup_august(hass, entry, august_gateway)
-    except OAuth2TokenRequestReauthError as err:
-        raise ConfigEntryAuthFailed from err
     except (RequireValidation, InvalidAuth) as err:
         raise ConfigEntryAuthFailed from err
     except TimeoutError as err:
         raise ConfigEntryNotReady("Timed out connecting to august api") from err
-    except (
-        AugustApiAIOHTTPError,
-        OAuth2TokenRequestError,
-        ClientError,
-        CannotConnect,
-    ) as err:
+    except (AugustApiAIOHTTPError, ClientResponseError, CannotConnect) as err:
         raise ConfigEntryNotReady from err
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
     return True

homeassistant/components/automation/__init__.py

@@ -121,29 +121,23 @@ _EXPERIMENTAL_CONDITION_PLATFORMS = {
     "alarm_control_panel",
     "assist_satellite",
     "climate",
-    "cover",
     "device_tracker",
-    "door",
     "fan",
-    "garage_door",
-    "gate",
     "humidifier",
     "lawn_mower",
     "light",
     "lock",
     "media_player",
-    "motion",
-    "occupancy",
     "person",
     "siren",
     "switch",
     "vacuum",
-    "window",
 }
 
 _EXPERIMENTAL_TRIGGER_PLATFORMS = {
     "alarm_control_panel",
     "assist_satellite",
+    "binary_sensor",
     "button",
     "climate",
     "cover",
@@ -151,27 +145,21 @@ _EXPERIMENTAL_TRIGGER_PLATFORMS = {
     "door",
     "fan",
     "garage_door",
-    "gate",
     "humidifier",
     "humidity",
-    "input_boolean",
     "lawn_mower",
     "light",
     "lock",
     "media_player",
-    "motion",
-    "occupancy",
     "person",
     "remote",
     "scene",
     "schedule",
-    "select",
     "siren",
     "switch",
     "text",
     "update",
     "vacuum",
-    "window",
 }
 
 

homeassistant/components/autoskope/__init__.py

@@ -1,53 +0,0 @@
-"""The Autoskope integration."""
-
-from __future__ import annotations
-
-import aiohttp
-from autoskope_client.api import AutoskopeApi
-from autoskope_client.models import CannotConnect, InvalidAuth
-
-from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME, Platform
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryError, ConfigEntryNotReady
-from homeassistant.helpers.aiohttp_client import async_create_clientsession
-
-from .const import DEFAULT_HOST
-from .coordinator import AutoskopeConfigEntry, AutoskopeDataUpdateCoordinator
-
-PLATFORMS: list[Platform] = [Platform.DEVICE_TRACKER]
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: AutoskopeConfigEntry) -> bool:
-    """Set up Autoskope from a config entry."""
-    session = async_create_clientsession(hass, cookie_jar=aiohttp.CookieJar())
-
-    api = AutoskopeApi(
-        host=entry.data.get(CONF_HOST, DEFAULT_HOST),
-        username=entry.data[CONF_USERNAME],
-        password=entry.data[CONF_PASSWORD],
-        session=session,
-    )
-
-    try:
-        await api.connect()
-    except InvalidAuth as err:
-        # Raise ConfigEntryError until reauth flow is implemented (then ConfigEntryAuthFailed)
-        raise ConfigEntryError(
-            "Authentication failed, please check credentials"
-        ) from err
-    except CannotConnect as err:
-        raise ConfigEntryNotReady("Could not connect to Autoskope API") from err
-
-    coordinator = AutoskopeDataUpdateCoordinator(hass, api, entry)
-    await coordinator.async_config_entry_first_refresh()
-
-    entry.runtime_data = coordinator
-
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: AutoskopeConfigEntry) -> bool:
-    """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/autoskope/config_flow.py

@@ -1,89 +0,0 @@
-"""Config flow for the Autoskope integration."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from autoskope_client.api import AutoskopeApi
-from autoskope_client.models import CannotConnect, InvalidAuth
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
-from homeassistant.data_entry_flow import section
-import homeassistant.helpers.config_validation as cv
-from homeassistant.helpers.selector import (
-    TextSelector,
-    TextSelectorConfig,
-    TextSelectorType,
-)
-
-from .const import DEFAULT_HOST, DOMAIN, SECTION_ADVANCED_SETTINGS
-
-STEP_USER_DATA_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_USERNAME): str,
-        vol.Required(CONF_PASSWORD): TextSelector(
-            TextSelectorConfig(type=TextSelectorType.PASSWORD)
-        ),
-        vol.Required(SECTION_ADVANCED_SETTINGS): section(
-            vol.Schema(
-                {
-                    vol.Required(CONF_HOST, default=DEFAULT_HOST): TextSelector(
-                        TextSelectorConfig(type=TextSelectorType.URL)
-                    ),
-                }
-            ),
-            {"collapsed": True},
-        ),
-    }
-)
-
-
-class AutoskopeConfigFlow(ConfigFlow, domain=DOMAIN):
-    """Handle a config flow for Autoskope."""
-
-    VERSION = 1
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the initial step."""
-        errors: dict[str, str] = {}
-        if user_input is not None:
-            username = user_input[CONF_USERNAME].lower()
-            host = user_input[SECTION_ADVANCED_SETTINGS][CONF_HOST].lower()
-
-            try:
-                cv.url(host)
-            except vol.Invalid:
-                errors["base"] = "invalid_url"
-
-            if not errors:
-                await self.async_set_unique_id(f"{username}@{host}")
-                self._abort_if_unique_id_configured()
-
-                try:
-                    async with AutoskopeApi(
-                        host=host,
-                        username=username,
-                        password=user_input[CONF_PASSWORD],
-                    ):
-                        pass
-                except CannotConnect:
-                    errors["base"] = "cannot_connect"
-                except InvalidAuth:
-                    errors["base"] = "invalid_auth"
-                else:
-                    return self.async_create_entry(
-                        title=f"Autoskope ({username})",
-                        data={
-                            CONF_USERNAME: username,
-                            CONF_PASSWORD: user_input[CONF_PASSWORD],
-                            CONF_HOST: host,
-                        },
-                    )
-
-        return self.async_show_form(
-            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
-        )

homeassistant/components/autoskope/const.py

@@ -1,9 +0,0 @@
-"""Constants for the Autoskope integration."""
-
-from datetime import timedelta
-
-DOMAIN = "autoskope"
-
-DEFAULT_HOST = "https://portal.autoskope.de"
-SECTION_ADVANCED_SETTINGS = "advanced_settings"
-UPDATE_INTERVAL = timedelta(seconds=60)

homeassistant/components/autoskope/coordinator.py

@@ -1,60 +0,0 @@
-"""Data update coordinator for the Autoskope integration."""
-
-from __future__ import annotations
-
-import logging
-
-from autoskope_client.api import AutoskopeApi
-from autoskope_client.models import CannotConnect, InvalidAuth, Vehicle
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-
-from .const import DOMAIN, UPDATE_INTERVAL
-
-_LOGGER = logging.getLogger(__name__)
-
-
-type AutoskopeConfigEntry = ConfigEntry[AutoskopeDataUpdateCoordinator]
-
-
-class AutoskopeDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Vehicle]]):
-    """Class to manage fetching Autoskope data."""
-
-    config_entry: AutoskopeConfigEntry
-
-    def __init__(
-        self, hass: HomeAssistant, api: AutoskopeApi, entry: AutoskopeConfigEntry
-    ) -> None:
-        """Initialize the coordinator."""
-        super().__init__(
-            hass,
-            _LOGGER,
-            name=DOMAIN,
-            update_interval=UPDATE_INTERVAL,
-            config_entry=entry,
-        )
-        self.api = api
-
-    async def _async_update_data(self) -> dict[str, Vehicle]:
-        """Fetch data from API endpoint."""
-        try:
-            vehicles = await self.api.get_vehicles()
-            return {vehicle.id: vehicle for vehicle in vehicles}
-
-        except InvalidAuth:
-            # Attempt to re-authenticate using stored credentials
-            try:
-                await self.api.authenticate()
-                # Retry the request after successful re-authentication
-                vehicles = await self.api.get_vehicles()
-                return {vehicle.id: vehicle for vehicle in vehicles}
-            except InvalidAuth as reauth_err:
-                raise ConfigEntryAuthFailed(
-                    f"Authentication failed: {reauth_err}"
-                ) from reauth_err
-
-        except CannotConnect as err:
-            raise UpdateFailed(f"Error communicating with API: {err}") from err

homeassistant/components/autoskope/device_tracker.py

@@ -1,145 +0,0 @@
-"""Support for Autoskope device tracking."""
-
-from __future__ import annotations
-
-from autoskope_client.constants import MANUFACTURER
-from autoskope_client.models import Vehicle
-
-from homeassistant.components.device_tracker import SourceType, TrackerEntity
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import device_registry as dr
-from homeassistant.helpers.device_registry import DeviceInfo
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
-
-from .const import DOMAIN
-from .coordinator import AutoskopeConfigEntry, AutoskopeDataUpdateCoordinator
-
-PARALLEL_UPDATES = 0
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: AutoskopeConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up Autoskope device tracker entities."""
-    coordinator: AutoskopeDataUpdateCoordinator = entry.runtime_data
-    tracked_vehicles: set[str] = set()
-
-    @callback
-    def update_entities() -> None:
-        """Update entities based on coordinator data."""
-        current_vehicles = set(coordinator.data.keys())
-        vehicles_to_add = current_vehicles - tracked_vehicles
-
-        if vehicles_to_add:
-            new_entities = [
-                AutoskopeDeviceTracker(coordinator, vehicle_id)
-                for vehicle_id in vehicles_to_add
-            ]
-            tracked_vehicles.update(vehicles_to_add)
-            async_add_entities(new_entities)
-
-    entry.async_on_unload(coordinator.async_add_listener(update_entities))
-    update_entities()
-
-
-class AutoskopeDeviceTracker(
-    CoordinatorEntity[AutoskopeDataUpdateCoordinator], TrackerEntity
-):
-    """Representation of an Autoskope tracked device."""
-
-    _attr_has_entity_name = True
-    _attr_name: str | None = None
-
-    def __init__(
-        self, coordinator: AutoskopeDataUpdateCoordinator, vehicle_id: str
-    ) -> None:
-        """Initialize the TrackerEntity."""
-        super().__init__(coordinator)
-        self._vehicle_id = vehicle_id
-        self._attr_unique_id = vehicle_id
-
-    @callback
-    def _handle_coordinator_update(self) -> None:
-        """Handle updated data from the coordinator."""
-        if (
-            self._vehicle_id in self.coordinator.data
-            and (device_entry := self.device_entry) is not None
-            and device_entry.name != self._vehicle_data.name
-        ):
-            device_registry = dr.async_get(self.hass)
-            device_registry.async_update_device(
-                device_entry.id, name=self._vehicle_data.name
-            )
-        super()._handle_coordinator_update()
-
-    @property
-    def device_info(self) -> DeviceInfo:
-        """Return device info for the vehicle."""
-        vehicle = self.coordinator.data[self._vehicle_id]
-        return DeviceInfo(
-            identifiers={(DOMAIN, str(vehicle.id))},
-            name=vehicle.name,
-            manufacturer=MANUFACTURER,
-            model=vehicle.model,
-            serial_number=vehicle.imei,
-        )
-
-    @property
-    def available(self) -> bool:
-        """Return if entity is available."""
-        return (
-            super().available
-            and self.coordinator.data is not None
-            and self._vehicle_id in self.coordinator.data
-        )
-
-    @property
-    def _vehicle_data(self) -> Vehicle:
-        """Return the vehicle data for the current entity."""
-        return self.coordinator.data[self._vehicle_id]
-
-    @property
-    def latitude(self) -> float | None:
-        """Return latitude value of the device."""
-        if (vehicle := self._vehicle_data) and vehicle.position:
-            return float(vehicle.position.latitude)
-        return None
-
-    @property
-    def longitude(self) -> float | None:
-        """Return longitude value of the device."""
-        if (vehicle := self._vehicle_data) and vehicle.position:
-            return float(vehicle.position.longitude)
-        return None
-
-    @property
-    def source_type(self) -> SourceType:
-        """Return the source type of the device."""
-        return SourceType.GPS
-
-    @property
-    def location_accuracy(self) -> float:
-        """Return the location accuracy of the device in meters."""
-        if (vehicle := self._vehicle_data) and vehicle.gps_quality:
-            if vehicle.gps_quality > 0:
-                # HDOP to estimated accuracy in meters
-                # HDOP of 1-2 = good (5-10m), 2-5 = moderate (10-25m), >5 = poor (>25m)
-                return float(max(5, int(vehicle.gps_quality * 5.0)))
-        return 0.0
-
-    @property
-    def icon(self) -> str:
-        """Return the icon based on the vehicle's activity."""
-        if self._vehicle_id not in self.coordinator.data:
-            return "mdi:car-clock"
-        vehicle = self._vehicle_data
-        if vehicle.position:
-            if vehicle.position.park_mode:
-                return "mdi:car-brake-parking"
-            if vehicle.position.speed > 5:  # Moving threshold: 5 km/h
-                return "mdi:car-arrow-right"
-            return "mdi:car"
-        return "mdi:car-clock"

homeassistant/components/autoskope/manifest.json

@@ -1,11 +0,0 @@
-{
-  "domain": "autoskope",
-  "name": "Autoskope",
-  "codeowners": ["@mcisk"],
-  "config_flow": true,
-  "documentation": "https://www.home-assistant.io/integrations/autoskope",
-  "integration_type": "hub",
-  "iot_class": "cloud_polling",
-  "quality_scale": "bronze",
-  "requirements": ["autoskope_client==1.4.1"]
-}

homeassistant/components/autoskope/quality_scale.yaml

@@ -1,88 +0,0 @@
-# + in comment indicates requirement for quality scale
-# - in comment indicates issue to be fixed, not impacting quality scale
-rules:
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: |
-      Integration does not provide custom services.
-  appropriate-polling: done
-  brands: done
-  common-modules: done
-  config-flow-test-coverage: done
-  config-flow: done
-  dependency-transparency: done
-  docs-actions:
-    status: exempt
-    comment: |
-      Integration does not provide custom services.
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup: done
-  entity-unique-id: done
-  has-entity-name: done
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup: done
-  unique-config-entry: done
-
-  # Silver
-  action-exceptions:
-    status: exempt
-    comment: |
-      Integration does not provide custom services.
-  config-entry-unloading: done
-  docs-configuration-parameters: done
-  docs-installation-parameters: done
-  entity-unavailable: done
-  integration-owner: done
-  log-when-unavailable: todo
-  parallel-updates: done
-  reauthentication-flow:
-    status: todo
-    comment: |
-      Reauthentication flow removed for initial PR, will be added in follow-up.
-  test-coverage: done
-  # Gold
-  devices: done
-  diagnostics: todo
-  discovery-update-info:
-    status: exempt
-    comment: |
-      Integration does not use discovery. Autoskope devices use NB-IoT/LTE-M (via IoT SIMs) and LoRaWAN.
-  discovery:
-    status: exempt
-    comment: |
-      Integration does not use discovery. Autoskope devices use NB-IoT/LTE-M (via IoT SIMs) and LoRaWAN.
-  docs-data-update: done
-  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
-  entity-category: done
-  entity-device-class: done
-  entity-disabled-by-default:
-    status: exempt
-    comment: |
-      Only one entity type (device_tracker) is created, making this not applicable.
-  entity-translations: done
-  exception-translations: done
-  icon-translations: done
-  reconfiguration-flow:
-    status: todo
-    comment: |
-      Reconfiguration flow removed for initial PR, will be added in follow-up.
-  repair-issues: todo
-  stale-devices: done
-
-  # Platinum
-  async-dependency: done
-  inject-websession: done
-  strict-typing:
-    status: todo
-    comment: |
-      Integration needs to be added to .strict-typing file for full compliance.

homeassistant/components/autoskope/strings.json

@@ -1,52 +0,0 @@
-{
-  "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
-    },
-    "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
-      "invalid_url": "Invalid URL",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
-    },
-    "step": {
-      "user": {
-        "data": {
-          "password": "[%key:common::config_flow::data::password%]",
-          "username": "[%key:common::config_flow::data::username%]"
-        },
-        "data_description": {
-          "password": "The password for your Autoskope account.",
-          "username": "The username for your Autoskope account."
-        },
-        "description": "Enter your Autoskope credentials.",
-        "sections": {
-          "advanced_settings": {
-            "data": {
-              "host": "API endpoint"
-            },
-            "data_description": {
-              "host": "The URL of your Autoskope API endpoint. Only change this if you use a white-label portal."
-            },
-            "name": "Advanced settings"
-          }
-        },
-        "title": "Connect to Autoskope"
-      }
-    }
-  },
-  "issues": {
-    "cannot_connect": {
-      "description": "Home Assistant could not connect to the Autoskope API at {host}. Please check the connection details and ensure the API endpoint is reachable.\n\nError: {error}",
-      "title": "Failed to connect to Autoskope"
-    },
-    "invalid_auth": {
-      "description": "Authentication with Autoskope failed for user {username}. Please re-authenticate the integration with the correct password.",
-      "title": "Invalid Autoskope authentication"
-    },
-    "low_battery": {
-      "description": "The battery voltage for vehicle {vehicle_name} ({vehicle_id}) is low ({value}V). Consider checking or replacing the battery.",
-      "title": "Low vehicle battery ({vehicle_name})"
-    }
-  }
-}

homeassistant/components/axis/manifest.json

@@ -29,7 +29,7 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["axis"],
-  "requirements": ["axis==67"],
+  "requirements": ["axis==66"],
   "ssdp": [
     {
       "manufacturer": "AXIS"

homeassistant/components/backup/manager.py

@@ -32,7 +32,6 @@ from homeassistant.helpers import (
     issue_registry as ir,
     start,
 )
-from homeassistant.helpers.debounce import Debouncer
 from homeassistant.helpers.json import json_bytes
 from homeassistant.util import dt as dt_util, json as json_util
 from homeassistant.util.async_iterator import AsyncIteratorReader
@@ -79,8 +78,6 @@ from .util import (
     validate_password_stream,
 )
 
-UPLOAD_PROGRESS_DEBOUNCE_SECONDS = 1
-
 
 @dataclass(frozen=True, kw_only=True, slots=True)
 class NewBackup:
@@ -144,7 +141,6 @@ class CreateBackupStage(StrEnum):
     ADDONS = "addons"
     AWAIT_ADDON_RESTARTS = "await_addon_restarts"
     DOCKER_CONFIG = "docker_config"
-    CLEANING_UP = "cleaning_up"
     FINISHING_FILE = "finishing_file"
     FOLDERS = "folders"
     HOME_ASSISTANT = "home_assistant"
@@ -594,49 +590,23 @@ class BackupManager:
                 )
             agent = self.backup_agents[agent_id]
 
-            latest_uploaded_bytes = 0
-
             @callback
-            def _emit_upload_progress() -> None:
-                """Emit the latest upload progress event."""
+            def on_upload_progress(*, bytes_uploaded: int, **kwargs: Any) -> None:
+                """Handle upload progress."""
                 self.async_on_backup_event(
                     UploadBackupEvent(
                         manager_state=self.state,
                         agent_id=agent_id,
-                        uploaded_bytes=latest_uploaded_bytes,
+                        uploaded_bytes=bytes_uploaded,
                         total_bytes=_backup.size,
                     )
                 )
 
-            upload_progress_debouncer: Debouncer[None] = Debouncer(
-                self.hass,
-                LOGGER,
-                cooldown=UPLOAD_PROGRESS_DEBOUNCE_SECONDS,
-                immediate=True,
-                function=_emit_upload_progress,
-            )
-
-            @callback
-            def on_upload_progress(*, bytes_uploaded: int, **kwargs: Any) -> None:
-                """Handle upload progress."""
-                nonlocal latest_uploaded_bytes
-                latest_uploaded_bytes = bytes_uploaded
-                upload_progress_debouncer.async_schedule_call()
-
             await agent.async_upload_backup(
                 open_stream=open_stream_func,
                 backup=_backup,
                 on_progress=on_upload_progress,
             )
-            upload_progress_debouncer.async_cancel()
-            self.async_on_backup_event(
-                UploadBackupEvent(
-                    manager_state=self.state,
-                    agent_id=agent_id,
-                    uploaded_bytes=_backup.size,
-                    total_bytes=_backup.size,
-                )
-            )
             if streamer:
                 await streamer.wait()
 
@@ -1291,13 +1261,6 @@ class BackupManager:
                 )
             # delete old backups more numerous than copies
             # try this regardless of agent errors above
-            self.async_on_backup_event(
-                CreateBackupEvent(
-                    reason=None,
-                    stage=CreateBackupStage.CLEANING_UP,
-                    state=CreateBackupState.IN_PROGRESS,
-                )
-            )
             await delete_backups_exceeding_configured_count(self)
 
         finally:

homeassistant/components/backup/util.py

@@ -246,8 +246,6 @@ def decrypt_backup(
         except (DecryptError, SecureTarError, tarfile.TarError) as err:
             LOGGER.warning("Error decrypting backup: %s", err)
             error = err
-        except Abort:
-            raise
         except Exception as err:  # noqa: BLE001
             LOGGER.exception("Unexpected error when decrypting backup: %s", err)
             error = err
@@ -334,10 +332,8 @@ def encrypt_backup(
         except (EncryptError, SecureTarError, tarfile.TarError) as err:
             LOGGER.warning("Error encrypting backup: %s", err)
             error = err
-        except Abort:
-            raise
         except Exception as err:  # noqa: BLE001
-            LOGGER.exception("Unexpected error when encrypting backup: %s", err)
+            LOGGER.exception("Unexpected error when decrypting backup: %s", err)
             error = err
         else:
             # Pad the output stream to the requested minimum size

homeassistant/components/binary_sensor/icons.json

@@ -174,5 +174,13 @@
         "on": "mdi:window-open"
       }
     }
+  },
+  "triggers": {
+    "occupancy_cleared": {
+      "trigger": "mdi:home-outline"
+    },
+    "occupancy_detected": {
+      "trigger": "mdi:home"
+    }
   }
 }

homeassistant/components/binary_sensor/strings.json

@@ -1,4 +1,8 @@
 {
+  "common": {
+    "trigger_behavior_description_occupancy": "The behavior of the targeted occupancy sensors to trigger on.",
+    "trigger_behavior_name": "Behavior"
+  },
   "device_automation": {
     "condition_type": {
       "is_bat_low": "{entity_name} battery is low",
@@ -317,5 +321,36 @@
       }
     }
   },
-  "title": "Binary sensor"
+  "selector": {
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
+    }
+  },
+  "title": "Binary sensor",
+  "triggers": {
+    "occupancy_cleared": {
+      "description": "Triggers after one or more occupancy sensors stop detecting occupancy.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::binary_sensor::common::trigger_behavior_description_occupancy%]",
+          "name": "[%key:component::binary_sensor::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Occupancy cleared"
+    },
+    "occupancy_detected": {
+      "description": "Triggers after one or more occupancy sensors start detecting occupancy.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::binary_sensor::common::trigger_behavior_description_occupancy%]",
+          "name": "[%key:component::binary_sensor::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Occupancy detected"
+    }
+  }
 }

homeassistant/components/binary_sensor/trigger.py

@@ -0,0 +1,67 @@
+"""Provides triggers for binary sensors."""
+
+from homeassistant.const import STATE_OFF, STATE_ON
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity import get_device_class
+from homeassistant.helpers.trigger import EntityTargetStateTriggerBase, Trigger
+from homeassistant.helpers.typing import UNDEFINED, UndefinedType
+
+from . import DOMAIN, BinarySensorDeviceClass
+
+
+def get_device_class_or_undefined(
+    hass: HomeAssistant, entity_id: str
+) -> str | None | UndefinedType:
+    """Get the device class of an entity or UNDEFINED if not found."""
+    try:
+        return get_device_class(hass, entity_id)
+    except HomeAssistantError:
+        return UNDEFINED
+
+
+class BinarySensorOnOffTrigger(EntityTargetStateTriggerBase):
+    """Class for binary sensor on/off triggers."""
+
+    _device_class: BinarySensorDeviceClass | None
+    _domains = {DOMAIN}
+
+    def entity_filter(self, entities: set[str]) -> set[str]:
+        """Filter entities of this domain."""
+        entities = super().entity_filter(entities)
+        return {
+            entity_id
+            for entity_id in entities
+            if get_device_class_or_undefined(self._hass, entity_id)
+            == self._device_class
+        }
+
+
+def make_binary_sensor_trigger(
+    device_class: BinarySensorDeviceClass | None,
+    to_state: str,
+) -> type[BinarySensorOnOffTrigger]:
+    """Create an entity state trigger class."""
+
+    class CustomTrigger(BinarySensorOnOffTrigger):
+        """Trigger for entity state changes."""
+
+        _device_class = device_class
+        _to_states = {to_state}
+
+    return CustomTrigger
+
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "occupancy_detected": make_binary_sensor_trigger(
+        BinarySensorDeviceClass.OCCUPANCY, STATE_ON
+    ),
+    "occupancy_cleared": make_binary_sensor_trigger(
+        BinarySensorDeviceClass.OCCUPANCY, STATE_OFF
+    ),
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for binary sensors."""
+    return TRIGGERS

homeassistant/components/binary_sensor/triggers.yaml

@@ -10,16 +10,16 @@
           - last
           - any
 
-detected:
+occupancy_cleared:
   fields: *trigger_common_fields
   target:
     entity:
-      - domain: binary_sensor
-        device_class: occupancy
+      domain: binary_sensor
+      device_class: occupancy
 
-cleared:
+occupancy_detected:
   fields: *trigger_common_fields
   target:
     entity:
-      - domain: binary_sensor
-        device_class: occupancy
+      domain: binary_sensor
+      device_class: occupancy

homeassistant/components/bluetooth/manifest.json

@@ -21,6 +21,6 @@
     "bluetooth-auto-recovery==1.5.3",
     "bluetooth-data-tools==1.28.4",
     "dbus-fast==3.1.2",
-    "habluetooth==5.10.2"
+    "habluetooth==5.9.1"
   ]
 }

homeassistant/components/bond/strings.json

@@ -37,8 +37,8 @@
           "name": "Entity"
         },
         "speed": {
-          "description": "The fan speed as a percentage.",
-          "name": "Fan speed"
+          "description": "Fan Speed as %.",
+          "name": "Fan Speed"
         }
       },
       "name": "Set fan speed tracked state"
@@ -47,7 +47,7 @@
       "description": "Sets the tracked brightness state of a Bond light.",
       "fields": {
         "brightness": {
-          "description": "The tracked brightness of the light.",
+          "description": "Brightness.",
           "name": "Brightness"
         },
         "entity_id": {
@@ -79,22 +79,22 @@
           "name": "Entity"
         },
         "power_state": {
-          "description": "The tracked power state.",
+          "description": "Power state.",
           "name": "Power state"
         }
       },
       "name": "Set switch power tracked state"
     },
     "start_decreasing_brightness": {
-      "description": "Starts decreasing the brightness of a light (deprecated).",
+      "description": "Starts decreasing the brightness of the light (deprecated).",
       "name": "Start decreasing brightness"
     },
     "start_increasing_brightness": {
-      "description": "Starts increasing the brightness of a light (deprecated).",
+      "description": "Starts increasing the brightness of the light (deprecated).",
       "name": "Start increasing brightness"
     },
     "stop": {
-      "description": "Stops any in-progress action and empties the queue (deprecated).",
+      "description": "Stops any in-progress action and empty the queue (deprecated).",
       "name": "[%key:common::action::stop%]"
     }
   }

homeassistant/components/button/trigger.py

@@ -2,7 +2,6 @@
 
 from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN
 from homeassistant.core import HomeAssistant, State
-from homeassistant.helpers.automation import DomainSpec
 from homeassistant.helpers.trigger import (
     ENTITY_STATE_TRIGGER_SCHEMA,
     EntityTriggerBase,
@@ -15,7 +14,7 @@ from . import DOMAIN
 class ButtonPressedTrigger(EntityTriggerBase):
     """Trigger for button entity presses."""
 
-    _domain_specs = {DOMAIN: DomainSpec()}
+    _domains = {DOMAIN}
     _schema = ENTITY_STATE_TRIGGER_SCHEMA
 
     def is_valid_transition(self, from_state: State, to_state: State) -> bool:

homeassistant/components/chess_com/diagnostics.py

@@ -1,22 +0,0 @@
-"""Diagnostics support for Chess.com."""
-
-from __future__ import annotations
-
-from dataclasses import asdict
-from typing import Any
-
-from homeassistant.core import HomeAssistant
-
-from .coordinator import ChessConfigEntry
-
-
-async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, entry: ChessConfigEntry
-) -> dict[str, Any]:
-    """Return diagnostics for a config entry."""
-    coordinator = entry.runtime_data
-
-    return {
-        "player": asdict(coordinator.data.player),
-        "stats": asdict(coordinator.data.stats),
-    }

homeassistant/components/chess_com/quality_scale.yaml

@@ -41,7 +41,7 @@ rules:
 
   # Gold
   devices: done
-  diagnostics: done
+  diagnostics: todo
   discovery-update-info:
     status: exempt
     comment: Can't detect a game

homeassistant/components/clementine/media_player.py

@@ -66,7 +66,6 @@ class ClementineDevice(MediaPlayerEntity):
         | MediaPlayerEntityFeature.SELECT_SOURCE
         | MediaPlayerEntityFeature.PLAY
     )
-    _attr_volume_step = 0.04
 
     def __init__(self, client, name):
         """Initialize the Clementine device."""
@@ -125,6 +124,16 @@ class ClementineDevice(MediaPlayerEntity):
 
         return None, None
 
+    def volume_up(self) -> None:
+        """Volume up the media player."""
+        newvolume = min(self._client.volume + 4, 100)
+        self._client.set_volume(newvolume)
+
+    def volume_down(self) -> None:
+        """Volume down media player."""
+        newvolume = max(self._client.volume - 4, 0)
+        self._client.set_volume(newvolume)
+
     def mute_volume(self, mute: bool) -> None:
         """Send mute command."""
         self._client.set_volume(0)

homeassistant/components/climate/condition.py

@@ -1,8 +1,11 @@
 """Provides conditions for climates."""
 
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.automation import DomainSpec
-from homeassistant.helpers.condition import Condition, make_entity_state_condition
+from homeassistant.helpers.condition import (
+    Condition,
+    make_entity_state_attribute_condition,
+    make_entity_state_condition,
+)
 
 from .const import ATTR_HVAC_ACTION, DOMAIN, HVACAction, HVACMode
 
@@ -19,14 +22,14 @@ CONDITIONS: dict[str, type[Condition]] = {
             HVACMode.HEAT_COOL,
         },
     ),
-    "is_cooling": make_entity_state_condition(
-        {DOMAIN: DomainSpec(value_source=ATTR_HVAC_ACTION)}, HVACAction.COOLING
+    "is_cooling": make_entity_state_attribute_condition(
+        DOMAIN, ATTR_HVAC_ACTION, HVACAction.COOLING
     ),
-    "is_drying": make_entity_state_condition(
-        {DOMAIN: DomainSpec(value_source=ATTR_HVAC_ACTION)}, HVACAction.DRYING
+    "is_drying": make_entity_state_attribute_condition(
+        DOMAIN, ATTR_HVAC_ACTION, HVACAction.DRYING
     ),
-    "is_heating": make_entity_state_condition(
-        {DOMAIN: DomainSpec(value_source=ATTR_HVAC_ACTION)}, HVACAction.HEATING
+    "is_heating": make_entity_state_attribute_condition(
+        DOMAIN, ATTR_HVAC_ACTION, HVACAction.HEATING
     ),
 }
 

homeassistant/components/climate/trigger.py

@@ -5,14 +5,14 @@ import voluptuous as vol
 from homeassistant.const import ATTR_TEMPERATURE, CONF_OPTIONS
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.automation import DomainSpec, NumericalDomainSpec
 from homeassistant.helpers.trigger import (
     ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST,
     EntityTargetStateTriggerBase,
     Trigger,
     TriggerConfig,
-    make_entity_numerical_state_changed_trigger,
-    make_entity_numerical_state_crossed_threshold_trigger,
+    make_entity_numerical_state_attribute_changed_trigger,
+    make_entity_numerical_state_attribute_crossed_threshold_trigger,
+    make_entity_target_state_attribute_trigger,
     make_entity_target_state_trigger,
     make_entity_transition_trigger,
 )
@@ -35,7 +35,7 @@ HVAC_MODE_CHANGED_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST.extend
 class HVACModeChangedTrigger(EntityTargetStateTriggerBase):
     """Trigger for entity state changes."""
 
-    _domain_specs = {DOMAIN: DomainSpec()}
+    _domains = {DOMAIN}
     _schema = HVAC_MODE_CHANGED_TRIGGER_SCHEMA
 
     def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
@@ -46,23 +46,23 @@ class HVACModeChangedTrigger(EntityTargetStateTriggerBase):
 
 TRIGGERS: dict[str, type[Trigger]] = {
     "hvac_mode_changed": HVACModeChangedTrigger,
-    "started_cooling": make_entity_target_state_trigger(
-        {DOMAIN: DomainSpec(value_source=ATTR_HVAC_ACTION)}, HVACAction.COOLING
+    "started_cooling": make_entity_target_state_attribute_trigger(
+        DOMAIN, ATTR_HVAC_ACTION, HVACAction.COOLING
     ),
-    "started_drying": make_entity_target_state_trigger(
-        {DOMAIN: DomainSpec(value_source=ATTR_HVAC_ACTION)}, HVACAction.DRYING
+    "started_drying": make_entity_target_state_attribute_trigger(
+        DOMAIN, ATTR_HVAC_ACTION, HVACAction.DRYING
     ),
-    "target_humidity_changed": make_entity_numerical_state_changed_trigger(
-        {DOMAIN: NumericalDomainSpec(value_source=ATTR_HUMIDITY)}
+    "target_humidity_changed": make_entity_numerical_state_attribute_changed_trigger(
+        {DOMAIN}, {DOMAIN: ATTR_HUMIDITY}
     ),
-    "target_humidity_crossed_threshold": make_entity_numerical_state_crossed_threshold_trigger(
-        {DOMAIN: NumericalDomainSpec(value_source=ATTR_HUMIDITY)}
+    "target_humidity_crossed_threshold": make_entity_numerical_state_attribute_crossed_threshold_trigger(
+        {DOMAIN}, {DOMAIN: ATTR_HUMIDITY}
     ),
-    "target_temperature_changed": make_entity_numerical_state_changed_trigger(
-        {DOMAIN: NumericalDomainSpec(value_source=ATTR_TEMPERATURE)}
+    "target_temperature_changed": make_entity_numerical_state_attribute_changed_trigger(
+        {DOMAIN}, {DOMAIN: ATTR_TEMPERATURE}
     ),
-    "target_temperature_crossed_threshold": make_entity_numerical_state_crossed_threshold_trigger(
-        {DOMAIN: NumericalDomainSpec(value_source=ATTR_TEMPERATURE)}
+    "target_temperature_crossed_threshold": make_entity_numerical_state_attribute_crossed_threshold_trigger(
+        {DOMAIN}, {DOMAIN: ATTR_TEMPERATURE}
     ),
     "turned_off": make_entity_target_state_trigger(DOMAIN, HVACMode.OFF),
     "turned_on": make_entity_transition_trigger(
@@ -79,8 +79,8 @@ TRIGGERS: dict[str, type[Trigger]] = {
             HVACMode.HEAT_COOL,
         },
     ),
-    "started_heating": make_entity_target_state_trigger(
-        {DOMAIN: DomainSpec(value_source=ATTR_HVAC_ACTION)}, HVACAction.HEATING
+    "started_heating": make_entity_target_state_attribute_trigger(
+        DOMAIN, ATTR_HVAC_ACTION, HVACAction.HEATING
     ),
 }
 

homeassistant/components/cloud/http_api.py

@@ -516,8 +516,6 @@ class DownloadSupportPackageView(HomeAssistantView):
         hass_info: dict[str, Any],
         domains_info: dict[str, dict[str, str]],
     ) -> str:
-        cloud = hass.data[DATA_CLOUD]
-
         def get_domain_table_markdown(domain_info: dict[str, Any]) -> str:
             if len(domain_info) == 0:
                 return "No information available\n"
@@ -574,15 +572,6 @@ class DownloadSupportPackageView(HomeAssistantView):
                 "</details>\n\n"
             )
 
-        # Add stored latency response if available
-        if locations := cloud.remote.latency_by_location:
-            markdown += "## Latency by location\n\n"
-            markdown += "Location | Latency (ms)\n"
-            markdown += "--- | ---\n"
-            for location in sorted(locations):
-                markdown += f"{location} | {locations[location]['avg'] or 'N/A'}\n"
-            markdown += "\n"
-
         # Add installed packages section
         try:
             installed_packages = await async_get_installed_packages()

homeassistant/components/cloud/manifest.json

@@ -13,6 +13,6 @@
   "integration_type": "system",
   "iot_class": "cloud_push",
   "loggers": ["acme", "hass_nabucasa", "snitun"],
-  "requirements": ["hass-nabucasa==2.0.0", "openai==2.21.0"],
+  "requirements": ["hass-nabucasa==1.15.0", "openai==2.21.0"],
   "single_config_entry": true
 }

homeassistant/components/comelit/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "local_polling",
   "loggers": ["aiocomelit"],
   "quality_scale": "platinum",
-  "requirements": ["aiocomelit==2.0.1"]
+  "requirements": ["aiocomelit==2.0.0"]
 }

homeassistant/components/config/entity_registry.py

@@ -153,8 +153,8 @@ def websocket_get_entities(
     {
         vol.Required("type"): "config/entity_registry/update",
         vol.Required("entity_id"): cv.entity_id,
-        vol.Optional("aliases"): [vol.Any(str, None)],
         # If passed in, we update value. Passing None will remove old value.
+        vol.Optional("aliases"): list,
         vol.Optional("area_id"): vol.Any(str, None),
         # Categories is a mapping of key/value (scope/category_id) pairs.
         # If passed in, we update/adjust only the provided scope(s).
@@ -225,15 +225,10 @@ def websocket_update_entity(
             changes[key] = msg[key]
 
     if "aliases" in msg:
-        # Sanitize aliases by removing:
-        #   - Trailing and leading whitespace characters in the individual aliases
+        # Create a set for the aliases without:
         #   - Empty strings
-        changes["aliases"] = aliases = []
-        for alias in msg["aliases"]:
-            if alias is None:
-                aliases.append(er.COMPUTED_NAME)
-            elif alias := alias.strip():
-                aliases.append(alias)
+        #   - Trailing and leading whitespace characters in the individual aliases
+        changes["aliases"] = {s_strip for s in msg["aliases"] if (s_strip := s.strip())}
 
     if "labels" in msg:
         # Convert labels to a set

homeassistant/components/conversation/default_agent.py

@@ -992,11 +992,18 @@ class DefaultAgent(ConversationEntity):
                         continue
                     context[attr] = state.attributes[attr]
 
-            entity_entry = entity_registry.async_get(state.entity_id)
-            for name in intent.async_get_entity_aliases(
-                self.hass, entity_entry, state=state
-            ):
-                yield (name, name, context)
+            if (
+                entity := entity_registry.async_get(state.entity_id)
+            ) and entity.aliases:
+                for alias in entity.aliases:
+                    alias = alias.strip()
+                    if not alias:
+                        continue
+
+                    yield (alias, alias, context)
+
+            # Default name
+            yield (state.name, state.name, context)
 
     def _recognize_strict(
         self,

homeassistant/components/cover/__init__.py

@@ -32,7 +32,6 @@ from homeassistant.helpers.typing import ConfigType
 from homeassistant.loader import bind_hass
 from homeassistant.util.hass_dict import HassKey
 
-from .condition import make_cover_is_closed_condition, make_cover_is_open_condition
 from .const import (
     ATTR_CURRENT_POSITION,
     ATTR_CURRENT_TILT_POSITION,
@@ -81,8 +80,6 @@ __all__ = [
     "CoverEntityFeature",
     "CoverState",
     "make_cover_closed_trigger",
-    "make_cover_is_closed_condition",
-    "make_cover_is_open_condition",
     "make_cover_opened_trigger",
 ]
 

homeassistant/components/cover/condition.py

@@ -1,103 +0,0 @@
-"""Provides conditions for covers."""
-
-from homeassistant.const import STATE_OFF, STATE_ON
-from homeassistant.core import HomeAssistant, State, split_entity_id
-from homeassistant.helpers.condition import Condition, EntityConditionBase
-
-from .const import ATTR_IS_CLOSED, DOMAIN, CoverDeviceClass
-from .models import CoverDomainSpec
-
-
-class CoverConditionBase(EntityConditionBase[CoverDomainSpec]):
-    """Base condition for cover state checks."""
-
-    def is_valid_state(self, entity_state: State) -> bool:
-        """Check if the state matches the expected cover state."""
-        domain_spec = self._domain_specs[split_entity_id(entity_state.entity_id)[0]]
-        if domain_spec.value_source is not None:
-            return (
-                entity_state.attributes.get(domain_spec.value_source)
-                == domain_spec.target_value
-            )
-        return entity_state.state == domain_spec.target_value
-
-
-def make_cover_is_open_condition(
-    *, device_classes: dict[str, str]
-) -> type[CoverConditionBase]:
-    """Create a condition for cover is open."""
-
-    class CoverIsOpenCondition(CoverConditionBase):
-        """Condition for cover is open."""
-
-        _domain_specs = {
-            domain: CoverDomainSpec(
-                device_class=dc,
-                value_source=ATTR_IS_CLOSED if domain == DOMAIN else None,
-                target_value=False if domain == DOMAIN else STATE_ON,
-            )
-            for domain, dc in device_classes.items()
-        }
-
-    return CoverIsOpenCondition
-
-
-def make_cover_is_closed_condition(
-    *, device_classes: dict[str, str]
-) -> type[CoverConditionBase]:
-    """Create a condition for cover is closed."""
-
-    class CoverIsClosedCondition(CoverConditionBase):
-        """Condition for cover is closed."""
-
-        _domain_specs = {
-            domain: CoverDomainSpec(
-                device_class=dc,
-                value_source=ATTR_IS_CLOSED if domain == DOMAIN else None,
-                target_value=True if domain == DOMAIN else STATE_OFF,
-            )
-            for domain, dc in device_classes.items()
-        }
-
-    return CoverIsClosedCondition
-
-
-DEVICE_CLASSES_AWNING: dict[str, str] = {DOMAIN: CoverDeviceClass.AWNING}
-DEVICE_CLASSES_BLIND: dict[str, str] = {DOMAIN: CoverDeviceClass.BLIND}
-DEVICE_CLASSES_CURTAIN: dict[str, str] = {DOMAIN: CoverDeviceClass.CURTAIN}
-DEVICE_CLASSES_SHADE: dict[str, str] = {DOMAIN: CoverDeviceClass.SHADE}
-DEVICE_CLASSES_SHUTTER: dict[str, str] = {DOMAIN: CoverDeviceClass.SHUTTER}
-
-CONDITIONS: dict[str, type[Condition]] = {
-    "awning_is_closed": make_cover_is_closed_condition(
-        device_classes=DEVICE_CLASSES_AWNING
-    ),
-    "awning_is_open": make_cover_is_open_condition(
-        device_classes=DEVICE_CLASSES_AWNING
-    ),
-    "blind_is_closed": make_cover_is_closed_condition(
-        device_classes=DEVICE_CLASSES_BLIND
-    ),
-    "blind_is_open": make_cover_is_open_condition(device_classes=DEVICE_CLASSES_BLIND),
-    "curtain_is_closed": make_cover_is_closed_condition(
-        device_classes=DEVICE_CLASSES_CURTAIN
-    ),
-    "curtain_is_open": make_cover_is_open_condition(
-        device_classes=DEVICE_CLASSES_CURTAIN
-    ),
-    "shade_is_closed": make_cover_is_closed_condition(
-        device_classes=DEVICE_CLASSES_SHADE
-    ),
-    "shade_is_open": make_cover_is_open_condition(device_classes=DEVICE_CLASSES_SHADE),
-    "shutter_is_closed": make_cover_is_closed_condition(
-        device_classes=DEVICE_CLASSES_SHUTTER
-    ),
-    "shutter_is_open": make_cover_is_open_condition(
-        device_classes=DEVICE_CLASSES_SHUTTER
-    ),
-}
-
-
-async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
-    """Return the conditions for covers."""
-    return CONDITIONS

homeassistant/components/cover/conditions.yaml

@@ -1,80 +0,0 @@
-.condition_common_fields: &condition_common_fields
-  behavior:
-    required: true
-    default: any
-    selector:
-      select:
-        translation_key: condition_behavior
-        options:
-          - all
-          - any
-
-awning_is_closed:
-  fields: *condition_common_fields
-  target:
-    entity:
-      - domain: cover
-        device_class: awning
-
-awning_is_open:
-  fields: *condition_common_fields
-  target:
-    entity:
-      - domain: cover
-        device_class: awning
-
-blind_is_closed:
-  fields: *condition_common_fields
-  target:
-    entity:
-      - domain: cover
-        device_class: blind
-
-blind_is_open:
-  fields: *condition_common_fields
-  target:
-    entity:
-      - domain: cover
-        device_class: blind
-
-curtain_is_closed:
-  fields: *condition_common_fields
-  target:
-    entity:
-      - domain: cover
-        device_class: curtain
-
-curtain_is_open:
-  fields: *condition_common_fields
-  target:
-    entity:
-      - domain: cover
-        device_class: curtain
-
-shade_is_closed:
-  fields: *condition_common_fields
-  target:
-    entity:
-      - domain: cover
-        device_class: shade
-
-shade_is_open:
-  fields: *condition_common_fields
-  target:
-    entity:
-      - domain: cover
-        device_class: shade
-
-shutter_is_closed:
-  fields: *condition_common_fields
-  target:
-    entity:
-      - domain: cover
-        device_class: shutter
-
-shutter_is_open:
-  fields: *condition_common_fields
-  target:
-    entity:
-      - domain: cover
-        device_class: shutter

homeassistant/components/cover/icons.json

@@ -1,36 +1,4 @@
 {
-  "conditions": {
-    "awning_is_closed": {
-      "condition": "mdi:storefront-outline"
-    },
-    "awning_is_open": {
-      "condition": "mdi:storefront-outline"
-    },
-    "blind_is_closed": {
-      "condition": "mdi:blinds-horizontal-closed"
-    },
-    "blind_is_open": {
-      "condition": "mdi:blinds-horizontal"
-    },
-    "curtain_is_closed": {
-      "condition": "mdi:curtains-closed"
-    },
-    "curtain_is_open": {
-      "condition": "mdi:curtains"
-    },
-    "shade_is_closed": {
-      "condition": "mdi:roller-shade-closed"
-    },
-    "shade_is_open": {
-      "condition": "mdi:roller-shade"
-    },
-    "shutter_is_closed": {
-      "condition": "mdi:window-shutter"
-    },
-    "shutter_is_open": {
-      "condition": "mdi:window-shutter-open"
-    }
-  },
   "entity_component": {
     "_": {
       "default": "mdi:window-open",

homeassistant/components/cover/intent.py

@@ -15,6 +15,7 @@ async def async_setup_intents(hass: HomeAssistant) -> None:
             INTENT_OPEN_COVER,
             DOMAIN,
             SERVICE_OPEN_COVER,
+            "Opening {}",
             description="Opens a cover",
             platforms={DOMAIN},
             device_classes={CoverDeviceClass},
@@ -26,6 +27,7 @@ async def async_setup_intents(hass: HomeAssistant) -> None:
             INTENT_CLOSE_COVER,
             DOMAIN,
             SERVICE_CLOSE_COVER,
+            "Closing {}",
             description="Closes a cover",
             platforms={DOMAIN},
             device_classes={CoverDeviceClass},

homeassistant/components/cover/models.py

@@ -1,12 +0,0 @@
-"""Data models for the cover integration."""
-
-from dataclasses import dataclass
-
-from homeassistant.helpers.automation import DomainSpec
-
-
-@dataclass(frozen=True, slots=True)
-class CoverDomainSpec(DomainSpec):
-    """DomainSpec with a target value for comparison."""
-
-    target_value: str | bool | None = None

homeassistant/components/cover/strings.json

@@ -1,112 +1,8 @@
 {
   "common": {
-    "condition_behavior_description": "How the state should match on the targeted covers.",
-    "condition_behavior_name": "Behavior",
     "trigger_behavior_description": "The behavior of the targeted covers to trigger on.",
     "trigger_behavior_name": "Behavior"
   },
-  "conditions": {
-    "awning_is_closed": {
-      "description": "Tests if one or more awnings are closed.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::cover::common::condition_behavior_description%]",
-          "name": "[%key:component::cover::common::condition_behavior_name%]"
-        }
-      },
-      "name": "Awning is closed"
-    },
-    "awning_is_open": {
-      "description": "Tests if one or more awnings are open.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::cover::common::condition_behavior_description%]",
-          "name": "[%key:component::cover::common::condition_behavior_name%]"
-        }
-      },
-      "name": "Awning is open"
-    },
-    "blind_is_closed": {
-      "description": "Tests if one or more blinds are closed.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::cover::common::condition_behavior_description%]",
-          "name": "[%key:component::cover::common::condition_behavior_name%]"
-        }
-      },
-      "name": "Blind is closed"
-    },
-    "blind_is_open": {
-      "description": "Tests if one or more blinds are open.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::cover::common::condition_behavior_description%]",
-          "name": "[%key:component::cover::common::condition_behavior_name%]"
-        }
-      },
-      "name": "Blind is open"
-    },
-    "curtain_is_closed": {
-      "description": "Tests if one or more curtains are closed.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::cover::common::condition_behavior_description%]",
-          "name": "[%key:component::cover::common::condition_behavior_name%]"
-        }
-      },
-      "name": "Curtain is closed"
-    },
-    "curtain_is_open": {
-      "description": "Tests if one or more curtains are open.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::cover::common::condition_behavior_description%]",
-          "name": "[%key:component::cover::common::condition_behavior_name%]"
-        }
-      },
-      "name": "Curtain is open"
-    },
-    "shade_is_closed": {
-      "description": "Tests if one or more shades are closed.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::cover::common::condition_behavior_description%]",
-          "name": "[%key:component::cover::common::condition_behavior_name%]"
-        }
-      },
-      "name": "Shade is closed"
-    },
-    "shade_is_open": {
-      "description": "Tests if one or more shades are open.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::cover::common::condition_behavior_description%]",
-          "name": "[%key:component::cover::common::condition_behavior_name%]"
-        }
-      },
-      "name": "Shade is open"
-    },
-    "shutter_is_closed": {
-      "description": "Tests if one or more shutters are closed.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::cover::common::condition_behavior_description%]",
-          "name": "[%key:component::cover::common::condition_behavior_name%]"
-        }
-      },
-      "name": "Shutter is closed"
-    },
-    "shutter_is_open": {
-      "description": "Tests if one or more shutters are open.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::cover::common::condition_behavior_description%]",
-          "name": "[%key:component::cover::common::condition_behavior_name%]"
-        }
-      },
-      "name": "Shutter is open"
-    }
-  },
   "device_automation": {
     "action_type": {
       "close": "Close {entity_name}",
@@ -191,12 +87,6 @@
     }
   },
   "selector": {
-    "condition_behavior": {
-      "options": {
-        "all": "All",
-        "any": "Any"
-      }
-    },
     "trigger_behavior": {
       "options": {
         "any": "Any",

homeassistant/components/cover/trigger.py

@@ -2,72 +2,80 @@
 
 from homeassistant.const import STATE_OFF, STATE_ON, STATE_UNAVAILABLE, STATE_UNKNOWN
 from homeassistant.core import HomeAssistant, State, split_entity_id
-from homeassistant.helpers.trigger import EntityTriggerBase, Trigger
+from homeassistant.helpers.trigger import (
+    EntityTriggerBase,
+    Trigger,
+    get_device_class_or_undefined,
+)
 
 from .const import ATTR_IS_CLOSED, DOMAIN, CoverDeviceClass
-from .models import CoverDomainSpec
 
 
-class CoverTriggerBase(EntityTriggerBase[CoverDomainSpec]):
+class CoverTriggerBase(EntityTriggerBase):
     """Base trigger for cover state changes."""
 
-    def _get_value(self, state: State) -> str | bool | None:
-        """Extract the relevant value from state based on domain spec."""
-        domain_spec = self._domain_specs[split_entity_id(state.entity_id)[0]]
-        if domain_spec.value_source is not None:
-            return state.attributes.get(domain_spec.value_source)
-        return state.state
+    _binary_sensor_target_state: str
+    _cover_is_closed_target_value: bool
+    _device_classes: dict[str, str]
+
+    def entity_filter(self, entities: set[str]) -> set[str]:
+        """Filter entities by cover device class."""
+        entities = super().entity_filter(entities)
+        return {
+            entity_id
+            for entity_id in entities
+            if get_device_class_or_undefined(self._hass, entity_id)
+            == self._device_classes[split_entity_id(entity_id)[0]]
+        }
 
     def is_valid_state(self, state: State) -> bool:
         """Check if the state matches the target cover state."""
-        domain_spec = self._domain_specs[split_entity_id(state.entity_id)[0]]
-        return self._get_value(state) == domain_spec.target_value
+        if split_entity_id(state.entity_id)[0] == DOMAIN:
+            return (
+                state.attributes.get(ATTR_IS_CLOSED)
+                == self._cover_is_closed_target_value
+            )
+        return state.state == self._binary_sensor_target_state
 
     def is_valid_transition(self, from_state: State, to_state: State) -> bool:
         """Check if the transition is valid for a cover state change."""
         if from_state.state in (STATE_UNAVAILABLE, STATE_UNKNOWN):
             return False
-        if (from_value := self._get_value(from_state)) is None:
-            return False
-        return from_value != self._get_value(to_state)
+        if split_entity_id(from_state.entity_id)[0] == DOMAIN:
+            if (from_is_closed := from_state.attributes.get(ATTR_IS_CLOSED)) is None:
+                return False
+            return from_is_closed != to_state.attributes.get(ATTR_IS_CLOSED)  # type: ignore[no-any-return]
+        return from_state.state != to_state.state
 
 
 def make_cover_opened_trigger(
-    *, device_classes: dict[str, str]
+    *, device_classes: dict[str, str], domains: set[str] | None = None
 ) -> type[CoverTriggerBase]:
     """Create a trigger cover_opened."""
 
     class CoverOpenedTrigger(CoverTriggerBase):
         """Trigger for cover opened state changes."""
 
-        _domain_specs = {
-            domain: CoverDomainSpec(
-                device_class=dc,
-                value_source=ATTR_IS_CLOSED if domain == DOMAIN else None,
-                target_value=False if domain == DOMAIN else STATE_ON,
-            )
-            for domain, dc in device_classes.items()
-        }
+        _binary_sensor_target_state = STATE_ON
+        _cover_is_closed_target_value = False
+        _domains = domains or {DOMAIN}
+        _device_classes = device_classes
 
     return CoverOpenedTrigger
 
 
 def make_cover_closed_trigger(
-    *, device_classes: dict[str, str]
+    *, device_classes: dict[str, str], domains: set[str] | None = None
 ) -> type[CoverTriggerBase]:
     """Create a trigger cover_closed."""
 
     class CoverClosedTrigger(CoverTriggerBase):
         """Trigger for cover closed state changes."""
 
-        _domain_specs = {
-            domain: CoverDomainSpec(
-                device_class=dc,
-                value_source=ATTR_IS_CLOSED if domain == DOMAIN else None,
-                target_value=True if domain == DOMAIN else STATE_OFF,
-            )
-            for domain, dc in device_classes.items()
-        }
+        _binary_sensor_target_state = STATE_OFF
+        _cover_is_closed_target_value = True
+        _domains = domains or {DOMAIN}
+        _device_classes = device_classes
 
     return CoverClosedTrigger
 

homeassistant/components/demo/valve.py

@@ -9,12 +9,9 @@ from typing import Any
 from homeassistant.components.valve import ValveEntity, ValveEntityFeature, ValveState
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback
-from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.event import async_track_utc_time_change
 
-from . import DOMAIN
-
 OPEN_CLOSE_DELAY = 2  # Used to give a realistic open/close experience in frontend
 
 
@@ -26,10 +23,10 @@ async def async_setup_entry(
     """Set up the Demo config entry."""
     async_add_entities(
         [
-            DemoValve("valve_1", "Front Garden", ValveState.OPEN),
-            DemoValve("valve_2", "Orchard", ValveState.CLOSED),
-            DemoValve("valve_3", "Back Garden", ValveState.CLOSED, position=70),
-            DemoValve("valve_4", "Trees", ValveState.CLOSED, position=30),
+            DemoValve("Front Garden", ValveState.OPEN),
+            DemoValve("Orchard", ValveState.CLOSED),
+            DemoValve("Back Garden", ValveState.CLOSED, position=70),
+            DemoValve("Trees", ValveState.CLOSED, position=30),
         ]
     )
 
@@ -37,24 +34,17 @@ async def async_setup_entry(
 class DemoValve(ValveEntity):
     """Representation of a Demo valve."""
 
-    _attr_has_entity_name = True
-    _attr_name = None
     _attr_should_poll = False
 
     def __init__(
         self,
-        unique_id: str,
         name: str,
         state: str,
         moveable: bool = True,
         position: int | None = None,
     ) -> None:
         """Initialize the valve."""
-        self._attr_unique_id = unique_id
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, unique_id)},
-            name=name,
-        )
+        self._attr_name = name
         if moveable:
             self._attr_supported_features = (
                 ValveEntityFeature.OPEN | ValveEntityFeature.CLOSE

homeassistant/components/diagnostics/__init__.py

@@ -38,9 +38,9 @@ from homeassistant.util.hass_dict import HassKey
 from homeassistant.util.json import format_unserializable_data
 
 from .const import DOMAIN, REDACTED, DiagnosticsSubType, DiagnosticsType
-from .util import async_redact_data, entity_entry_as_dict
+from .util import async_redact_data
 
-__all__ = ["REDACTED", "async_redact_data", "entity_entry_as_dict"]
+__all__ = ["REDACTED", "async_redact_data"]
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/diagnostics/util.py

@@ -5,10 +5,7 @@ from __future__ import annotations
 from collections.abc import Iterable, Mapping
 from typing import Any, cast, overload
 
-import attr
-
 from homeassistant.core import callback
-from homeassistant.helpers.entity_registry import RegistryEntry
 
 from .const import REDACTED
 
@@ -45,16 +42,3 @@ def async_redact_data[_T](data: _T, to_redact: Iterable[Any]) -> _T:
             redacted[key] = [async_redact_data(item, to_redact) for item in value]
 
     return cast(_T, redacted)
-
-
-def _entity_entry_filter(a: attr.Attribute, _: Any) -> bool:
-    return a.name not in ("_cache", "compat_aliases", "compat_name")
-
-
-@callback
-def entity_entry_as_dict(entry: RegistryEntry) -> dict[str, Any]:
-    """Convert an entity registry entry to a dict for diagnostics.
-
-    This excludes internal fields that should not be exposed in diagnostics.
-    """
-    return attr.asdict(entry, filter=_entity_entry_filter)

homeassistant/components/door/condition.py

@@ -1,29 +0,0 @@
-"""Provides conditions for doors."""
-
-from homeassistant.components.binary_sensor import (
-    DOMAIN as BINARY_SENSOR_DOMAIN,
-    BinarySensorDeviceClass,
-)
-from homeassistant.components.cover import (
-    DOMAIN as COVER_DOMAIN,
-    CoverDeviceClass,
-    make_cover_is_closed_condition,
-    make_cover_is_open_condition,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.condition import Condition
-
-DEVICE_CLASSES_DOOR: dict[str, str] = {
-    BINARY_SENSOR_DOMAIN: BinarySensorDeviceClass.DOOR,
-    COVER_DOMAIN: CoverDeviceClass.DOOR,
-}
-
-CONDITIONS: dict[str, type[Condition]] = {
-    "is_closed": make_cover_is_closed_condition(device_classes=DEVICE_CLASSES_DOOR),
-    "is_open": make_cover_is_open_condition(device_classes=DEVICE_CLASSES_DOOR),
-}
-
-
-async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
-    """Return the conditions for doors."""
-    return CONDITIONS

homeassistant/components/door/conditions.yaml

@@ -1,28 +0,0 @@
-.condition_common_fields: &condition_common_fields
-  behavior:
-    required: true
-    default: any
-    selector:
-      select:
-        translation_key: condition_behavior
-        options:
-          - all
-          - any
-
-is_closed:
-  fields: *condition_common_fields
-  target:
-    entity:
-      - domain: binary_sensor
-        device_class: door
-      - domain: cover
-        device_class: door
-
-is_open:
-  fields: *condition_common_fields
-  target:
-    entity:
-      - domain: binary_sensor
-        device_class: door
-      - domain: cover
-        device_class: door

homeassistant/components/door/icons.json

@@ -1,12 +1,4 @@
 {
-  "conditions": {
-    "is_closed": {
-      "condition": "mdi:door-closed"
-    },
-    "is_open": {
-      "condition": "mdi:door-open"
-    }
-  },
   "triggers": {
     "closed": {
       "trigger": "mdi:door-closed"

homeassistant/components/door/strings.json

@@ -1,39 +1,9 @@
 {
   "common": {
-    "condition_behavior_description": "How the state should match on the targeted doors.",
-    "condition_behavior_name": "Behavior",
     "trigger_behavior_description": "The behavior of the targeted doors to trigger on.",
     "trigger_behavior_name": "Behavior"
   },
-  "conditions": {
-    "is_closed": {
-      "description": "Tests if one or more doors are closed.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::door::common::condition_behavior_description%]",
-          "name": "[%key:component::door::common::condition_behavior_name%]"
-        }
-      },
-      "name": "Door is closed"
-    },
-    "is_open": {
-      "description": "Tests if one or more doors are open.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::door::common::condition_behavior_description%]",
-          "name": "[%key:component::door::common::condition_behavior_name%]"
-        }
-      },
-      "name": "Door is open"
-    }
-  },
   "selector": {
-    "condition_behavior": {
-      "options": {
-        "all": "All",
-        "any": "Any"
-      }
-    },
     "trigger_behavior": {
       "options": {
         "any": "Any",

homeassistant/components/door/trigger.py

@@ -20,8 +20,14 @@ DEVICE_CLASSES_DOOR: dict[str, str] = {
 
 
 TRIGGERS: dict[str, type[Trigger]] = {
-    "opened": make_cover_opened_trigger(device_classes=DEVICE_CLASSES_DOOR),
-    "closed": make_cover_closed_trigger(device_classes=DEVICE_CLASSES_DOOR),
+    "opened": make_cover_opened_trigger(
+        device_classes=DEVICE_CLASSES_DOOR,
+        domains={BINARY_SENSOR_DOMAIN, COVER_DOMAIN},
+    ),
+    "closed": make_cover_closed_trigger(
+        device_classes=DEVICE_CLASSES_DOOR,
+        domains={BINARY_SENSOR_DOMAIN, COVER_DOMAIN},
+    ),
 }
 
 

homeassistant/components/eheimdigital/__init__.py

@@ -10,7 +10,6 @@ from .const import DOMAIN
 from .coordinator import EheimDigitalConfigEntry, EheimDigitalUpdateCoordinator
 
 PLATFORMS = [
-    Platform.BINARY_SENSOR,
     Platform.CLIMATE,
     Platform.LIGHT,
     Platform.NUMBER,

homeassistant/components/eheimdigital/binary_sensor.py

@@ -1,101 +0,0 @@
-"""EHEIM Digital binary sensors."""
-
-from collections.abc import Callable
-from dataclasses import dataclass
-from typing import Any
-
-from eheimdigital.device import EheimDigitalDevice
-from eheimdigital.reeflex import EheimDigitalReeflexUV
-
-from homeassistant.components.binary_sensor import (
-    BinarySensorDeviceClass,
-    BinarySensorEntity,
-    BinarySensorEntityDescription,
-)
-from homeassistant.const import EntityCategory
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import EheimDigitalConfigEntry, EheimDigitalUpdateCoordinator
-from .entity import EheimDigitalEntity
-
-# Coordinator is used to centralize the data updates
-PARALLEL_UPDATES = 0
-
-
-@dataclass(frozen=True, kw_only=True)
-class EheimDigitalBinarySensorDescription[_DeviceT: EheimDigitalDevice](
-    BinarySensorEntityDescription
-):
-    """Class describing EHEIM Digital binary sensor entities."""
-
-    value_fn: Callable[[_DeviceT], bool | None]
-
-
-REEFLEX_DESCRIPTIONS: tuple[
-    EheimDigitalBinarySensorDescription[EheimDigitalReeflexUV], ...
-] = (
-    EheimDigitalBinarySensorDescription[EheimDigitalReeflexUV](
-        key="is_lighting",
-        translation_key="is_lighting",
-        value_fn=lambda device: device.is_lighting,
-        device_class=BinarySensorDeviceClass.LIGHT,
-    ),
-    EheimDigitalBinarySensorDescription[EheimDigitalReeflexUV](
-        key="is_uvc_connected",
-        translation_key="is_uvc_connected",
-        entity_category=EntityCategory.DIAGNOSTIC,
-        value_fn=lambda device: device.is_uvc_connected,
-        device_class=BinarySensorDeviceClass.CONNECTIVITY,
-    ),
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: EheimDigitalConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the callbacks for the coordinator so binary sensors can be added as devices are found."""
-    coordinator = entry.runtime_data
-
-    def async_setup_device_entities(
-        device_address: dict[str, EheimDigitalDevice],
-    ) -> None:
-        """Set up the binary sensor entities for one or multiple devices."""
-        entities: list[EheimDigitalBinarySensor[Any]] = []
-        for device in device_address.values():
-            if isinstance(device, EheimDigitalReeflexUV):
-                entities += [
-                    EheimDigitalBinarySensor[EheimDigitalReeflexUV](
-                        coordinator, device, description
-                    )
-                    for description in REEFLEX_DESCRIPTIONS
-                ]
-
-        async_add_entities(entities)
-
-    coordinator.add_platform_callback(async_setup_device_entities)
-    async_setup_device_entities(coordinator.hub.devices)
-
-
-class EheimDigitalBinarySensor[_DeviceT: EheimDigitalDevice](
-    EheimDigitalEntity[_DeviceT], BinarySensorEntity
-):
-    """Represent an EHEIM Digital binary sensor entity."""
-
-    entity_description: EheimDigitalBinarySensorDescription[_DeviceT]
-
-    def __init__(
-        self,
-        coordinator: EheimDigitalUpdateCoordinator,
-        device: _DeviceT,
-        description: EheimDigitalBinarySensorDescription[_DeviceT],
-    ) -> None:
-        """Initialize an EHEIM Digital binary sensor entity."""
-        super().__init__(coordinator, device)
-        self.entity_description = description
-        self._attr_unique_id = f"{self._device_address}_{description.key}"
-
-    def _async_update_attrs(self) -> None:
-        self._attr_is_on = self.entity_description.value_fn(self._device)

homeassistant/components/eheimdigital/icons.json

@@ -1,19 +1,5 @@
 {
   "entity": {
-    "binary_sensor": {
-      "is_lighting": {
-        "default": "mdi:lightbulb-outline",
-        "state": {
-          "on": "mdi:lightbulb-on"
-        }
-      },
-      "is_uvc_connected": {
-        "default": "mdi:lightbulb-off",
-        "state": {
-          "on": "mdi:lightbulb-outline"
-        }
-      }
-    },
     "number": {
       "day_speed": {
         "default": "mdi:weather-sunny"

homeassistant/components/eheimdigital/strings.json

@@ -33,17 +33,6 @@
     }
   },
   "entity": {
-    "binary_sensor": {
-      "is_lighting": {
-        "state": {
-          "off": "[%key:common::state::off%]",
-          "on": "[%key:common::state::on%]"
-        }
-      },
-      "is_uvc_connected": {
-        "name": "UVC lamp connected"
-      }
-    },
     "climate": {
       "heater": {
         "state_attributes": {

homeassistant/components/enphase_envoy/diagnostics.py

@@ -11,7 +11,7 @@ from attr import asdict
 from pyenphase.envoy import Envoy
 from pyenphase.exceptions import EnvoyError
 
-from homeassistant.components.diagnostics import async_redact_data, entity_entry_as_dict
+from homeassistant.components.diagnostics import async_redact_data
 from homeassistant.const import (
     CONF_NAME,
     CONF_PASSWORD,
@@ -111,7 +111,8 @@ async def async_get_config_entry_diagnostics(
             if state := hass.states.get(entity.entity_id):
                 state_dict = dict(state.as_dict())
                 state_dict.pop("context", None)
-            entity_dict = entity_entry_as_dict(entity)
+            entity_dict = asdict(entity)
+            entity_dict.pop("_cache", None)
             entities.append({"entity": entity_dict, "state": state_dict})
         device_dict = asdict(device)
         device_dict.pop("_cache", None)

homeassistant/components/enphase_envoy/manifest.json

@@ -8,7 +8,7 @@
   "iot_class": "local_polling",
   "loggers": ["pyenphase"],
   "quality_scale": "platinum",
-  "requirements": ["pyenphase==2.4.6"],
+  "requirements": ["pyenphase==2.4.5"],
   "zeroconf": [
     {
       "type": "_enphase-envoy._tcp.local."

homeassistant/components/esphome/light.py

@@ -160,23 +160,6 @@ class EsphomeLight(EsphomeEntity[LightInfo, LightState], LightEntity):
     _native_supported_color_modes: tuple[ESPHomeColorMode, ...]
     _supports_color_mode = False
 
-    def _color_temp_to_cold_warm(self, color_temp_mired: float) -> tuple[float, float]:
-        """Convert a color temperature in mireds to cold/warm white fractions.
-
-        Returns (cold_white, warm_white) normalized so the brighter channel
-        is 1.0.
-        """
-        static_info = self._static_info
-        min_mireds = static_info.min_mireds
-        max_mireds = static_info.max_mireds
-        if max_mireds <= min_mireds:
-            return 1.0, 1.0
-        color_temp_clamped = min(max(color_temp_mired, min_mireds), max_mireds)
-        ww_frac = (color_temp_clamped - min_mireds) / (max_mireds - min_mireds)
-        cw_frac = 1 - ww_frac
-        max_frac = max(cw_frac, ww_frac)
-        return cw_frac / max_frac, ww_frac / max_frac
-
     @property
     @esphome_state_property
     def is_on(self) -> bool:
@@ -258,19 +241,12 @@ class EsphomeLight(EsphomeEntity[LightInfo, LightState], LightEntity):
 
         if (color_temp_k := kwargs.get(ATTR_COLOR_TEMP_KELVIN)) is not None:
             # Do not use kelvin_to_mired here to prevent precision loss
-            color_temp_mired = 1_000_000.0 / color_temp_k
+            data["color_temperature"] = 1_000_000.0 / color_temp_k
             if color_temp_modes := _filter_color_modes(
                 color_modes, LightColorCapability.COLOR_TEMPERATURE
             ):
-                data["color_temperature"] = color_temp_mired
                 color_modes = color_temp_modes
             else:
-                # Convert color temperature to explicit cold/warm white
-                # values to avoid ESPHome applying brightness to both
-                # master brightness and white channels (b² effect).
-                data["cold_white"], data["warm_white"] = self._color_temp_to_cold_warm(
-                    color_temp_mired
-                )
                 color_modes = _filter_color_modes(
                     color_modes, LightColorCapability.COLD_WARM_WHITE
                 )
@@ -369,13 +345,19 @@ class EsphomeLight(EsphomeEntity[LightInfo, LightState], LightEntity):
             self._native_supported_color_modes, LightColorCapability.COLD_WARM_WHITE
         ):
             # Try to reverse white + color temp to cwww
+            static_info = self._static_info
+            min_ct = static_info.min_mireds
+            max_ct = static_info.max_mireds
+            color_temp = min(max(state.color_temperature, min_ct), max_ct)
             white = state.white
-            cw, ww = self._color_temp_to_cold_warm(state.color_temperature)
+
+            ww_frac = (color_temp - min_ct) / (max_ct - min_ct)
+            cw_frac = 1 - ww_frac
 
             return (
                 *rgb,
-                round(white * cw * 255),
-                round(white * ww * 255),
+                round(white * cw_frac / max(cw_frac, ww_frac) * 255),
+                round(white * ww_frac / max(cw_frac, ww_frac) * 255),
             )
         return (
             *rgb,

homeassistant/components/esphome/manifest.json

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

homeassistant/components/esphome/select.py

@@ -123,13 +123,19 @@ class EsphomeAssistSatelliteWakeWordSelect(
 
     def __init__(self, entry_data: RuntimeEntryData, index: int = 0) -> None:
         """Initialize a wake word selector."""
-        if index >= 1:
-            self.entity_description = replace(
-                self.entity_description,
-                key=f"wake_word_{index + 1}",
-                translation_key="wake_word_n",
-                translation_placeholders={"index": str(index + 1)},
-            )
+        if index < 1:
+            # Keep compatibility
+            key_suffix = ""
+            placeholder = ""
+        else:
+            key_suffix = f"_{index + 1}"
+            placeholder = f" {index + 1}"
+
+        self.entity_description = replace(
+            self.entity_description,
+            key=f"wake_word{key_suffix}",
+            translation_placeholders={"index": placeholder},
+        )
 
         EsphomeAssistEntity.__init__(self, entry_data)
 

homeassistant/components/esphome/strings.json

@@ -107,12 +107,6 @@
           "preferred": "[%key:component::assist_pipeline::entity::select::pipeline::state::preferred%]"
         }
       },
-      "pipeline_n": {
-        "name": "[%key:component::assist_pipeline::entity::select::pipeline_n::name%]",
-        "state": {
-          "preferred": "[%key:component::assist_pipeline::entity::select::pipeline::state::preferred%]"
-        }
-      },
       "vad_sensitivity": {
         "name": "[%key:component::assist_pipeline::entity::select::vad_sensitivity::name%]",
         "state": {
@@ -122,18 +116,11 @@
         }
       },
       "wake_word": {
-        "name": "Wake word",
+        "name": "Wake word{index}",
         "state": {
           "no_wake_word": "No wake word",
           "okay_nabu": "Okay Nabu"
         }
-      },
-      "wake_word_n": {
-        "name": "Wake word {index}",
-        "state": {
-          "no_wake_word": "[%key:component::esphome::entity::select::wake_word::state::no_wake_word%]",
-          "okay_nabu": "[%key:component::esphome::entity::select::wake_word::state::okay_nabu%]"
-        }
       }
     }
   },

homeassistant/components/esphome/water_heater.py

@@ -5,13 +5,7 @@ from __future__ import annotations
 from functools import partial
 from typing import Any
 
-from aioesphomeapi import (
-    EntityInfo,
-    WaterHeaterFeature,
-    WaterHeaterInfo,
-    WaterHeaterMode,
-    WaterHeaterState,
-)
+from aioesphomeapi import EntityInfo, WaterHeaterInfo, WaterHeaterMode, WaterHeaterState
 
 from homeassistant.components.water_heater import (
     WaterHeaterEntity,
@@ -60,7 +54,6 @@ class EsphomeWaterHeater(
         static_info = self._static_info
         self._attr_min_temp = static_info.min_temperature
         self._attr_max_temp = static_info.max_temperature
-        self._attr_target_temperature_step = static_info.target_temperature_step
         features = WaterHeaterEntityFeature.TARGET_TEMPERATURE
         if static_info.supported_modes:
             features |= WaterHeaterEntityFeature.OPERATION_MODE
@@ -70,8 +63,6 @@ class EsphomeWaterHeater(
             ]
         else:
             self._attr_operation_list = None
-        if static_info.supported_features & WaterHeaterFeature.SUPPORTS_ON_OFF:
-            features |= WaterHeaterEntityFeature.ON_OFF
         self._attr_supported_features = features
 
     @property
@@ -110,24 +101,6 @@ class EsphomeWaterHeater(
             device_id=self._static_info.device_id,
         )
 
-    @convert_api_error_ha_error
-    async def async_turn_on(self, **kwargs: Any) -> None:
-        """Turn the water heater on."""
-        self._client.water_heater_command(
-            key=self._key,
-            on=True,
-            device_id=self._static_info.device_id,
-        )
-
-    @convert_api_error_ha_error
-    async def async_turn_off(self, **kwargs: Any) -> None:
-        """Turn the water heater off."""
-        self._client.water_heater_command(
-            key=self._key,
-            on=False,
-            device_id=self._static_info.device_id,
-        )
-
 
 async_setup_entry = partial(
     platform_async_setup_entry,

homeassistant/components/evohome/climate.py

@@ -363,12 +363,10 @@ class EvoController(EvoClimateEntity):
 
         Data validation is not required, it will have been done upstream.
         """
-
-        if service == EvoService.RESET_SYSTEM:
-            await self.coordinator.call_client_api(self._evo_device.reset())
-            return
-
-        mode = data[ATTR_MODE]  # otherwise it is EvoService.SET_SYSTEM_MODE
+        if service == EvoService.SET_SYSTEM_MODE:
+            mode = data[ATTR_MODE]
+        else:  # otherwise it is EvoService.RESET_SYSTEM
+            mode = EvoSystemMode.AUTO_WITH_RESET
 
         if ATTR_PERIOD in data:
             until = dt_util.start_of_local_day()