Disable unnecessary parts to test image build

Since 2026.02.0 the builder has sha-pinning fixed, so we can also get rid of
the Zizmor error suppression.

Builder changes:
* https://github.com/home-assistant/builder/releases/tag/2026.02.0
* https://github.com/home-assistant/builder/releases/tag/2026.02.1

.github/workflows/builder.yml

@@ -57,10 +57,10 @@ jobs:
         with:
           type: ${{ env.BUILD_TYPE }}
 
-      - name: Verify version
-        uses: home-assistant/actions/helpers/verify-version@master # zizmor: ignore[unpinned-uses]
-        with:
-          ignore-dev: true
+      # - name: Verify version
+      #   uses: home-assistant/actions/helpers/verify-version@master # zizmor: ignore[unpinned-uses]
+      #   with:
+      #     ignore-dev: true
 
       - name: Fail if translations files are checked in
         run: |
@@ -272,7 +272,7 @@ jobs:
     name: Build ${{ matrix.machine }} machine core image
     if: github.repository_owner == 'home-assistant'
     needs: ["init", "build_base"]
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.runs-on }}
     permissions:
       contents: read # To check out the repository
       packages: write # To push to GHCR
@@ -294,6 +294,21 @@ jobs:
           - raspberrypi5-64
           - yellow
           - green
+        include:
+          # Default: aarch64 on native ARM runner
+          - arch: aarch64
+            runs-on: ubuntu-24.04-arm
+          # Overrides for amd64 machines
+          - machine: generic-x86-64
+            arch: amd64
+            runs-on: ubuntu-24.04
+          - machine: qemux86-64
+            arch: amd64
+            runs-on: ubuntu-24.04
+          # TODO: remove, intel-nuc is a legacy name for x86-64, renamed in 2021
+          - machine: intel-nuc
+            arch: amd64
+            runs-on: ubuntu-24.04
     steps:
       - name: Checkout the repository
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
@@ -321,286 +336,288 @@ jobs:
           password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Build base image
-        uses: home-assistant/builder@21bc64d76dad7a5184c67826aab41c6b6f89023a # 2025.11.0
+        uses: home-assistant/builder@6cb4fd3d1338b6e22d0958a4bcb53e0965ea63b4 # 2026.02.1
         with:
+          image: ${{ matrix.arch }}
           args: |
             $BUILD_ARGS \
+            --test \
             --target /data/machine \
             --cosign \
             --machine "${{ needs.init.outputs.version }}=${{ matrix.machine }}"
 
-  publish_ha:
-    name: Publish version files
-    environment: ${{ needs.init.outputs.channel }}
-    if: github.repository_owner == 'home-assistant'
-    needs: ["init", "build_machine"]
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-
-      - name: Initialize git
-        uses: home-assistant/actions/helpers/git-init@master # zizmor: ignore[unpinned-uses]
-        with:
-          name: ${{ secrets.GIT_NAME }}
-          email: ${{ secrets.GIT_EMAIL }}
-          token: ${{ secrets.GIT_TOKEN }}
-
-      - name: Update version file
-        uses: home-assistant/actions/helpers/version-push@master # zizmor: ignore[unpinned-uses]
-        with:
-          key: "homeassistant[]"
-          key-description: "Home Assistant Core"
-          version: ${{ needs.init.outputs.version }}
-          channel: ${{ needs.init.outputs.channel }}
-          exclude-list: '["odroid-xu","qemuarm","qemux86","raspberrypi","raspberrypi2","raspberrypi3","raspberrypi4","tinker"]'
-
-      - name: Update version file (stable -> beta)
-        if: needs.init.outputs.channel == 'stable'
-        uses: home-assistant/actions/helpers/version-push@master # zizmor: ignore[unpinned-uses]
-        with:
-          key: "homeassistant[]"
-          key-description: "Home Assistant Core"
-          version: ${{ needs.init.outputs.version }}
-          channel: beta
-          exclude-list: '["odroid-xu","qemuarm","qemux86","raspberrypi","raspberrypi2","raspberrypi3","raspberrypi4","tinker"]'
-
-  publish_container:
-    name: Publish meta container for ${{ matrix.registry }}
-    environment: ${{ needs.init.outputs.channel }}
-    if: github.repository_owner == 'home-assistant'
-    needs: ["init", "build_base"]
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read # To check out the repository
-      packages: write # To push to GHCR
-      id-token: write # For cosign signing
-    strategy:
-      fail-fast: false
-      matrix:
-        registry: ["ghcr.io/home-assistant", "docker.io/homeassistant"]
-    steps:
-      - name: Install Cosign
-        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@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
-      - name: Login to GitHub Container Registry
-        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Verify architecture image signatures
-        shell: bash
-        env:
-          ARCHITECTURES: ${{ needs.init.outputs.architectures }}
-          VERSION: ${{ needs.init.outputs.version }}
-        run: |
-          ARCHS=$(echo "${ARCHITECTURES}" | jq -r '.[]')
-          for arch in $ARCHS; do
-            echo "Verifying ${arch} image signature..."
-            cosign verify \
-              --certificate-oidc-issuer https://token.actions.githubusercontent.com \
-              --certificate-identity-regexp https://github.com/home-assistant/core/.* \
-              "ghcr.io/home-assistant/${arch}-homeassistant:${VERSION}"
-          done
-          echo "✓ All images verified successfully"
-
-      # Generate all Docker tags based on version string
-      # Version format: YYYY.MM.PATCH, YYYY.MM.PATCHbN (beta), or YYYY.MM.PATCH.devYYYYMMDDHHMM (dev)
-      # Examples:
-      #   2025.12.1     (stable)    -> tags: 2025.12.1, 2025.12, stable, latest, beta, rc
-      #   2025.12.0b3   (beta)      -> tags: 2025.12.0b3, beta, rc
-      #   2025.12.0.dev202511250240 -> tags: 2025.12.0.dev202511250240, dev
-      - name: Generate Docker metadata
-        id: meta
-        uses: docker/metadata-action@c299e40c65443455700f0fdfc63efafe5b349051 # v5.10.0
-        with:
-          images: ${{ matrix.registry }}/home-assistant
-          sep-tags: ","
-          tags: |
-            type=raw,value=${{ needs.init.outputs.version }},priority=9999
-            type=raw,value=dev,enable=${{ contains(needs.init.outputs.version, 'd') }}
-            type=raw,value=beta,enable=${{ !contains(needs.init.outputs.version, 'd') }}
-            type=raw,value=rc,enable=${{ !contains(needs.init.outputs.version, 'd') }}
-            type=raw,value=stable,enable=${{ !contains(needs.init.outputs.version, 'd') && !contains(needs.init.outputs.version, 'b') }}
-            type=raw,value=latest,enable=${{ !contains(needs.init.outputs.version, 'd') && !contains(needs.init.outputs.version, 'b') }}
-            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@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.7.1
-
-      - name: Copy architecture images to DockerHub
-        if: matrix.registry == 'docker.io/homeassistant'
-        shell: bash
-        env:
-          ARCHITECTURES: ${{ needs.init.outputs.architectures }}
-          VERSION: ${{ needs.init.outputs.version }}
-        run: |
-          # Use imagetools to copy image blobs directly between registries
-          # This preserves provenance/attestations and seems to be much faster than pull/push
-          ARCHS=$(echo "${ARCHITECTURES}" | jq -r '.[]')
-          for arch in $ARCHS; do
-            echo "Copying ${arch} image to DockerHub..."
-            for attempt in 1 2 3; do
-              if docker buildx imagetools create \
-                --tag "docker.io/homeassistant/${arch}-homeassistant:${VERSION}" \
-                "ghcr.io/home-assistant/${arch}-homeassistant:${VERSION}"; then
-                break
-              fi
-              echo "Attempt ${attempt} failed, retrying in 10 seconds..."
-              sleep 10
-              if [ "${attempt}" -eq 3 ]; then
-                echo "Failed after 3 attempts"
-                exit 1
-              fi
-            done
-            cosign sign --yes "docker.io/homeassistant/${arch}-homeassistant:${VERSION}"
-          done
-
-      - name: Create and push multi-arch manifests
-        shell: bash
-        env:
-          ARCHITECTURES: ${{ needs.init.outputs.architectures }}
-          REGISTRY: ${{ matrix.registry }}
-          VERSION: ${{ needs.init.outputs.version }}
-          META_TAGS: ${{ steps.meta.outputs.tags }}
-        run: |
-          # Build list of architecture images dynamically
-          ARCHS=$(echo "${ARCHITECTURES}" | jq -r '.[]')
-          ARCH_IMAGES=()
-          for arch in $ARCHS; do
-            ARCH_IMAGES+=("${REGISTRY}/${arch}-homeassistant:${VERSION}")
-          done
-
-          # Build list of all tags for single manifest creation
-          # Note: Using sep-tags=',' in metadata-action for easier parsing
-          TAG_ARGS=()
-          IFS=',' read -ra TAGS <<< "${META_TAGS}"
-          for tag in "${TAGS[@]}"; do
-            TAG_ARGS+=("--tag" "${tag}")
-          done
-
-          # Create manifest with ALL tags in a single operation (much faster!)
-          echo "Creating multi-arch manifest with tags: ${TAGS[*]}"
-          docker buildx imagetools create "${TAG_ARGS[@]}" "${ARCH_IMAGES[@]}"
-
-          # Sign each tag separately (signing requires individual tag names)
-          echo "Signing all tags..."
-          for tag in "${TAGS[@]}"; do
-            echo "Signing ${tag}"
-            cosign sign --yes "${tag}"
-          done
-
-          echo "All manifests created and signed successfully"
-
-  build_python:
-    name: Build PyPi package
-    environment: ${{ needs.init.outputs.channel }}
-    needs: ["init", "build_base"]
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read # To check out the repository
-      id-token: write # For PyPI trusted publishing
-    if: github.repository_owner == 'home-assistant' && needs.init.outputs.publish == 'true'
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-
-      - name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
-        with:
-          python-version: ${{ env.DEFAULT_PYTHON }}
-
-      - name: Download translations
-        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
-        with:
-          name: translations
-
-      - name: Extract translations
-        run: |
-          tar xvf translations.tar.gz
-          rm translations.tar.gz
-
-      - name: Build package
-        shell: bash
-        run: |
-          # Remove dist, build, and homeassistant.egg-info
-          # when build locally for testing!
-          pip install build
-          python -m build
-
-      - name: Upload package to PyPI
-        uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0
-        with:
-          skip-existing: true
-
-  hassfest-image:
-    name: Build and test hassfest image
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read # To check out the repository
-      packages: write # To push to GHCR
-      attestations: write # For build provenance attestation
-      id-token: write # For build provenance attestation
-    needs: ["init"]
-    if: github.repository_owner == 'home-assistant'
-    env:
-      HASSFEST_IMAGE_NAME: ghcr.io/home-assistant/hassfest
-      HASSFEST_IMAGE_TAG: ghcr.io/home-assistant/hassfest:${{ needs.init.outputs.version }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-        with:
-          persist-credentials: false
-
-      - name: Login to GitHub Container Registry
-        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@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6.19.2
-        with:
-          context: . # So action will not pull the repository again
-          file: ./script/hassfest/docker/Dockerfile
-          load: true
-          tags: ${{ env.HASSFEST_IMAGE_TAG }}
-
-      - name: Run hassfest against core
-        run: docker run --rm -v "${GITHUB_WORKSPACE}":/github/workspace "${HASSFEST_IMAGE_TAG}" --core-path=/github/workspace
-
-      - name: Push Docker image
-        if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
-        id: push
-        uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6.19.2
-        with:
-          context: . # So action will not pull the repository again
-          file: ./script/hassfest/docker/Dockerfile
-          push: true
-          tags: ${{ env.HASSFEST_IMAGE_TAG }},${{ env.HASSFEST_IMAGE_NAME }}:latest
-
-      - name: Generate artifact attestation
-        if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
-        uses: actions/attest-build-provenance@96278af6caaf10aea03fd8d33a09a777ca52d62f # v3.2.0
-        with:
-          subject-name: ${{ env.HASSFEST_IMAGE_NAME }}
-          subject-digest: ${{ steps.push.outputs.digest }}
-          push-to-registry: true
+#  publish_ha:
+#    name: Publish version files
+#    environment: ${{ needs.init.outputs.channel }}
+#    if: github.repository_owner == 'home-assistant'
+#    needs: ["init", "build_machine"]
+#    runs-on: ubuntu-latest
+#    permissions:
+#      contents: read
+#    steps:
+#      - name: Checkout the repository
+#        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+#        with:
+#          persist-credentials: false
+#
+#      - name: Initialize git
+#        uses: home-assistant/actions/helpers/git-init@master # zizmor: ignore[unpinned-uses]
+#        with:
+#          name: ${{ secrets.GIT_NAME }}
+#          email: ${{ secrets.GIT_EMAIL }}
+#          token: ${{ secrets.GIT_TOKEN }}
+#
+#      - name: Update version file
+#        uses: home-assistant/actions/helpers/version-push@master # zizmor: ignore[unpinned-uses]
+#        with:
+#          key: "homeassistant[]"
+#          key-description: "Home Assistant Core"
+#          version: ${{ needs.init.outputs.version }}
+#          channel: ${{ needs.init.outputs.channel }}
+#          exclude-list: '["odroid-xu","qemuarm","qemux86","raspberrypi","raspberrypi2","raspberrypi3","raspberrypi4","tinker"]'
+#
+#      - name: Update version file (stable -> beta)
+#        if: needs.init.outputs.channel == 'stable'
+#        uses: home-assistant/actions/helpers/version-push@master # zizmor: ignore[unpinned-uses]
+#        with:
+#          key: "homeassistant[]"
+#          key-description: "Home Assistant Core"
+#          version: ${{ needs.init.outputs.version }}
+#          channel: beta
+#          exclude-list: '["odroid-xu","qemuarm","qemux86","raspberrypi","raspberrypi2","raspberrypi3","raspberrypi4","tinker"]'
+#
+#  publish_container:
+#    name: Publish meta container for ${{ matrix.registry }}
+#    environment: ${{ needs.init.outputs.channel }}
+#    if: github.repository_owner == 'home-assistant'
+#    needs: ["init", "build_base"]
+#    runs-on: ubuntu-latest
+#    permissions:
+#      contents: read # To check out the repository
+#      packages: write # To push to GHCR
+#      id-token: write # For cosign signing
+#    strategy:
+#      fail-fast: false
+#      matrix:
+#        registry: ["ghcr.io/home-assistant", "docker.io/homeassistant"]
+#    steps:
+#      - name: Install Cosign
+#        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@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
+#        with:
+#          username: ${{ secrets.DOCKERHUB_USERNAME }}
+#          password: ${{ secrets.DOCKERHUB_TOKEN }}
+#
+#      - name: Login to GitHub Container Registry
+#        uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
+#        with:
+#          registry: ghcr.io
+#          username: ${{ github.repository_owner }}
+#          password: ${{ secrets.GITHUB_TOKEN }}
+#
+#      - name: Verify architecture image signatures
+#        shell: bash
+#        env:
+#          ARCHITECTURES: ${{ needs.init.outputs.architectures }}
+#          VERSION: ${{ needs.init.outputs.version }}
+#        run: |
+#          ARCHS=$(echo "${ARCHITECTURES}" | jq -r '.[]')
+#          for arch in $ARCHS; do
+#            echo "Verifying ${arch} image signature..."
+#            cosign verify \
+#              --certificate-oidc-issuer https://token.actions.githubusercontent.com \
+#              --certificate-identity-regexp https://github.com/home-assistant/core/.* \
+#              "ghcr.io/home-assistant/${arch}-homeassistant:${VERSION}"
+#          done
+#          echo "✓ All images verified successfully"
+#
+#      # Generate all Docker tags based on version string
+#      # Version format: YYYY.MM.PATCH, YYYY.MM.PATCHbN (beta), or YYYY.MM.PATCH.devYYYYMMDDHHMM (dev)
+#      # Examples:
+#      #   2025.12.1     (stable)    -> tags: 2025.12.1, 2025.12, stable, latest, beta, rc
+#      #   2025.12.0b3   (beta)      -> tags: 2025.12.0b3, beta, rc
+#      #   2025.12.0.dev202511250240 -> tags: 2025.12.0.dev202511250240, dev
+#      - name: Generate Docker metadata
+#        id: meta
+#        uses: docker/metadata-action@c299e40c65443455700f0fdfc63efafe5b349051 # v5.10.0
+#        with:
+#          images: ${{ matrix.registry }}/home-assistant
+#          sep-tags: ","
+#          tags: |
+#            type=raw,value=${{ needs.init.outputs.version }},priority=9999
+#            type=raw,value=dev,enable=${{ contains(needs.init.outputs.version, 'd') }}
+#            type=raw,value=beta,enable=${{ !contains(needs.init.outputs.version, 'd') }}
+#            type=raw,value=rc,enable=${{ !contains(needs.init.outputs.version, 'd') }}
+#            type=raw,value=stable,enable=${{ !contains(needs.init.outputs.version, 'd') && !contains(needs.init.outputs.version, 'b') }}
+#            type=raw,value=latest,enable=${{ !contains(needs.init.outputs.version, 'd') && !contains(needs.init.outputs.version, 'b') }}
+#            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@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.7.1
+#
+#      - name: Copy architecture images to DockerHub
+#        if: matrix.registry == 'docker.io/homeassistant'
+#        shell: bash
+#        env:
+#          ARCHITECTURES: ${{ needs.init.outputs.architectures }}
+#          VERSION: ${{ needs.init.outputs.version }}
+#        run: |
+#          # Use imagetools to copy image blobs directly between registries
+#          # This preserves provenance/attestations and seems to be much faster than pull/push
+#          ARCHS=$(echo "${ARCHITECTURES}" | jq -r '.[]')
+#          for arch in $ARCHS; do
+#            echo "Copying ${arch} image to DockerHub..."
+#            for attempt in 1 2 3; do
+#              if docker buildx imagetools create \
+#                --tag "docker.io/homeassistant/${arch}-homeassistant:${VERSION}" \
+#                "ghcr.io/home-assistant/${arch}-homeassistant:${VERSION}"; then
+#                break
+#              fi
+#              echo "Attempt ${attempt} failed, retrying in 10 seconds..."
+#              sleep 10
+#              if [ "${attempt}" -eq 3 ]; then
+#                echo "Failed after 3 attempts"
+#                exit 1
+#              fi
+#            done
+#            cosign sign --yes "docker.io/homeassistant/${arch}-homeassistant:${VERSION}"
+#          done
+#
+#      - name: Create and push multi-arch manifests
+#        shell: bash
+#        env:
+#          ARCHITECTURES: ${{ needs.init.outputs.architectures }}
+#          REGISTRY: ${{ matrix.registry }}
+#          VERSION: ${{ needs.init.outputs.version }}
+#          META_TAGS: ${{ steps.meta.outputs.tags }}
+#        run: |
+#          # Build list of architecture images dynamically
+#          ARCHS=$(echo "${ARCHITECTURES}" | jq -r '.[]')
+#          ARCH_IMAGES=()
+#          for arch in $ARCHS; do
+#            ARCH_IMAGES+=("${REGISTRY}/${arch}-homeassistant:${VERSION}")
+#          done
+#
+#          # Build list of all tags for single manifest creation
+#          # Note: Using sep-tags=',' in metadata-action for easier parsing
+#          TAG_ARGS=()
+#          IFS=',' read -ra TAGS <<< "${META_TAGS}"
+#          for tag in "${TAGS[@]}"; do
+#            TAG_ARGS+=("--tag" "${tag}")
+#          done
+#
+#          # Create manifest with ALL tags in a single operation (much faster!)
+#          echo "Creating multi-arch manifest with tags: ${TAGS[*]}"
+#          docker buildx imagetools create "${TAG_ARGS[@]}" "${ARCH_IMAGES[@]}"
+#
+#          # Sign each tag separately (signing requires individual tag names)
+#          echo "Signing all tags..."
+#          for tag in "${TAGS[@]}"; do
+#            echo "Signing ${tag}"
+#            cosign sign --yes "${tag}"
+#          done
+#
+#          echo "All manifests created and signed successfully"
+#
+#  build_python:
+#    name: Build PyPi package
+#    environment: ${{ needs.init.outputs.channel }}
+#    needs: ["init", "build_base"]
+#    runs-on: ubuntu-latest
+#    permissions:
+#      contents: read # To check out the repository
+#      id-token: write # For PyPI trusted publishing
+#    if: github.repository_owner == 'home-assistant' && needs.init.outputs.publish == 'true'
+#    steps:
+#      - name: Checkout the repository
+#        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+#        with:
+#          persist-credentials: false
+#
+#      - name: Set up Python ${{ env.DEFAULT_PYTHON }}
+#        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+#        with:
+#          python-version: ${{ env.DEFAULT_PYTHON }}
+#
+#      - name: Download translations
+#        uses: actions/download-artifact@37930b1c2abaa49bbe596cd826c3c89aef350131 # v7.0.0
+#        with:
+#          name: translations
+#
+#      - name: Extract translations
+#        run: |
+#          tar xvf translations.tar.gz
+#          rm translations.tar.gz
+#
+#      - name: Build package
+#        shell: bash
+#        run: |
+#          # Remove dist, build, and homeassistant.egg-info
+#          # when build locally for testing!
+#          pip install build
+#          python -m build
+#
+#      - name: Upload package to PyPI
+#        uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0
+#        with:
+#          skip-existing: true
+#
+#  hassfest-image:
+#    name: Build and test hassfest image
+#    runs-on: ubuntu-latest
+#    permissions:
+#      contents: read # To check out the repository
+#      packages: write # To push to GHCR
+#      attestations: write # For build provenance attestation
+#      id-token: write # For build provenance attestation
+#    needs: ["init"]
+#    if: github.repository_owner == 'home-assistant'
+#    env:
+#      HASSFEST_IMAGE_NAME: ghcr.io/home-assistant/hassfest
+#      HASSFEST_IMAGE_TAG: ghcr.io/home-assistant/hassfest:${{ needs.init.outputs.version }}
+#    steps:
+#      - name: Checkout repository
+#        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+#        with:
+#          persist-credentials: false
+#
+#      - name: Login to GitHub Container Registry
+#        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@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6.19.2
+#        with:
+#          context: . # So action will not pull the repository again
+#          file: ./script/hassfest/docker/Dockerfile
+#          load: true
+#          tags: ${{ env.HASSFEST_IMAGE_TAG }}
+#
+#      - name: Run hassfest against core
+#        run: docker run --rm -v "${GITHUB_WORKSPACE}":/github/workspace "${HASSFEST_IMAGE_TAG}" --core-path=/github/workspace
+#
+#      - name: Push Docker image
+#        if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
+#        id: push
+#        uses: docker/build-push-action@10e90e3645eae34f1e60eeb005ba3a3d33f178e8 # v6.19.2
+#        with:
+#          context: . # So action will not pull the repository again
+#          file: ./script/hassfest/docker/Dockerfile
+#          push: true
+#          tags: ${{ env.HASSFEST_IMAGE_TAG }},${{ env.HASSFEST_IMAGE_NAME }}:latest
+#
+#      - name: Generate artifact attestation
+#        if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
+#        uses: actions/attest-build-provenance@96278af6caaf10aea03fd8d33a09a777ca52d62f # v3.2.0
+#        with:
+#          subject-name: ${{ env.HASSFEST_IMAGE_NAME }}
+#          subject-digest: ${{ steps.push.outputs.digest }}
+#          push-to-registry: true

CODEOWNERS

@@ -555,8 +555,6 @@ build.json @home-assistant/supervisor
 /tests/components/fritz/ @AaronDavidSchneider @chemelli74 @mib1185
 /homeassistant/components/fritzbox/ @mib1185 @flabbamann
 /tests/components/fritzbox/ @mib1185 @flabbamann
-/homeassistant/components/fritzbox_callmonitor/ @cdce8p
-/tests/components/fritzbox_callmonitor/ @cdce8p
 /homeassistant/components/fronius/ @farmio
 /tests/components/fronius/ @farmio
 /homeassistant/components/frontend/ @home-assistant/frontend

homeassistant/components/airos/config_flow.py

@@ -34,11 +34,13 @@ from homeassistant.const import (
 )
 from homeassistant.data_entry_flow import section
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.device_registry import format_mac
 from homeassistant.helpers.selector import (
     TextSelector,
     TextSelectorConfig,
     TextSelectorType,
 )
+from homeassistant.helpers.service_info.dhcp import DhcpServiceInfo
 
 from .const import (
     DEFAULT_SSL,
@@ -392,6 +394,18 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
         except asyncio.CancelledError:
             pass
 
+    async def async_step_dhcp(
+        self, discovery_info: DhcpServiceInfo
+    ) -> ConfigFlowResult:
+        """Automatically handle a DHCP discovered IP change."""
+        ip_address = discovery_info.ip
+        # python-airos defaults to upper for derived mac_address
+        normalized_mac = format_mac(discovery_info.macaddress).upper()
+        await self.async_set_unique_id(normalized_mac)
+
+        self._abort_if_unique_id_configured(updates={CONF_HOST: ip_address})
+        return self.async_abort(reason="unreachable")
+
     async def async_step_discovery_no_devices(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:

homeassistant/components/airos/manifest.json

@@ -3,6 +3,7 @@
   "name": "Ubiquiti airOS",
   "codeowners": ["@CoMPaTech"],
   "config_flow": true,
+  "dhcp": [{ "registered_devices": true }],
   "documentation": "https://www.home-assistant.io/integrations/airos",
   "integration_type": "device",
   "iot_class": "local_polling",

homeassistant/components/aladdin_connect/__init__.py

@@ -2,10 +2,12 @@
 
 from __future__ import annotations
 
+import aiohttp
 from genie_partner_sdk.client import AladdinConnectClient
 
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import (
     aiohttp_client,
     config_entry_oauth2_flow,
@@ -31,11 +33,27 @@ async def async_setup_entry(
 
     session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation)
 
+    try:
+        await session.async_ensure_token_valid()
+    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
+
     client = AladdinConnectClient(
         api.AsyncConfigEntryAuth(aiohttp_client.async_get_clientsession(hass), session)
     )
 
-    doors = await client.get_doors()
+    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 = {
         door.unique_id: AladdinConnectCoordinator(hass, entry, client, door)

homeassistant/components/aladdin_connect/api.py

@@ -11,6 +11,18 @@ API_URL = "https://twdvzuefzh.execute-api.us-east-2.amazonaws.com/v1"
 API_KEY = "k6QaiQmcTm2zfaNns5L1Z8duBtJmhDOW8JawlCC3"
 
 
+class AsyncConfigFlowAuth(Auth):
+    """Provide Aladdin Connect Genie authentication for config flow validation."""
+
+    def __init__(self, websession: ClientSession, access_token: str) -> None:
+        """Initialize Aladdin Connect Genie auth."""
+        super().__init__(websession, API_URL, access_token, API_KEY)
+
+    async def async_get_access_token(self) -> str:
+        """Return the access token."""
+        return self.access_token
+
+
 class AsyncConfigEntryAuth(Auth):
     """Provide Aladdin Connect Genie authentication tied to an OAuth2 based config entry."""
 

homeassistant/components/aladdin_connect/config_flow.py

@@ -4,12 +4,14 @@ from collections.abc import Mapping
 import logging
 from typing import Any
 
+from genie_partner_sdk.client import AladdinConnectClient
 import jwt
 import voluptuous as vol
 
 from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlowResult
-from homeassistant.helpers import config_entry_oauth2_flow
+from homeassistant.helpers import aiohttp_client, config_entry_oauth2_flow
 
+from .api import AsyncConfigFlowAuth
 from .const import CONFIG_FLOW_MINOR_VERSION, CONFIG_FLOW_VERSION, DOMAIN
 
 
@@ -52,11 +54,25 @@ class OAuth2FlowHandler(
 
     async def async_oauth_create_entry(self, data: dict) -> ConfigFlowResult:
         """Create an oauth config entry or update existing entry for reauth."""
-        # Extract the user ID from the JWT token's 'sub' field
-        token = jwt.decode(
-            data["token"]["access_token"], options={"verify_signature": False}
+        try:
+            token = jwt.decode(
+                data["token"]["access_token"], options={"verify_signature": False}
+            )
+            user_id = token["sub"]
+        except jwt.DecodeError, KeyError:
+            return self.async_abort(reason="oauth_error")
+
+        client = AladdinConnectClient(
+            AsyncConfigFlowAuth(
+                aiohttp_client.async_get_clientsession(self.hass),
+                data["token"]["access_token"],
+            )
         )
-        user_id = token["sub"]
+        try:
+            await client.get_doors()
+        except Exception:  # noqa: BLE001
+            return self.async_abort(reason="cannot_connect")
+
         await self.async_set_unique_id(user_id)
 
         if self.source == SOURCE_REAUTH:

homeassistant/components/aladdin_connect/quality_scale.yaml

@@ -7,39 +7,31 @@ rules:
   brands: done
   common-modules: done
   config-flow: done
-  config-flow-test-coverage: todo
+  config-flow-test-coverage: done
   dependency-transparency: done
   docs-actions:
     status: exempt
     comment: Integration does not register any service actions.
   docs-high-level-description: done
-  docs-installation-instructions:
-    status: todo
-    comment: Documentation needs to be created.
-  docs-removal-instructions:
-    status: todo
-    comment: Documentation needs to be created.
+  docs-installation-instructions: done
+  docs-removal-instructions: done
   entity-event-setup:
     status: exempt
     comment: Integration does not subscribe to external events.
   entity-unique-id: done
   has-entity-name: done
   runtime-data: done
-  test-before-configure:
-    status: todo
-    comment: Config flow does not currently test connection during setup.
-  test-before-setup: todo
+  test-before-configure: done
+  test-before-setup: done
   unique-config-entry: done
 
   # Silver
   action-exceptions: todo
   config-entry-unloading: done
   docs-configuration-parameters:
-    status: todo
-    comment: Documentation needs to be created.
-  docs-installation-parameters:
-    status: todo
-    comment: Documentation needs to be created.
+    status: exempt
+    comment: Integration does not have an options flow.
+  docs-installation-parameters: done
   entity-unavailable: todo
   integration-owner: done
   log-when-unavailable: todo
@@ -52,29 +44,17 @@ rules:
   # Gold
   devices: done
   diagnostics: todo
-  discovery: todo
-  discovery-update-info: todo
-  docs-data-update:
-    status: todo
-    comment: Documentation needs to be created.
-  docs-examples:
-    status: todo
-    comment: Documentation needs to be created.
-  docs-known-limitations:
-    status: todo
-    comment: Documentation needs to be created.
-  docs-supported-devices:
-    status: todo
-    comment: Documentation needs to be created.
-  docs-supported-functions:
-    status: todo
-    comment: Documentation needs to be created.
-  docs-troubleshooting:
-    status: todo
-    comment: Documentation needs to be created.
-  docs-use-cases:
-    status: todo
-    comment: Documentation needs to be created.
+  discovery: done
+  discovery-update-info:
+    status: exempt
+    comment: Integration connects via the cloud and not locally.
+  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: todo
   entity-category: done
   entity-device-class: done
@@ -86,7 +66,7 @@ rules:
   repair-issues: todo
   stale-devices:
     status: todo
-    comment: Stale devices can be done dynamically
+    comment: We can automatically remove removed devices
 
   # Platinum
   async-dependency: todo

homeassistant/components/aladdin_connect/strings.json

@@ -4,6 +4,7 @@
       "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
       "already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
       "authorize_url_timeout": "[%key:common::config_flow::abort::oauth2_authorize_url_timeout%]",
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "cloud_not_enabled": "Please make sure you run Home Assistant with `{default_config}` enabled in your configuration.yaml.",
       "missing_configuration": "[%key:common::config_flow::abort::oauth2_missing_configuration%]",
       "no_url_available": "[%key:common::config_flow::abort::oauth2_no_url_available%]",

homeassistant/components/anthropic/config_flow.py

@@ -112,19 +112,12 @@ async def get_model_list(client: anthropic.AsyncAnthropic) -> list[SelectOptionD
         # Resolve alias from versioned model name:
         model_alias = (
             model_info.id[:-9]
-            if model_info.id
-            not in (
-                "claude-3-haiku-20240307",
-                "claude-3-5-haiku-20241022",
-                "claude-3-opus-20240229",
-            )
+            if model_info.id != "claude-3-haiku-20240307"
             and model_info.id[-2:-1] != "-"
             else model_info.id
         )
         if short_form.search(model_alias):
             model_alias += "-0"
-        if model_alias.endswith(("haiku", "opus", "sonnet")):
-            model_alias += "-latest"
         model_options.append(
             SelectOptionDict(
                 label=model_info.display_name,

homeassistant/components/anthropic/const.py

@@ -37,8 +37,6 @@ DEFAULT = {
 MIN_THINKING_BUDGET = 1024
 
 NON_THINKING_MODELS = [
-    "claude-3-5",  # Both sonnet and haiku
-    "claude-3-opus",
     "claude-3-haiku",
 ]
 
@@ -51,7 +49,7 @@ NON_ADAPTIVE_THINKING_MODELS = [
     "claude-opus-4-20250514",
     "claude-sonnet-4-0",
     "claude-sonnet-4-20250514",
-    "claude-3",
+    "claude-3-haiku",
 ]
 
 UNSUPPORTED_STRUCTURED_OUTPUT_MODELS = [
@@ -60,19 +58,13 @@ UNSUPPORTED_STRUCTURED_OUTPUT_MODELS = [
     "claude-opus-4-20250514",
     "claude-sonnet-4-0",
     "claude-sonnet-4-20250514",
-    "claude-3",
+    "claude-3-haiku",
 ]
 
 WEB_SEARCH_UNSUPPORTED_MODELS = [
     "claude-3-haiku",
-    "claude-3-opus",
-    "claude-3-5-sonnet-20240620",
-    "claude-3-5-sonnet-20241022",
 ]
 
 DEPRECATED_MODELS = [
-    "claude-3-5-haiku",
-    "claude-3-7-sonnet",
-    "claude-3-5-sonnet",
-    "claude-3-opus",
+    "claude-3",
 ]

homeassistant/components/anthropic/manifest.json

@@ -8,5 +8,5 @@
   "documentation": "https://www.home-assistant.io/integrations/anthropic",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["anthropic==0.78.0"]
+  "requirements": ["anthropic==0.83.0"]
 }

homeassistant/components/anthropic/repairs.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from collections.abc import Iterator
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING
 
 import voluptuous as vol
 
@@ -19,7 +19,7 @@ from homeassistant.helpers.selector import (
 )
 
 from .config_flow import get_model_list
-from .const import CONF_CHAT_MODEL, DEFAULT, DEPRECATED_MODELS, DOMAIN
+from .const import CONF_CHAT_MODEL, DEPRECATED_MODELS, DOMAIN
 
 if TYPE_CHECKING:
     from . import AnthropicConfigEntry
@@ -67,13 +67,23 @@ class ModelDeprecatedRepairFlow(RepairsFlow):
             self._model_list_cache[entry.entry_id] = model_list
 
         if "opus" in model:
-            suggested_model = "claude-opus-4-5"
-        elif "haiku" in model:
-            suggested_model = "claude-haiku-4-5"
+            family = "claude-opus"
         elif "sonnet" in model:
-            suggested_model = "claude-sonnet-4-5"
+            family = "claude-sonnet"
         else:
-            suggested_model = cast(str, DEFAULT[CONF_CHAT_MODEL])
+            family = "claude-haiku"
+
+        suggested_model = next(
+            (
+                model_option["value"]
+                for model_option in sorted(
+                    (m for m in model_list if family in m["value"]),
+                    key=lambda x: x["value"],
+                    reverse=True,
+                )
+            ),
+            vol.UNDEFINED,
+        )
 
         schema = vol.Schema(
             {

homeassistant/components/backup/util.py

@@ -16,6 +16,7 @@ from typing import IO, Any, cast
 
 import aiohttp
 from securetar import (
+    InvalidPasswordError,
     SecureTarArchive,
     SecureTarError,
     SecureTarFile,
@@ -165,7 +166,7 @@ def validate_password(path: Path, password: str | None) -> bool:
             ):
                 # If we can read the tar file, the password is correct
                 return True
-        except tarfile.ReadError, SecureTarReadError:
+        except tarfile.ReadError, InvalidPasswordError, SecureTarReadError:
             LOGGER.debug("Invalid password")
             return False
         except Exception:  # noqa: BLE001
@@ -192,13 +193,14 @@ def validate_password_stream(
         for obj in input_archive.tar:
             if not obj.name.endswith((".tar", ".tgz", ".tar.gz")):
                 continue
-            with input_archive.extract_tar(obj) as decrypted:
-                if decrypted.plaintext_size is None:
-                    raise UnsupportedSecureTarVersion
-                try:
+            try:
+                with input_archive.extract_tar(obj) as decrypted:
+                    if decrypted.plaintext_size is None:
+                        raise UnsupportedSecureTarVersion
                     decrypted.read(1)  # Read a single byte to trigger the decryption
-                except SecureTarReadError as err:
-                    raise IncorrectPassword from err
+            except (InvalidPasswordError, SecureTarReadError) as err:
+                raise IncorrectPassword from err
+            else:
                 return
     raise BackupEmpty
 

homeassistant/components/bsblan/coordinator.py

@@ -29,8 +29,13 @@ if TYPE_CHECKING:
 
 # Filter lists for optimized API calls - only fetch parameters we actually use
 # This significantly reduces response time (~0.2s per parameter saved)
-STATE_INCLUDE = ["current_temperature", "target_temperature", "hvac_mode"]
-SENSOR_INCLUDE = ["current_temperature", "outside_temperature"]
+STATE_INCLUDE = [
+    "current_temperature",
+    "target_temperature",
+    "hvac_mode",
+    "hvac_action",
+]
+SENSOR_INCLUDE = ["current_temperature", "outside_temperature", "total_energy"]
 DHW_STATE_INCLUDE = [
     "operating_mode",
     "nominal_setpoint",

homeassistant/components/bsblan/sensor.py

@@ -11,7 +11,7 @@ from homeassistant.components.sensor import (
     SensorEntityDescription,
     SensorStateClass,
 )
-from homeassistant.const import UnitOfTemperature
+from homeassistant.const import UnitOfEnergy, UnitOfTemperature
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
@@ -58,6 +58,19 @@ SENSOR_TYPES: tuple[BSBLanSensorEntityDescription, ...] = (
         ),
         exists_fn=lambda data: data.sensor.outside_temperature is not None,
     ),
+    BSBLanSensorEntityDescription(
+        key="total_energy",
+        translation_key="total_energy",
+        device_class=SensorDeviceClass.ENERGY,
+        native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        value_fn=lambda data: (
+            data.sensor.total_energy.value
+            if data.sensor.total_energy is not None
+            else None
+        ),
+        exists_fn=lambda data: data.sensor.total_energy is not None,
+    ),
 )
 
 

homeassistant/components/bsblan/strings.json

@@ -66,6 +66,9 @@
       },
       "outside_temperature": {
         "name": "Outside temperature"
+      },
+      "total_energy": {
+        "name": "Total energy"
       }
     }
   },

homeassistant/components/ecovacs/vacuum.py

@@ -8,17 +8,24 @@ from typing import TYPE_CHECKING, Any
 
 from deebot_client.capabilities import Capabilities, DeviceType
 from deebot_client.device import Device
-from deebot_client.events import FanSpeedEvent, RoomsEvent, StateEvent
-from deebot_client.models import CleanAction, CleanMode, Room, State
+from deebot_client.events import (
+    CachedMapInfoEvent,
+    FanSpeedEvent,
+    RoomsEvent,
+    StateEvent,
+)
+from deebot_client.events.map import Map
+from deebot_client.models import CleanAction, CleanMode, State
 import sucks
 
 from homeassistant.components.vacuum import (
+    Segment,
     StateVacuumEntity,
     StateVacuumEntityDescription,
     VacuumActivity,
     VacuumEntityFeature,
 )
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import slugify
@@ -29,6 +36,7 @@ from .entity import EcovacsEntity, EcovacsLegacyEntity
 from .util import get_name_key
 
 _LOGGER = logging.getLogger(__name__)
+_SEGMENTS_SEPARATOR = "_"
 
 ATTR_ERROR = "error"
 
@@ -218,7 +226,8 @@ class EcovacsVacuum(
         """Initialize the vacuum."""
         super().__init__(device, device.capabilities)
 
-        self._rooms: list[Room] = []
+        self._room_event: RoomsEvent | None = None
+        self._maps: dict[str, Map] = {}
 
         if fan_speed := self._capability.fan_speed:
             self._attr_supported_features |= VacuumEntityFeature.FAN_SPEED
@@ -226,14 +235,13 @@ class EcovacsVacuum(
                 get_name_key(level) for level in fan_speed.types
             ]
 
+        if self._capability.map and self._capability.clean.action.area:
+            self._attr_supported_features |= VacuumEntityFeature.CLEAN_AREA
+
     async def async_added_to_hass(self) -> None:
         """Set up the event listeners now that hass is ready."""
         await super().async_added_to_hass()
 
-        async def on_rooms(event: RoomsEvent) -> None:
-            self._rooms = event.rooms
-            self.async_write_ha_state()
-
         async def on_status(event: StateEvent) -> None:
             self._attr_activity = _STATE_TO_VACUUM_STATE[event.state]
             self.async_write_ha_state()
@@ -249,8 +257,20 @@ class EcovacsVacuum(
             self._subscribe(self._capability.fan_speed.event, on_fan_speed)
 
         if map_caps := self._capability.map:
+
+            async def on_rooms(event: RoomsEvent) -> None:
+                self._room_event = event
+                self._check_segments_changed()
+                self.async_write_ha_state()
+
             self._subscribe(map_caps.rooms.event, on_rooms)
 
+            async def on_map_info(event: CachedMapInfoEvent) -> None:
+                self._maps = {map_obj.id: map_obj for map_obj in event.maps}
+                self._check_segments_changed()
+
+            self._subscribe(map_caps.cached_info.event, on_map_info)
+
     @property
     def extra_state_attributes(self) -> Mapping[str, Any] | None:
         """Return entity specific state attributes.
@@ -259,7 +279,10 @@ class EcovacsVacuum(
         is lowercase snake_case.
         """
         rooms: dict[str, Any] = {}
-        for room in self._rooms:
+        if self._room_event is None:
+            return rooms
+
+        for room in self._room_event.rooms:
             # convert room name to snake_case to meet the convention
             room_name = slugify(room.name)
             room_values = rooms.get(room_name)
@@ -374,3 +397,116 @@ class EcovacsVacuum(
             )
 
         return await self._device.execute_command(position_commands[0])
+
+    @callback
+    def _check_segments_changed(self) -> None:
+        """Check if segments have changed and create repair issue."""
+        last_seen = self.last_seen_segments
+        if last_seen is None:
+            return
+
+        last_seen_ids = {seg.id for seg in last_seen}
+        current_ids = {seg.id for seg in self._get_segments()}
+
+        if current_ids != last_seen_ids:
+            self.async_create_segments_issue()
+
+    def _get_segments(self) -> list[Segment]:
+        """Get the segments that can be cleaned."""
+        last_seen = self.last_seen_segments or []
+        if self._room_event is None or not self._maps:
+            # If we don't have the necessary information to determine segments, return the last
+            # seen segments to avoid temporarily losing all segments until we get the necessary
+            # information, which could cause unnecessary issues to be created
+            return last_seen
+
+        map_id = self._room_event.map_id
+        if (map_obj := self._maps.get(map_id)) is None:
+            _LOGGER.warning("Map ID %s not found in available maps", map_id)
+            return []
+
+        id_prefix = f"{map_id}{_SEGMENTS_SEPARATOR}"
+        other_map_ids = {
+            map_obj.id
+            for map_obj in self._maps.values()
+            if map_obj.id != self._room_event.map_id
+        }
+        # Include segments from the current map and any segments from other maps that were
+        # previously seen, as we want to continue showing segments from other maps for
+        # mapping purposes
+        segments = [
+            seg for seg in last_seen if _split_composite_id(seg.id)[0] in other_map_ids
+        ]
+        segments.extend(
+            Segment(
+                id=f"{id_prefix}{room.id}",
+                name=room.name,
+                group=map_obj.name,
+            )
+            for room in self._room_event.rooms
+        )
+        return segments
+
+    async def async_get_segments(self) -> list[Segment]:
+        """Get the segments that can be cleaned."""
+        return self._get_segments()
+
+    async def async_clean_segments(self, segment_ids: list[str], **kwargs: Any) -> None:
+        """Perform an area clean.
+
+        Only cleans segments from the currently selected map.
+        """
+        if not self._maps:
+            _LOGGER.warning("No map information available, cannot clean segments")
+            return
+
+        valid_room_ids: list[int | float] = []
+        for composite_id in segment_ids:
+            map_id, segment_id = _split_composite_id(composite_id)
+            if (map_obj := self._maps.get(map_id)) is None:
+                _LOGGER.warning("Map ID %s not found in available maps", map_id)
+                continue
+
+            if not map_obj.using:
+                room_name = next(
+                    (
+                        segment.name
+                        for segment in self.last_seen_segments or []
+                        if segment.id == composite_id
+                    ),
+                    "",
+                )
+                _LOGGER.warning(
+                    'Map "%s" is not currently selected, skipping segment "%s" (%s)',
+                    map_obj.name,
+                    room_name,
+                    segment_id,
+                )
+                continue
+
+            valid_room_ids.append(int(segment_id))
+
+        if not valid_room_ids:
+            _LOGGER.warning(
+                "No valid segments to clean after validation, skipping clean segments command"
+            )
+            return
+
+        if TYPE_CHECKING:
+            # Supported feature is only added if clean.action.area is not None
+            assert self._capability.clean.action.area is not None
+
+        await self._device.execute_command(
+            self._capability.clean.action.area(
+                CleanMode.SPOT_AREA,
+                valid_room_ids,
+                1,
+            )
+        )
+
+
+@callback
+def _split_composite_id(composite_id: str) -> tuple[str, str]:
+    """Split a composite ID into its components."""
+    map_id, _, segment_id = composite_id.partition(_SEGMENTS_SEPARATOR)
+    return map_id, segment_id

homeassistant/components/enocean/config_flow.py

@@ -4,17 +4,23 @@ from typing import Any
 
 import voluptuous as vol
 
+from homeassistant.components import usb
+from homeassistant.components.usb import (
+    human_readable_device_name,
+    usb_unique_id_from_service_info,
+)
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_DEVICE
+from homeassistant.const import ATTR_MANUFACTURER, CONF_DEVICE, CONF_NAME
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.selector import (
     SelectSelector,
     SelectSelectorConfig,
     SelectSelectorMode,
 )
+from homeassistant.helpers.service_info.usb import UsbServiceInfo
 
 from . import dongle
-from .const import DOMAIN, ERROR_INVALID_DONGLE_PATH, LOGGER
+from .const import DOMAIN, ERROR_INVALID_DONGLE_PATH, LOGGER, MANUFACTURER
 
 MANUAL_SCHEMA = vol.Schema(
     {
@@ -31,8 +37,48 @@ class EnOceanFlowHandler(ConfigFlow, domain=DOMAIN):
 
     def __init__(self) -> None:
         """Initialize the EnOcean config flow."""
-        self.dongle_path = None
-        self.discovery_info = None
+        self.data: dict[str, Any] = {}
+
+    async def async_step_usb(self, discovery_info: UsbServiceInfo) -> ConfigFlowResult:
+        """Handle usb discovery."""
+        unique_id = usb_unique_id_from_service_info(discovery_info)
+
+        await self.async_set_unique_id(unique_id)
+        self._abort_if_unique_id_configured(
+            updates={CONF_DEVICE: discovery_info.device}
+        )
+
+        discovery_info.device = await self.hass.async_add_executor_job(
+            usb.get_serial_by_id, discovery_info.device
+        )
+
+        self.data[CONF_DEVICE] = discovery_info.device
+        self.context["title_placeholders"] = {
+            CONF_NAME: human_readable_device_name(
+                discovery_info.device,
+                discovery_info.serial_number,
+                discovery_info.manufacturer,
+                discovery_info.description,
+                discovery_info.vid,
+                discovery_info.pid,
+            )
+        }
+        return await self.async_step_usb_confirm()
+
+    async def async_step_usb_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle USB Discovery confirmation."""
+        if user_input is not None:
+            return await self.async_step_manual({CONF_DEVICE: self.data[CONF_DEVICE]})
+        self._set_confirm_only()
+        return self.async_show_form(
+            step_id="usb_confirm",
+            description_placeholders={
+                ATTR_MANUFACTURER: MANUFACTURER,
+                CONF_DEVICE: self.data.get(CONF_DEVICE, ""),
+            },
+        )
 
     async def async_step_import(self, import_data: dict[str, Any]) -> ConfigFlowResult:
         """Import a yaml configuration."""
@@ -104,4 +150,4 @@ class EnOceanFlowHandler(ConfigFlow, domain=DOMAIN):
 
     def create_enocean_entry(self, user_input):
         """Create an entry for the provided configuration."""
-        return self.async_create_entry(title="EnOcean", data=user_input)
+        return self.async_create_entry(title=MANUFACTURER, data=user_input)

homeassistant/components/enocean/const.py

@@ -6,6 +6,8 @@ from homeassistant.const import Platform
 
 DOMAIN = "enocean"
 
+MANUFACTURER = "EnOcean"
+
 ERROR_INVALID_DONGLE_PATH = "invalid_dongle_path"
 
 SIGNAL_RECEIVE_MESSAGE = "enocean.receive_message"

homeassistant/components/enocean/manifest.json

@@ -3,10 +3,19 @@
   "name": "EnOcean",
   "codeowners": [],
   "config_flow": true,
+  "dependencies": ["usb"],
   "documentation": "https://www.home-assistant.io/integrations/enocean",
   "integration_type": "hub",
   "iot_class": "local_push",
   "loggers": ["enocean"],
   "requirements": ["enocean==0.50"],
-  "single_config_entry": true
+  "single_config_entry": true,
+  "usb": [
+    {
+      "description": "*usb 300*",
+      "manufacturer": "*enocean*",
+      "pid": "6001",
+      "vid": "0403"
+    }
+  ]
 }

homeassistant/components/enocean/strings.json

@@ -25,6 +25,9 @@
           "device": "[%key:component::enocean::config::step::detect::data_description::device%]"
         },
         "description": "Enter the path to your EnOcean USB dongle."
+      },
+      "usb_confirm": {
+        "description": "{manufacturer} USB dongle detected at {device}. Do you want to set up this device?"
       }
     }
   },

homeassistant/components/esphome/entry_data.py

@@ -300,16 +300,23 @@ class RuntimeEntryData:
                 needed_platforms.add(Platform.BINARY_SENSOR)
                 needed_platforms.add(Platform.SELECT)
 
-        needed_platforms.update(INFO_TYPE_TO_PLATFORM[type(info)] for info in infos)
-        await self._ensure_platforms_loaded(hass, entry, needed_platforms)
-
         # Make a dict of the EntityInfo by type and send
         # them to the listeners for each specific EntityInfo type
+        info_types_to_platform = INFO_TYPE_TO_PLATFORM
         infos_by_type: defaultdict[type[EntityInfo], list[EntityInfo]] = defaultdict(
             list
         )
         for info in infos:
-            infos_by_type[type(info)].append(info)
+            info_type = type(info)
+            if platform := info_types_to_platform.get(info_type):
+                needed_platforms.add(platform)
+                infos_by_type[info_type].append(info)
+            else:
+                _LOGGER.warning(
+                    "Entity type %s is not supported in this version of Home Assistant",
+                    info_type,
+                )
+        await self._ensure_platforms_loaded(hass, entry, needed_platforms)
 
         for type_, callbacks in self.entity_info_callbacks.items():
             # If all entities for a type are removed, we

homeassistant/components/esphome/manifest.json

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

homeassistant/components/fritzbox_callmonitor/manifest.json

@@ -1,7 +1,7 @@
 {
   "domain": "fritzbox_callmonitor",
   "name": "FRITZ!Box Call Monitor",
-  "codeowners": ["@cdce8p"],
+  "codeowners": [],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/fritzbox_callmonitor",
   "integration_type": "device",

homeassistant/components/google_assistant/trait.py

@@ -1752,15 +1752,15 @@ class FanSpeedTrait(_Trait):
         """Initialize a trait for a state."""
         super().__init__(hass, state, config)
         if state.domain == fan.DOMAIN:
-            speed_count = min(
-                FAN_SPEED_MAX_SPEED_COUNT,
-                round(
-                    100 / (self.state.attributes.get(fan.ATTR_PERCENTAGE_STEP) or 1.0)
-                ),
+            speed_count = round(
+                100 / (self.state.attributes.get(fan.ATTR_PERCENTAGE_STEP) or 1.0)
             )
-            self._ordered_speed = [
-                f"{speed}/{speed_count}" for speed in range(1, speed_count + 1)
-            ]
+            if speed_count <= FAN_SPEED_MAX_SPEED_COUNT:
+                self._ordered_speed = [
+                    f"{speed}/{speed_count}" for speed in range(1, speed_count + 1)
+                ]
+            else:
+                self._ordered_speed = []
 
     @staticmethod
     def supported(domain, features, device_class, _):
@@ -1786,7 +1786,11 @@ class FanSpeedTrait(_Trait):
             result.update(
                 {
                     "reversible": reversible,
-                    "supportsFanSpeedPercent": True,
+                    # supportsFanSpeedPercent is mutually exclusive with
+                    # availableFanSpeeds, where supportsFanSpeedPercent takes
+                    # precedence. Report it only when step speeds are not
+                    # supported so Google renders a percent slider (1-100%).
+                    "supportsFanSpeedPercent": not self._ordered_speed,
                 }
             )
 
@@ -1832,10 +1836,12 @@ class FanSpeedTrait(_Trait):
 
         if domain == fan.DOMAIN:
             percent = attrs.get(fan.ATTR_PERCENTAGE) or 0
-            response["currentFanSpeedPercent"] = percent
-            response["currentFanSpeedSetting"] = percentage_to_ordered_list_item(
-                self._ordered_speed, percent
-            )
+            if self._ordered_speed:
+                response["currentFanSpeedSetting"] = percentage_to_ordered_list_item(
+                    self._ordered_speed, percent
+                )
+            else:
+                response["currentFanSpeedPercent"] = percent
 
         return response
 
@@ -1855,7 +1861,7 @@ class FanSpeedTrait(_Trait):
             )
 
         if domain == fan.DOMAIN:
-            if fan_speed := params.get("fanSpeed"):
+            if self._ordered_speed and (fan_speed := params.get("fanSpeed")):
                 fan_speed_percent = ordered_list_item_to_percentage(
                     self._ordered_speed, fan_speed
                 )

homeassistant/components/hassio/ingress.py

@@ -181,8 +181,7 @@ class HassIOIngress(HomeAssistantView):
             skip_auto_headers={hdrs.CONTENT_TYPE},
         ) as result:
             headers = _response_header(result)
-            content_length_int = 0
-            content_length = result.headers.get(hdrs.CONTENT_LENGTH, UNDEFINED)
+
             # Avoid parsing content_type in simple cases for better performance
             if maybe_content_type := result.headers.get(hdrs.CONTENT_TYPE):
                 content_type: str = (maybe_content_type.partition(";"))[0].strip()
@@ -190,17 +189,30 @@ class HassIOIngress(HomeAssistantView):
                 # default value according to RFC 2616
                 content_type = "application/octet-stream"
 
+            # Empty body responses (304, 204, HEAD, etc.) should not be streamed,
+            # otherwise aiohttp < 3.9.0 may generate an invalid "0\r\n\r\n" chunk
+            # This also avoids setting content_type for empty responses.
+            if must_be_empty_body(request.method, result.status):
+                # If upstream contains content-type, preserve it (e.g. for HEAD requests)
+                # Note: This still is omitting content-length. We can't simply forward
+                # the upstream length since the proxy might change the body length
+                # (e.g. due to compression).
+                if maybe_content_type:
+                    headers[hdrs.CONTENT_TYPE] = content_type
+                return web.Response(
+                    headers=headers,
+                    status=result.status,
+                )
+
             # Simple request
-            if (empty_body := must_be_empty_body(result.method, result.status)) or (
+            content_length_int = 0
+            content_length = result.headers.get(hdrs.CONTENT_LENGTH, UNDEFINED)
+            if (
                 content_length is not UNDEFINED
                 and (content_length_int := int(content_length))
                 <= MAX_SIMPLE_RESPONSE_SIZE
             ):
-                # Return Response
-                if empty_body:
-                    body = None
-                else:
-                    body = await result.read()
+                body = await result.read()
                 simple_response = web.Response(
                     headers=headers,
                     status=result.status,

homeassistant/components/hikvision/manifest.json

@@ -7,6 +7,5 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["pyhik"],
-  "quality_scale": "legacy",
   "requirements": ["pyHik==0.4.2"]
 }

homeassistant/components/hikvision/quality_scale.yaml

@@ -0,0 +1,75 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: |
+      This integration does not provide additional actions.
+  appropriate-polling:
+    status: exempt
+    comment: |
+      This integration uses local_push and does not poll.
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: todo
+  docs-actions:
+    status: exempt
+    comment: |
+      This integration does not provide additional actions.
+  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: |
+      This integration does not provide additional actions.
+  config-entry-unloading: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: |
+      This integration has no configuration parameters.
+  docs-installation-parameters: todo
+  entity-unavailable: todo
+  integration-owner: done
+  log-when-unavailable: todo
+  parallel-updates: done
+  reauthentication-flow: todo
+  test-coverage: todo
+
+  # Gold
+  devices: todo
+  diagnostics: todo
+  discovery: todo
+  discovery-update-info: todo
+  docs-data-update: done
+  docs-examples: done
+  docs-known-limitations: done
+  docs-supported-devices: done
+  docs-supported-functions: todo
+  docs-troubleshooting: todo
+  docs-use-cases: todo
+  dynamic-devices: todo
+  entity-category: todo
+  entity-device-class: todo
+  entity-disabled-by-default: todo
+  entity-translations: todo
+  exception-translations: todo
+  icon-translations: todo
+  reconfiguration-flow: todo
+  repair-issues: todo
+  stale-devices: todo
+
+  # Platinum
+  async-dependency: todo
+  inject-websession: todo
+  strict-typing: todo

homeassistant/components/homee/config_flow.py

@@ -11,7 +11,12 @@ from pyHomee import (
 )
 import voluptuous as vol
 
-from homeassistant.config_entries import SOURCE_USER, ConfigFlow, ConfigFlowResult
+from homeassistant.config_entries import (
+    SOURCE_USER,
+    ConfigEntryState,
+    ConfigFlow,
+    ConfigFlowResult,
+)
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
 
@@ -113,7 +118,22 @@ class HomeeConfigFlow(ConfigFlow, domain=DOMAIN):
         if discovery_info.ip_address.version == 6:
             return self.async_abort(reason="ipv6_address")
 
-        await self.async_set_unique_id(self._name)
+        # If an already configured homee reports with a second IP, abort.
+        existing_entry = await self.async_set_unique_id(self._name)
+        if (
+            existing_entry
+            and existing_entry.state == ConfigEntryState.LOADED
+            and existing_entry.runtime_data.connected
+            and existing_entry.data[CONF_HOST] != self._host
+        ):
+            _LOGGER.debug(
+                "Aborting config flow for discovered homee with IP %s "
+                "since it is already configured at IP %s",
+                self._host,
+                existing_entry.data[CONF_HOST],
+            )
+            return self.async_abort(reason="2nd_ip_address")
+
         self._abort_if_unique_id_configured(updates={CONF_HOST: self._host})
 
         # Cause an auth-error to see if homee is reachable.

homeassistant/components/homee/event.py

@@ -20,6 +20,7 @@ PARALLEL_UPDATES = 0
 
 REMOTE_PROFILES = [
     NodeProfile.REMOTE,
+    NodeProfile.ONE_BUTTON_REMOTE,
     NodeProfile.TWO_BUTTON_REMOTE,
     NodeProfile.THREE_BUTTON_REMOTE,
     NodeProfile.FOUR_BUTTON_REMOTE,

homeassistant/components/homee/strings.json

@@ -1,6 +1,7 @@
 {
   "config": {
     "abort": {
+      "2nd_ip_address": "Your homee is already connected using another IP address",
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
       "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
       "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",

homeassistant/components/hue_ble/config_flow.py

@@ -6,6 +6,7 @@ from enum import Enum
 import logging
 from typing import Any
 
+from bleak.backends.scanner import AdvertisementData
 from HueBLE import ConnectionError, HueBleError, HueBleLight, PairingError
 import voluptuous as vol
 
@@ -26,6 +27,17 @@ from .light import get_available_color_modes
 _LOGGER = logging.getLogger(__name__)
 
 
+SERVICE_UUID = SERVICE_DATA_UUID = "0000fe0f-0000-1000-8000-00805f9b34fb"
+
+
+def device_filter(advertisement_data: AdvertisementData) -> bool:
+    """Return True if the device is supported."""
+    return (
+        SERVICE_UUID in advertisement_data.service_uuids
+        and SERVICE_DATA_UUID in advertisement_data.service_data
+    )
+
+
 async def validate_input(hass: HomeAssistant, address: str) -> Error | None:
     """Return error if cannot connect and validate."""
 
@@ -70,28 +82,66 @@ class HueBleConfigFlow(ConfigFlow, domain=DOMAIN):
 
     def __init__(self) -> None:
         """Initialize the config flow."""
+        self._discovered_devices: dict[str, bluetooth.BluetoothServiceInfoBleak] = {}
         self._discovery_info: bluetooth.BluetoothServiceInfoBleak | None = None
 
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the user step to pick discovered device."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            unique_id = dr.format_mac(user_input[CONF_MAC])
+            # Don't raise on progress because there may be discovery flows
+            await self.async_set_unique_id(unique_id, raise_on_progress=False)
+            # Guard against the user selecting a device which has been configured by
+            # another flow.
+            self._abort_if_unique_id_configured()
+            self._discovery_info = self._discovered_devices[user_input[CONF_MAC]]
+            return await self.async_step_confirm()
+
+        current_addresses = self._async_current_ids(include_ignore=False)
+        for discovery in bluetooth.async_discovered_service_info(self.hass):
+            if (
+                discovery.address in current_addresses
+                or discovery.address in self._discovered_devices
+                or not device_filter(discovery.advertisement)
+            ):
+                continue
+            self._discovered_devices[discovery.address] = discovery
+
+        if not self._discovered_devices:
+            return self.async_abort(reason="no_devices_found")
+
+        data_schema = vol.Schema(
+            {
+                vol.Required(CONF_MAC): vol.In(
+                    {
+                        service_info.address: (
+                            f"{service_info.name} ({service_info.address})"
+                        )
+                        for service_info in self._discovered_devices.values()
+                    }
+                ),
+            }
+        )
+        return self.async_show_form(
+            step_id="user",
+            data_schema=data_schema,
+            errors=errors,
+        )
+
     async def async_step_bluetooth(
         self, discovery_info: bluetooth.BluetoothServiceInfoBleak
     ) -> ConfigFlowResult:
         """Handle a flow initialized by the home assistant scanner."""
 
         _LOGGER.debug(
-            "HA found light %s. Will show in UI but not auto connect",
+            "HA found light %s. Use user flow to show in UI and connect",
             discovery_info.name,
         )
-
-        unique_id = dr.format_mac(discovery_info.address)
-        await self.async_set_unique_id(unique_id)
-        self._abort_if_unique_id_configured()
-
-        name = f"{discovery_info.name} ({discovery_info.address})"
-        self.context.update({"title_placeholders": {CONF_NAME: name}})
-
-        self._discovery_info = discovery_info
-
-        return await self.async_step_confirm()
+        return self.async_abort(reason="discovery_unsupported")
 
     async def async_step_confirm(
         self, user_input: dict[str, Any] | None = None
@@ -103,7 +153,10 @@ class HueBleConfigFlow(ConfigFlow, domain=DOMAIN):
 
         if user_input is not None:
             unique_id = dr.format_mac(self._discovery_info.address)
-            await self.async_set_unique_id(unique_id)
+            # Don't raise on progress because there may be discovery flows
+            await self.async_set_unique_id(unique_id, raise_on_progress=False)
+            # Guard against the user selecting a device which has been configured by
+            # another flow.
             self._abort_if_unique_id_configured()
             error = await validate_input(self.hass, unique_id)
             if error:

homeassistant/components/hue_ble/strings.json

@@ -2,7 +2,8 @@
   "config": {
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
-      "not_implemented": "This integration can only be set up via discovery."
+      "discovery_unsupported": "Discovery flow is not supported by the Hue BLE integration.",
+      "no_devices_found": "[%key:common::config_flow::abort::no_devices_found%]"
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -14,7 +15,16 @@
     },
     "step": {
       "confirm": {
-        "description": "Do you want to set up {name} ({mac})?. Make sure the light is [made discoverable to voice assistants]({url_pairing_mode}) or has been [factory reset]({url_factory_reset})."
+        "description": "Do you want to set up {name} ({mac})?\nMake sure the light is [made discoverable to voice assistants]({url_pairing_mode}) or has been [factory reset]({url_factory_reset})."
+      },
+      "user": {
+        "data": {
+          "mac": "[%key:common::config_flow::data::device%]"
+        },
+        "data_description": {
+          "mac": "Select the Hue device you want to set up"
+        },
+        "description": "[%key:component::bluetooth::config::step::user::description%]"
       }
     }
   }

homeassistant/components/liebherr/__init__.py

@@ -1,4 +1,4 @@
-"""The liebherr integration."""
+"""The Liebherr integration."""
 
 from __future__ import annotations
 
@@ -17,7 +17,12 @@ from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
 from .coordinator import LiebherrConfigEntry, LiebherrCoordinator
 
-PLATFORMS: list[Platform] = [Platform.NUMBER, Platform.SENSOR, Platform.SWITCH]
+PLATFORMS: list[Platform] = [
+    Platform.NUMBER,
+    Platform.SELECT,
+    Platform.SENSOR,
+    Platform.SWITCH,
+]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: LiebherrConfigEntry) -> bool:

homeassistant/components/liebherr/icons.json

@@ -1,5 +1,55 @@
 {
   "entity": {
+    "select": {
+      "bio_fresh_plus": {
+        "default": "mdi:leaf"
+      },
+      "bio_fresh_plus_bottom_zone": {
+        "default": "mdi:leaf"
+      },
+      "bio_fresh_plus_middle_zone": {
+        "default": "mdi:leaf"
+      },
+      "bio_fresh_plus_top_zone": {
+        "default": "mdi:leaf"
+      },
+      "hydro_breeze": {
+        "default": "mdi:weather-windy"
+      },
+      "hydro_breeze_bottom_zone": {
+        "default": "mdi:weather-windy"
+      },
+      "hydro_breeze_middle_zone": {
+        "default": "mdi:weather-windy"
+      },
+      "hydro_breeze_top_zone": {
+        "default": "mdi:weather-windy"
+      },
+      "ice_maker": {
+        "default": "mdi:cube-outline",
+        "state": {
+          "off": "mdi:cube-outline-off"
+        }
+      },
+      "ice_maker_bottom_zone": {
+        "default": "mdi:cube-outline",
+        "state": {
+          "off": "mdi:cube-outline-off"
+        }
+      },
+      "ice_maker_middle_zone": {
+        "default": "mdi:cube-outline",
+        "state": {
+          "off": "mdi:cube-outline-off"
+        }
+      },
+      "ice_maker_top_zone": {
+        "default": "mdi:cube-outline",
+        "state": {
+          "off": "mdi:cube-outline-off"
+        }
+      }
+    },
     "switch": {
       "night_mode": {
         "default": "mdi:sleep",

homeassistant/components/liebherr/select.py

@@ -0,0 +1,216 @@
+"""Select platform for Liebherr integration."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import TYPE_CHECKING, Any
+
+from pyliebherrhomeapi import (
+    BioFreshPlusControl,
+    BioFreshPlusMode,
+    HydroBreezeControl,
+    HydroBreezeMode,
+    IceMakerControl,
+    IceMakerMode,
+    ZonePosition,
+)
+
+from homeassistant.components.select import SelectEntity, SelectEntityDescription
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import LiebherrConfigEntry, LiebherrCoordinator
+from .entity import ZONE_POSITION_MAP, LiebherrEntity
+
+PARALLEL_UPDATES = 1
+
+type SelectControl = IceMakerControl | HydroBreezeControl | BioFreshPlusControl
+
+
+@dataclass(frozen=True, kw_only=True)
+class LiebherrSelectEntityDescription(SelectEntityDescription):
+    """Describes a Liebherr select entity."""
+
+    control_type: type[SelectControl]
+    mode_enum: type[StrEnum]
+    current_mode_fn: Callable[[SelectControl], StrEnum | str | None]
+    options_fn: Callable[[SelectControl], list[str]]
+    set_fn: Callable[[LiebherrCoordinator, int, StrEnum], Coroutine[Any, Any, None]]
+
+
+def _ice_maker_options(control: SelectControl) -> list[str]:
+    """Return available ice maker options."""
+    if TYPE_CHECKING:
+        assert isinstance(control, IceMakerControl)
+    options = [IceMakerMode.OFF.value, IceMakerMode.ON.value]
+    if control.has_max_ice:
+        options.append(IceMakerMode.MAX_ICE.value)
+    return options
+
+
+def _hydro_breeze_options(control: SelectControl) -> list[str]:
+    """Return available HydroBreeze options."""
+    return [mode.value for mode in HydroBreezeMode]
+
+
+def _bio_fresh_plus_options(control: SelectControl) -> list[str]:
+    """Return available BioFresh-Plus options."""
+    if TYPE_CHECKING:
+        assert isinstance(control, BioFreshPlusControl)
+    return [
+        mode.value
+        for mode in control.supported_modes
+        if isinstance(mode, BioFreshPlusMode)
+    ]
+
+
+SELECT_TYPES: list[LiebherrSelectEntityDescription] = [
+    LiebherrSelectEntityDescription(
+        key="ice_maker",
+        translation_key="ice_maker",
+        control_type=IceMakerControl,
+        mode_enum=IceMakerMode,
+        current_mode_fn=lambda c: c.ice_maker_mode,  # type: ignore[union-attr]
+        options_fn=_ice_maker_options,
+        set_fn=lambda coordinator, zone_id, mode: coordinator.client.set_ice_maker(
+            device_id=coordinator.device_id,
+            zone_id=zone_id,
+            mode=mode,  # type: ignore[arg-type]
+        ),
+    ),
+    LiebherrSelectEntityDescription(
+        key="hydro_breeze",
+        translation_key="hydro_breeze",
+        control_type=HydroBreezeControl,
+        mode_enum=HydroBreezeMode,
+        current_mode_fn=lambda c: c.current_mode,  # type: ignore[union-attr]
+        options_fn=_hydro_breeze_options,
+        set_fn=lambda coordinator, zone_id, mode: coordinator.client.set_hydro_breeze(
+            device_id=coordinator.device_id,
+            zone_id=zone_id,
+            mode=mode,  # type: ignore[arg-type]
+        ),
+    ),
+    LiebherrSelectEntityDescription(
+        key="bio_fresh_plus",
+        translation_key="bio_fresh_plus",
+        control_type=BioFreshPlusControl,
+        mode_enum=BioFreshPlusMode,
+        current_mode_fn=lambda c: c.current_mode,  # type: ignore[union-attr]
+        options_fn=_bio_fresh_plus_options,
+        set_fn=lambda coordinator, zone_id, mode: coordinator.client.set_bio_fresh_plus(
+            device_id=coordinator.device_id,
+            zone_id=zone_id,
+            mode=mode,  # type: ignore[arg-type]
+        ),
+    ),
+]
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: LiebherrConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Liebherr select entities."""
+    entities: list[LiebherrSelectEntity] = []
+
+    for coordinator in entry.runtime_data.values():
+        has_multiple_zones = len(coordinator.data.get_temperature_controls()) > 1
+
+        for control in coordinator.data.controls:
+            for description in SELECT_TYPES:
+                if isinstance(control, description.control_type):
+                    if TYPE_CHECKING:
+                        assert isinstance(
+                            control,
+                            IceMakerControl | HydroBreezeControl | BioFreshPlusControl,
+                        )
+                    entities.append(
+                        LiebherrSelectEntity(
+                            coordinator=coordinator,
+                            description=description,
+                            zone_id=control.zone_id,
+                            has_multiple_zones=has_multiple_zones,
+                        )
+                    )
+
+    async_add_entities(entities)
+
+
+class LiebherrSelectEntity(LiebherrEntity, SelectEntity):
+    """Representation of a Liebherr select entity."""
+
+    entity_description: LiebherrSelectEntityDescription
+
+    def __init__(
+        self,
+        coordinator: LiebherrCoordinator,
+        description: LiebherrSelectEntityDescription,
+        zone_id: int,
+        has_multiple_zones: bool,
+    ) -> None:
+        """Initialize the select entity."""
+        super().__init__(coordinator)
+        self.entity_description = description
+        self._zone_id = zone_id
+        self._attr_unique_id = f"{coordinator.device_id}_{description.key}_{zone_id}"
+
+        # Set options from the control
+        control = self._select_control
+        if control is not None:
+            self._attr_options = description.options_fn(control)
+
+        # Add zone suffix only for multi-zone devices
+        if has_multiple_zones:
+            temp_controls = coordinator.data.get_temperature_controls()
+            if (
+                (tc := temp_controls.get(zone_id))
+                and isinstance(tc.zone_position, ZonePosition)
+                and (zone_key := ZONE_POSITION_MAP.get(tc.zone_position))
+            ):
+                self._attr_translation_key = f"{description.translation_key}_{zone_key}"
+
+    @property
+    def _select_control(self) -> SelectControl | None:
+        """Get the select control for this entity."""
+        for control in self.coordinator.data.controls:
+            if (
+                isinstance(control, self.entity_description.control_type)
+                and control.zone_id == self._zone_id
+            ):
+                if TYPE_CHECKING:
+                    assert isinstance(
+                        control,
+                        IceMakerControl | HydroBreezeControl | BioFreshPlusControl,
+                    )
+                return control
+        return None
+
+    @property
+    def current_option(self) -> str | None:
+        """Return the current selected option."""
+        control = self._select_control
+        if TYPE_CHECKING:
+            assert isinstance(
+                control,
+                IceMakerControl | HydroBreezeControl | BioFreshPlusControl,
+            )
+        mode = self.entity_description.current_mode_fn(control)
+        if isinstance(mode, StrEnum):
+            return mode.value
+        return None
+
+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        return super().available and self._select_control is not None
+
+    async def async_select_option(self, option: str) -> None:
+        """Change the selected option."""
+        mode = self.entity_description.mode_enum(option)
+        await self._async_send_command(
+            self.entity_description.set_fn(self.coordinator, self._zone_id, mode),
+        )

homeassistant/components/liebherr/strings.json

@@ -47,6 +47,112 @@
         "name": "Top zone setpoint"
       }
     },
+    "select": {
+      "bio_fresh_plus": {
+        "name": "BioFresh-Plus",
+        "state": {
+          "minus_two_minus_two": "-2°C | -2°C",
+          "minus_two_zero": "-2°C | 0°C",
+          "zero_minus_two": "0°C | -2°C",
+          "zero_zero": "0°C | 0°C"
+        }
+      },
+      "bio_fresh_plus_bottom_zone": {
+        "name": "Bottom zone BioFresh-Plus",
+        "state": {
+          "minus_two_minus_two": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::minus_two_minus_two%]",
+          "minus_two_zero": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::minus_two_zero%]",
+          "zero_minus_two": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::zero_minus_two%]",
+          "zero_zero": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::zero_zero%]"
+        }
+      },
+      "bio_fresh_plus_middle_zone": {
+        "name": "Middle zone BioFresh-Plus",
+        "state": {
+          "minus_two_minus_two": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::minus_two_minus_two%]",
+          "minus_two_zero": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::minus_two_zero%]",
+          "zero_minus_two": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::zero_minus_two%]",
+          "zero_zero": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::zero_zero%]"
+        }
+      },
+      "bio_fresh_plus_top_zone": {
+        "name": "Top zone BioFresh-Plus",
+        "state": {
+          "minus_two_minus_two": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::minus_two_minus_two%]",
+          "minus_two_zero": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::minus_two_zero%]",
+          "zero_minus_two": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::zero_minus_two%]",
+          "zero_zero": "[%key:component::liebherr::entity::select::bio_fresh_plus::state::zero_zero%]"
+        }
+      },
+      "hydro_breeze": {
+        "name": "HydroBreeze",
+        "state": {
+          "high": "[%key:common::state::high%]",
+          "low": "[%key:common::state::low%]",
+          "medium": "[%key:common::state::medium%]",
+          "off": "[%key:common::state::off%]"
+        }
+      },
+      "hydro_breeze_bottom_zone": {
+        "name": "Bottom zone HydroBreeze",
+        "state": {
+          "high": "[%key:common::state::high%]",
+          "low": "[%key:common::state::low%]",
+          "medium": "[%key:common::state::medium%]",
+          "off": "[%key:common::state::off%]"
+        }
+      },
+      "hydro_breeze_middle_zone": {
+        "name": "Middle zone HydroBreeze",
+        "state": {
+          "high": "[%key:common::state::high%]",
+          "low": "[%key:common::state::low%]",
+          "medium": "[%key:common::state::medium%]",
+          "off": "[%key:common::state::off%]"
+        }
+      },
+      "hydro_breeze_top_zone": {
+        "name": "Top zone HydroBreeze",
+        "state": {
+          "high": "[%key:common::state::high%]",
+          "low": "[%key:common::state::low%]",
+          "medium": "[%key:common::state::medium%]",
+          "off": "[%key:common::state::off%]"
+        }
+      },
+      "ice_maker": {
+        "name": "IceMaker",
+        "state": {
+          "max_ice": "MaxIce",
+          "off": "[%key:common::state::off%]",
+          "on": "[%key:common::state::on%]"
+        }
+      },
+      "ice_maker_bottom_zone": {
+        "name": "Bottom zone IceMaker",
+        "state": {
+          "max_ice": "[%key:component::liebherr::entity::select::ice_maker::state::max_ice%]",
+          "off": "[%key:common::state::off%]",
+          "on": "[%key:common::state::on%]"
+        }
+      },
+      "ice_maker_middle_zone": {
+        "name": "Middle zone IceMaker",
+        "state": {
+          "max_ice": "[%key:component::liebherr::entity::select::ice_maker::state::max_ice%]",
+          "off": "[%key:common::state::off%]",
+          "on": "[%key:common::state::on%]"
+        }
+      },
+      "ice_maker_top_zone": {
+        "name": "Top zone IceMaker",
+        "state": {
+          "max_ice": "[%key:component::liebherr::entity::select::ice_maker::state::max_ice%]",
+          "off": "[%key:common::state::off%]",
+          "on": "[%key:common::state::on%]"
+        }
+      }
+    },
     "sensor": {
       "bottom_zone": {
         "name": "Bottom zone"

homeassistant/components/lunatone/light.py

@@ -109,14 +109,18 @@ class LunatoneLight(
         return self._device is not None and self._device.is_on
 
     @property
-    def brightness(self) -> int:
+    def brightness(self) -> int | None:
         """Return the brightness of this light between 0..255."""
-        return value_to_brightness(self.BRIGHTNESS_SCALE, self._device.brightness)
+        return (
+            value_to_brightness(self.BRIGHTNESS_SCALE, self._device.brightness)
+            if self._device.brightness is not None
+            else None
+        )
 
     @property
     def color_mode(self) -> ColorMode:
         """Return the color mode of the light."""
-        if self._device is not None and self._device.is_dimmable:
+        if self._device is not None and self._device.brightness is not None:
             return ColorMode.BRIGHTNESS
         return ColorMode.ONOFF
 
@@ -149,7 +153,8 @@ class LunatoneLight(
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Instruct the light to turn off."""
         if brightness_supported(self.supported_color_modes):
-            self._last_brightness = self.brightness
+            if self.brightness:
+                self._last_brightness = self.brightness
             await self._device.fade_to_brightness(0)
         else:
             await self._device.switch_off()

homeassistant/components/lunatone/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "quality_scale": "silver",
-  "requirements": ["lunatone-rest-api-client==0.6.3"]
+  "requirements": ["lunatone-rest-api-client==0.7.0"]
 }

homeassistant/components/media_extractor/manifest.json

@@ -8,6 +8,6 @@
   "iot_class": "calculated",
   "loggers": ["yt_dlp"],
   "quality_scale": "internal",
-  "requirements": ["yt-dlp[default]==2026.02.04"],
+  "requirements": ["yt-dlp[default]==2026.02.21"],
   "single_config_entry": true
 }

homeassistant/components/mta/__init__.py

@@ -2,10 +2,12 @@
 
 from __future__ import annotations
 
+import asyncio
+
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 
-from .const import DOMAIN as DOMAIN
+from .const import DOMAIN as DOMAIN, SUBENTRY_TYPE_BUS, SUBENTRY_TYPE_SUBWAY
 from .coordinator import MTAConfigEntry, MTADataUpdateCoordinator
 
 PLATFORMS = [Platform.SENSOR]
@@ -13,16 +15,36 @@ PLATFORMS = [Platform.SENSOR]
 
 async def async_setup_entry(hass: HomeAssistant, entry: MTAConfigEntry) -> bool:
     """Set up MTA from a config entry."""
-    coordinator = MTADataUpdateCoordinator(hass, entry)
-    await coordinator.async_config_entry_first_refresh()
+    coordinators: dict[str, MTADataUpdateCoordinator] = {}
 
-    entry.runtime_data = coordinator
+    for subentry_id, subentry in entry.subentries.items():
+        if subentry.subentry_type not in (SUBENTRY_TYPE_SUBWAY, SUBENTRY_TYPE_BUS):
+            continue
+
+        coordinators[subentry_id] = MTADataUpdateCoordinator(hass, entry, subentry)
+
+    # Refresh all coordinators in parallel
+    await asyncio.gather(
+        *(
+            coordinator.async_config_entry_first_refresh()
+            for coordinator in coordinators.values()
+        )
+    )
+
+    entry.runtime_data = coordinators
+
+    entry.async_on_unload(entry.add_update_listener(async_update_entry))
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
 
 
+async def async_update_entry(hass: HomeAssistant, entry: MTAConfigEntry) -> None:
+    """Handle config entry update (e.g., subentry changes)."""
+    await hass.config_entries.async_reload(entry.entry_id)
+
+
 async def async_unload_entry(hass: HomeAssistant, entry: MTAConfigEntry) -> bool:
     """Unload a config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/mta/config_flow.py

@@ -2,22 +2,43 @@
 
 from __future__ import annotations
 
+from collections.abc import Mapping
 import logging
 from typing import Any
 
-from pymta import LINE_TO_FEED, MTAFeedError, SubwayFeed
+from pymta import LINE_TO_FEED, BusFeed, MTAFeedError, SubwayFeed
 import voluptuous as vol
 
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.helpers import aiohttp_client
+from homeassistant.config_entries import (
+    SOURCE_REAUTH,
+    ConfigEntry,
+    ConfigFlow,
+    ConfigFlowResult,
+    ConfigSubentryFlow,
+    SubentryFlowResult,
+)
+from homeassistant.const import CONF_API_KEY
+from homeassistant.core import callback
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.selector import (
     SelectOptionDict,
     SelectSelector,
     SelectSelectorConfig,
     SelectSelectorMode,
+    TextSelector,
+    TextSelectorConfig,
+    TextSelectorType,
 )
 
-from .const import CONF_LINE, CONF_STOP_ID, CONF_STOP_NAME, DOMAIN
+from .const import (
+    CONF_LINE,
+    CONF_ROUTE,
+    CONF_STOP_ID,
+    CONF_STOP_NAME,
+    DOMAIN,
+    SUBENTRY_TYPE_BUS,
+    SUBENTRY_TYPE_SUBWAY,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -28,17 +49,79 @@ class MTAConfigFlow(ConfigFlow, domain=DOMAIN):
     VERSION = 1
     MINOR_VERSION = 1
 
-    def __init__(self) -> None:
-        """Initialize the config flow."""
-        self.data: dict[str, Any] = {}
-        self.stops: dict[str, str] = {}
+    @classmethod
+    @callback
+    def async_get_supported_subentry_types(
+        cls, config_entry: ConfigEntry
+    ) -> dict[str, type[ConfigSubentryFlow]]:
+        """Return subentries supported by this handler."""
+        return {
+            SUBENTRY_TYPE_SUBWAY: SubwaySubentryFlowHandler,
+            SUBENTRY_TYPE_BUS: BusSubentryFlowHandler,
+        }
 
     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:
+            api_key = user_input.get(CONF_API_KEY)
+            self._async_abort_entries_match({CONF_API_KEY: api_key})
+            if api_key:
+                # Test the API key by trying to fetch bus data
+                session = async_get_clientsession(self.hass)
+                bus_feed = BusFeed(api_key=api_key, session=session)
+                try:
+                    # Try to get stops for a known route to validate the key
+                    await bus_feed.get_stops(route_id="M15")
+                except MTAFeedError:
+                    errors["base"] = "cannot_connect"
+                except Exception:
+                    _LOGGER.exception("Unexpected error validating API key")
+                    errors["base"] = "unknown"
+            if not errors:
+                if self.source == SOURCE_REAUTH:
+                    return self.async_update_reload_and_abort(
+                        self._get_reauth_entry(),
+                        data_updates={CONF_API_KEY: api_key or None},
+                    )
+                return self.async_create_entry(
+                    title="MTA",
+                    data={CONF_API_KEY: api_key or None},
+                )
 
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Optional(CONF_API_KEY): TextSelector(
+                        TextSelectorConfig(type=TextSelectorType.PASSWORD)
+                    ),
+                }
+            ),
+            errors=errors,
+        )
+
+    async def async_step_reauth(
+        self, _entry_data: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Handle reauth when user wants to add or update API key."""
+        return await self.async_step_user()
+
+
+class SubwaySubentryFlowHandler(ConfigSubentryFlow):
+    """Handle subway stop subentry flow."""
+
+    def __init__(self) -> None:
+        """Initialize the subentry flow."""
+        self.data: dict[str, Any] = {}
+        self.stops: dict[str, str] = {}
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> SubentryFlowResult:
+        """Handle the line selection step."""
         if user_input is not None:
             self.data[CONF_LINE] = user_input[CONF_LINE]
             return await self.async_step_stop()
@@ -58,13 +141,12 @@ class MTAConfigFlow(ConfigFlow, domain=DOMAIN):
                     ),
                 }
             ),
-            errors=errors,
         )
 
     async def async_step_stop(
         self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle the stop step."""
+    ) -> SubentryFlowResult:
+        """Handle the stop selection step."""
         errors: dict[str, str] = {}
 
         if user_input is not None:
@@ -74,25 +156,30 @@ class MTAConfigFlow(ConfigFlow, domain=DOMAIN):
             self.data[CONF_STOP_NAME] = stop_name
 
             unique_id = f"{self.data[CONF_LINE]}_{stop_id}"
-            await self.async_set_unique_id(unique_id)
-            self._abort_if_unique_id_configured()
 
-            # Test connection to real-time GTFS-RT feed (different from static GTFS used by get_stops)
+            # Check for duplicate subentries across all entries
+            for entry in self.hass.config_entries.async_entries(DOMAIN):
+                for subentry in entry.subentries.values():
+                    if subentry.unique_id == unique_id:
+                        return self.async_abort(reason="already_configured")
+
+            # Test connection to real-time GTFS-RT feed
             try:
                 await self._async_test_connection()
             except MTAFeedError:
                 errors["base"] = "cannot_connect"
             else:
-                title = f"{self.data[CONF_LINE]} Line - {stop_name}"
+                title = f"{self.data[CONF_LINE]} - {stop_name}"
                 return self.async_create_entry(
                     title=title,
                     data=self.data,
+                    unique_id=unique_id,
                 )
 
         try:
             self.stops = await self._async_get_stops(self.data[CONF_LINE])
         except MTAFeedError:
-            _LOGGER.exception("Error fetching stops for line %s", self.data[CONF_LINE])
+            _LOGGER.debug("Error fetching stops for line %s", self.data[CONF_LINE])
             return self.async_abort(reason="cannot_connect")
 
         if not self.stops:
@@ -123,7 +210,7 @@ class MTAConfigFlow(ConfigFlow, domain=DOMAIN):
     async def _async_get_stops(self, line: str) -> dict[str, str]:
         """Get stops for a line from the library."""
         feed_id = SubwayFeed.get_feed_id_for_route(line)
-        session = aiohttp_client.async_get_clientsession(self.hass)
+        session = async_get_clientsession(self.hass)
 
         subway_feed = SubwayFeed(feed_id=feed_id, session=session)
         stops_list = await subway_feed.get_stops(route_id=line)
@@ -141,7 +228,7 @@ class MTAConfigFlow(ConfigFlow, domain=DOMAIN):
     async def _async_test_connection(self) -> None:
         """Test connection to MTA feed."""
         feed_id = SubwayFeed.get_feed_id_for_route(self.data[CONF_LINE])
-        session = aiohttp_client.async_get_clientsession(self.hass)
+        session = async_get_clientsession(self.hass)
 
         subway_feed = SubwayFeed(feed_id=feed_id, session=session)
         await subway_feed.get_arrivals(
@@ -149,3 +236,133 @@ class MTAConfigFlow(ConfigFlow, domain=DOMAIN):
             stop_id=self.data[CONF_STOP_ID],
             max_arrivals=1,
         )
+
+
+class BusSubentryFlowHandler(ConfigSubentryFlow):
+    """Handle bus stop subentry flow."""
+
+    def __init__(self) -> None:
+        """Initialize the subentry flow."""
+        self.data: dict[str, Any] = {}
+        self.stops: dict[str, str] = {}
+
+    def _get_api_key(self) -> str:
+        """Get API key from parent entry."""
+        return self._get_entry().data.get(CONF_API_KEY) or ""
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> SubentryFlowResult:
+        """Handle the route input step."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            route = user_input[CONF_ROUTE].upper().strip()
+            self.data[CONF_ROUTE] = route
+
+            # Validate route by fetching stops
+            try:
+                self.stops = await self._async_get_stops(route)
+                if not self.stops:
+                    errors["base"] = "invalid_route"
+                else:
+                    return await self.async_step_stop()
+            except MTAFeedError:
+                _LOGGER.debug("Error fetching stops for route %s", route)
+                errors["base"] = "invalid_route"
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_ROUTE): TextSelector(),
+                }
+            ),
+            errors=errors,
+        )
+
+    async def async_step_stop(
+        self, user_input: dict[str, Any] | None = None
+    ) -> SubentryFlowResult:
+        """Handle the stop selection step."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            stop_id = user_input[CONF_STOP_ID]
+            self.data[CONF_STOP_ID] = stop_id
+            stop_name = self.stops.get(stop_id, stop_id)
+            self.data[CONF_STOP_NAME] = stop_name
+
+            unique_id = f"bus_{self.data[CONF_ROUTE]}_{stop_id}"
+
+            # Check for duplicate subentries across all entries
+            for entry in self.hass.config_entries.async_entries(DOMAIN):
+                for subentry in entry.subentries.values():
+                    if subentry.unique_id == unique_id:
+                        return self.async_abort(reason="already_configured")
+
+            # Test connection to real-time feed
+            try:
+                await self._async_test_connection()
+            except MTAFeedError:
+                errors["base"] = "cannot_connect"
+            else:
+                title = f"{self.data[CONF_ROUTE]} - {stop_name}"
+                return self.async_create_entry(
+                    title=title,
+                    data=self.data,
+                    unique_id=unique_id,
+                )
+
+        stop_options = [
+            SelectOptionDict(value=stop_id, label=stop_name)
+            for stop_id, stop_name in sorted(self.stops.items(), key=lambda x: x[1])
+        ]
+
+        return self.async_show_form(
+            step_id="stop",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_STOP_ID): SelectSelector(
+                        SelectSelectorConfig(
+                            options=stop_options,
+                            mode=SelectSelectorMode.DROPDOWN,
+                        )
+                    ),
+                }
+            ),
+            errors=errors,
+            description_placeholders={"route": self.data[CONF_ROUTE]},
+        )
+
+    async def _async_get_stops(self, route: str) -> dict[str, str]:
+        """Get stops for a bus route from the library."""
+        session = async_get_clientsession(self.hass)
+        api_key = self._get_api_key()
+
+        bus_feed = BusFeed(api_key=api_key, session=session)
+        stops_list = await bus_feed.get_stops(route_id=route)
+
+        stops = {}
+        for stop in stops_list:
+            stop_id = stop["stop_id"]
+            stop_name = stop["stop_name"]
+            # Add direction if available (e.g., "to South Ferry")
+            if direction := stop.get("direction_name"):
+                stops[stop_id] = f"{stop_name} (to {direction})"
+            else:
+                stops[stop_id] = stop_name
+
+        return stops
+
+    async def _async_test_connection(self) -> None:
+        """Test connection to MTA bus feed."""
+        session = async_get_clientsession(self.hass)
+        api_key = self._get_api_key()
+
+        bus_feed = BusFeed(api_key=api_key, session=session)
+        await bus_feed.get_arrivals(
+            route_id=self.data[CONF_ROUTE],
+            stop_id=self.data[CONF_STOP_ID],
+            max_arrivals=1,
+        )

homeassistant/components/mta/const.py

@@ -7,5 +7,9 @@ DOMAIN = "mta"
 CONF_LINE = "line"
 CONF_STOP_ID = "stop_id"
 CONF_STOP_NAME = "stop_name"
+CONF_ROUTE = "route"
+
+SUBENTRY_TYPE_SUBWAY = "subway"
+SUBENTRY_TYPE_BUS = "bus"
 
 UPDATE_INTERVAL = timedelta(seconds=30)

homeassistant/components/mta/coordinator.py

@@ -6,22 +6,30 @@ from dataclasses import dataclass
 from datetime import datetime
 import logging
 
-from pymta import MTAFeedError, SubwayFeed
+from pymta import BusFeed, MTAFeedError, SubwayFeed
 
-from homeassistant.config_entries import ConfigEntry
+from homeassistant.config_entries import ConfigEntry, ConfigSubentry
+from homeassistant.const import CONF_API_KEY
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 from homeassistant.util import dt as dt_util
 
-from .const import CONF_LINE, CONF_STOP_ID, DOMAIN, UPDATE_INTERVAL
+from .const import (
+    CONF_LINE,
+    CONF_ROUTE,
+    CONF_STOP_ID,
+    DOMAIN,
+    SUBENTRY_TYPE_BUS,
+    UPDATE_INTERVAL,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
 
 @dataclass
 class MTAArrival:
-    """Represents a single train arrival."""
+    """Represents a single transit arrival."""
 
     arrival_time: datetime
     minutes_until: int
@@ -36,7 +44,7 @@ class MTAData:
     arrivals: list[MTAArrival]
 
 
-type MTAConfigEntry = ConfigEntry[MTADataUpdateCoordinator]
+type MTAConfigEntry = ConfigEntry[dict[str, MTADataUpdateCoordinator]]
 
 
 class MTADataUpdateCoordinator(DataUpdateCoordinator[MTAData]):
@@ -44,35 +52,48 @@ class MTADataUpdateCoordinator(DataUpdateCoordinator[MTAData]):
 
     config_entry: MTAConfigEntry
 
-    def __init__(self, hass: HomeAssistant, config_entry: MTAConfigEntry) -> None:
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: MTAConfigEntry,
+        subentry: ConfigSubentry,
+    ) -> None:
         """Initialize."""
-        self.line = config_entry.data[CONF_LINE]
-        self.stop_id = config_entry.data[CONF_STOP_ID]
+        self.subentry = subentry
+        self.stop_id = subentry.data[CONF_STOP_ID]
 
-        self.feed_id = SubwayFeed.get_feed_id_for_route(self.line)
         session = async_get_clientsession(hass)
-        self.subway_feed = SubwayFeed(feed_id=self.feed_id, session=session)
+
+        if subentry.subentry_type == SUBENTRY_TYPE_BUS:
+            api_key = config_entry.data.get(CONF_API_KEY) or ""
+            self.feed: BusFeed | SubwayFeed = BusFeed(api_key=api_key, session=session)
+            self.route_id = subentry.data[CONF_ROUTE]
+        else:
+            # Subway feed
+            line = subentry.data[CONF_LINE]
+            feed_id = SubwayFeed.get_feed_id_for_route(line)
+            self.feed = SubwayFeed(feed_id=feed_id, session=session)
+            self.route_id = line
 
         super().__init__(
             hass,
             _LOGGER,
             config_entry=config_entry,
-            name=DOMAIN,
+            name=f"{DOMAIN}_{subentry.subentry_id}",
             update_interval=UPDATE_INTERVAL,
         )
 
     async def _async_update_data(self) -> MTAData:
         """Fetch data from MTA."""
         _LOGGER.debug(
-            "Fetching data for line=%s, stop=%s, feed=%s",
-            self.line,
+            "Fetching data for route=%s, stop=%s",
+            self.route_id,
             self.stop_id,
-            self.feed_id,
         )
 
         try:
-            library_arrivals = await self.subway_feed.get_arrivals(
-                route_id=self.line,
+            library_arrivals = await self.feed.get_arrivals(
+                route_id=self.route_id,
                 stop_id=self.stop_id,
                 max_arrivals=3,
             )

homeassistant/components/mta/quality_scale.yaml

@@ -38,9 +38,7 @@ rules:
   integration-owner: done
   log-when-unavailable: done
   parallel-updates: done
-  reauthentication-flow:
-    status: exempt
-    comment: No authentication required.
+  reauthentication-flow: done
   test-coverage: done
 
   # Gold

homeassistant/components/mta/sensor.py

@@ -11,12 +11,13 @@ from homeassistant.components.sensor import (
     SensorEntity,
     SensorEntityDescription,
 )
+from homeassistant.config_entries import ConfigSubentry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import CONF_LINE, CONF_STOP_ID, CONF_STOP_NAME, DOMAIN
+from .const import CONF_LINE, CONF_ROUTE, CONF_STOP_NAME, DOMAIN, SUBENTRY_TYPE_BUS
 from .coordinator import MTAArrival, MTAConfigEntry, MTADataUpdateCoordinator
 
 PARALLEL_UPDATES = 0
@@ -97,16 +98,19 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up MTA sensor based on a config entry."""
-    coordinator = entry.runtime_data
-
-    async_add_entities(
-        MTASensor(coordinator, entry, description)
-        for description in SENSOR_DESCRIPTIONS
-    )
+    for subentry_id, coordinator in entry.runtime_data.items():
+        subentry = entry.subentries[subentry_id]
+        async_add_entities(
+            (
+                MTASensor(coordinator, subentry, description)
+                for description in SENSOR_DESCRIPTIONS
+            ),
+            config_subentry_id=subentry_id,
+        )
 
 
 class MTASensor(CoordinatorEntity[MTADataUpdateCoordinator], SensorEntity):
-    """Sensor for MTA train arrivals."""
+    """Sensor for MTA transit arrivals."""
 
     _attr_has_entity_name = True
     entity_description: MTASensorEntityDescription
@@ -114,24 +118,32 @@ class MTASensor(CoordinatorEntity[MTADataUpdateCoordinator], SensorEntity):
     def __init__(
         self,
         coordinator: MTADataUpdateCoordinator,
-        entry: MTAConfigEntry,
+        subentry: ConfigSubentry,
         description: MTASensorEntityDescription,
     ) -> None:
         """Initialize the sensor."""
         super().__init__(coordinator)
 
         self.entity_description = description
-        line = entry.data[CONF_LINE]
-        stop_id = entry.data[CONF_STOP_ID]
-        stop_name = entry.data.get(CONF_STOP_NAME, stop_id)
 
-        self._attr_unique_id = f"{entry.unique_id}-{description.key}"
+        is_bus = subentry.subentry_type == SUBENTRY_TYPE_BUS
+        if is_bus:
+            route = subentry.data[CONF_ROUTE]
+            model = "Bus"
+        else:
+            route = subentry.data[CONF_LINE]
+            model = "Subway"
+
+        stop_name = subentry.data.get(CONF_STOP_NAME, subentry.subentry_id)
+
+        unique_id = subentry.unique_id or subentry.subentry_id
+        self._attr_unique_id = f"{unique_id}-{description.key}"
 
         self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, entry.entry_id)},
-            name=f"{line} Line - {stop_name} ({stop_id})",
+            identifiers={(DOMAIN, unique_id)},
+            name=f"{route} - {stop_name}",
             manufacturer="MTA",
-            model="Subway",
+            model=model,
             entry_type=DeviceEntryType.SERVICE,
         )
 

homeassistant/components/mta/strings.json

@@ -2,32 +2,95 @@
   "config": {
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "no_stops": "No stops found for this line. The line may not be currently running."
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
     },
     "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "step": {
-      "stop": {
-        "data": {
-          "stop_id": "Stop and direction"
-        },
-        "data_description": {
-          "stop_id": "Select the stop and direction you want to track"
-        },
-        "description": "Choose a stop on the {line} line. The direction is included with each stop.",
-        "title": "Select stop and direction"
-      },
       "user": {
         "data": {
-          "line": "Line"
+          "api_key": "[%key:common::config_flow::data::api_key%]"
         },
         "data_description": {
-          "line": "The subway line to track"
+          "api_key": "API key from MTA Bus Time. Required for bus tracking, optional for subway only."
         },
-        "description": "Choose the subway line you want to track.",
-        "title": "Select subway line"
+        "description": "Enter your MTA Bus Time API key to enable bus tracking. Leave blank if you only want to track subways."
+      }
+    }
+  },
+  "config_subentries": {
+    "bus": {
+      "abort": {
+        "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
+        "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
+      },
+      "entry_type": "Bus stop",
+      "error": {
+        "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+        "invalid_route": "Invalid bus route. Please check the route name and try again."
+      },
+      "initiate_flow": {
+        "user": "Add bus stop"
+      },
+      "step": {
+        "stop": {
+          "data": {
+            "stop_id": "Stop"
+          },
+          "data_description": {
+            "stop_id": "Select the stop you want to track"
+          },
+          "description": "Choose a stop on the {route} route.",
+          "title": "Select stop"
+        },
+        "user": {
+          "data": {
+            "route": "Route"
+          },
+          "data_description": {
+            "route": "The bus route identifier"
+          },
+          "description": "Enter the bus route you want to track (for example, M15, B46, Q10).",
+          "title": "Enter bus route"
+        }
+      }
+    },
+    "subway": {
+      "abort": {
+        "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
+        "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+        "no_stops": "No stops found for this line. The line may not be currently running."
+      },
+      "entry_type": "Subway stop",
+      "error": {
+        "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"
+      },
+      "initiate_flow": {
+        "user": "Add subway stop"
+      },
+      "step": {
+        "stop": {
+          "data": {
+            "stop_id": "Stop and direction"
+          },
+          "data_description": {
+            "stop_id": "Select the stop and direction you want to track"
+          },
+          "description": "Choose a stop on the {line} line. The direction is included with each stop.",
+          "title": "Select stop and direction"
+        },
+        "user": {
+          "data": {
+            "line": "Line"
+          },
+          "data_description": {
+            "line": "The subway line to track"
+          },
+          "description": "Choose the subway line you want to track.",
+          "title": "Select subway line"
+        }
       }
     }
   },

homeassistant/components/ntfy/icons.json

@@ -81,6 +81,9 @@
       "service": "mdi:comment-remove"
     },
     "publish": {
+      "sections": {
+        "actions": "mdi:gesture-tap-button"
+      },
       "service": "mdi:send"
     }
   }

homeassistant/components/ntfy/notify.py

@@ -27,7 +27,14 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .const import DOMAIN
 from .coordinator import NtfyConfigEntry
 from .entity import NtfyBaseEntity
-from .services import ATTR_ATTACH_FILE, ATTR_FILENAME, ATTR_SEQUENCE_ID
+from .services import (
+    ACTIONS_MAP,
+    ATTR_ACTION,
+    ATTR_ACTIONS,
+    ATTR_ATTACH_FILE,
+    ATTR_FILENAME,
+    ATTR_SEQUENCE_ID,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -105,6 +112,15 @@ class NtfyNotifyEntity(NtfyBaseEntity, NotifyEntity):
 
                 params.setdefault(ATTR_FILENAME, media.path.name)
 
+        actions: list[dict[str, Any]] | None = params.get(ATTR_ACTIONS)
+        if actions:
+            params["actions"] = [
+                ACTIONS_MAP[action[ATTR_ACTION]](
+                    **{k: v for k, v in action.items() if k != ATTR_ACTION}
+                )
+                for action in actions
+            ]
+
         msg = Message(topic=self.topic, **params)
         try:
             await self.ntfy.publish(msg, attachment)

homeassistant/components/ntfy/services.py

@@ -3,6 +3,7 @@
 from datetime import timedelta
 from typing import Any
 
+from aiontfy import BroadcastAction, CopyAction, HttpAction, ViewAction
 import voluptuous as vol
 from yarl import URL
 
@@ -34,6 +35,28 @@ ATTR_ATTACH_FILE = "attach_file"
 ATTR_FILENAME = "filename"
 GRP_ATTACHMENT = "attachment"
 MSG_ATTACHMENT = "Only one attachment source is allowed: URL or local file"
+ATTR_ACTIONS = "actions"
+ATTR_ACTION = "action"
+ATTR_VIEW = "view"
+ATTR_BROADCAST = "broadcast"
+ATTR_HTTP = "http"
+ATTR_LABEL = "label"
+ATTR_URL = "url"
+ATTR_CLEAR = "clear"
+ATTR_INTENT = "intent"
+ATTR_EXTRAS = "extras"
+ATTR_METHOD = "method"
+ATTR_HEADERS = "headers"
+ATTR_BODY = "body"
+ATTR_VALUE = "value"
+ATTR_COPY = "copy"
+ACTIONS_MAP = {
+    ATTR_VIEW: ViewAction,
+    ATTR_BROADCAST: BroadcastAction,
+    ATTR_HTTP: HttpAction,
+    ATTR_COPY: CopyAction,
+}
+MAX_ACTIONS_ALLOWED = 3  # ntfy only supports up to 3 actions per notification
 
 
 def validate_filename(params: dict[str, Any]) -> dict[str, Any]:
@@ -45,6 +68,40 @@ def validate_filename(params: dict[str, Any]) -> dict[str, Any]:
     return params
 
 
+ACTION_SCHEMA = vol.Schema(
+    {
+        vol.Required(ATTR_LABEL): cv.string,
+        vol.Optional(ATTR_CLEAR, default=False): cv.boolean,
+    }
+)
+VIEW_SCHEMA = ACTION_SCHEMA.extend(
+    {
+        vol.Required(ATTR_ACTION): vol.Equal("view"),
+        vol.Required(ATTR_URL): vol.All(vol.Url(), vol.Coerce(URL)),
+    }
+)
+BROADCAST_SCHEMA = ACTION_SCHEMA.extend(
+    {
+        vol.Required(ATTR_ACTION): vol.Equal("broadcast"),
+        vol.Optional(ATTR_INTENT): cv.string,
+        vol.Optional(ATTR_EXTRAS): dict[str, str],
+    }
+)
+HTTP_SCHEMA = VIEW_SCHEMA.extend(
+    {
+        vol.Required(ATTR_ACTION): vol.Equal("http"),
+        vol.Optional(ATTR_METHOD): cv.string,
+        vol.Optional(ATTR_HEADERS): dict[str, str],
+        vol.Optional(ATTR_BODY): cv.string,
+    }
+)
+COPY_SCHEMA = ACTION_SCHEMA.extend(
+    {
+        vol.Required(ATTR_ACTION): vol.Equal("copy"),
+        vol.Required(ATTR_VALUE): cv.string,
+    }
+)
+
 SERVICE_PUBLISH_SCHEMA = vol.All(
     cv.make_entity_service_schema(
         {
@@ -69,6 +126,14 @@ SERVICE_PUBLISH_SCHEMA = vol.All(
                 ATTR_ATTACH_FILE, GRP_ATTACHMENT, MSG_ATTACHMENT
             ): MediaSelector({"accept": ["*/*"]}),
             vol.Optional(ATTR_FILENAME): cv.string,
+            vol.Optional(ATTR_ACTIONS): vol.All(
+                cv.ensure_list,
+                vol.Length(
+                    max=MAX_ACTIONS_ALLOWED,
+                    msg="Too many actions defined. A maximum of 3 is supported",
+                ),
+                [vol.Any(VIEW_SCHEMA, BROADCAST_SCHEMA, HTTP_SCHEMA, COPY_SCHEMA)],
+            ),
         }
     ),
     validate_filename,

homeassistant/components/ntfy/services.yaml

@@ -99,6 +99,65 @@ publish:
           type: url
           autocomplete: url
       example: https://example.org/logo.png
+    actions:
+      selector:
+        object:
+          label_field: "label"
+          description_field: "url"
+          multiple: true
+          translation_key: actions
+          fields:
+            action:
+              required: true
+              selector:
+                select:
+                  options:
+                    - value: view
+                      label: Open website/app
+                    - value: http
+                      label: Send HTTP request
+                    - value: broadcast
+                      label: Send Android broadcast
+                    - value: copy
+                      label: Copy to clipboard
+                  translation_key: action_type
+                  mode: dropdown
+            label:
+              selector:
+                text:
+              required: true
+            clear:
+              selector:
+                boolean:
+            url:
+              selector:
+                text:
+                  type: url
+            method:
+              selector:
+                select:
+                  options:
+                    - GET
+                    - POST
+                    - PUT
+                    - DELETE
+                  custom_value: true
+            headers:
+              selector:
+                object:
+            body:
+              selector:
+                text:
+                  multiline: true
+            intent:
+              selector:
+                text:
+            extras:
+              selector:
+                object:
+            value:
+              selector:
+                text:
     sequence_id:
       required: false
       selector:

homeassistant/components/ntfy/strings.json

@@ -318,6 +318,50 @@
     }
   },
   "selector": {
+    "actions": {
+      "fields": {
+        "action": {
+          "description": "Select the type of action to add to the notification",
+          "name": "Action type"
+        },
+        "body": {
+          "description": "The body of the HTTP request for `http` actions.",
+          "name": "HTTP body"
+        },
+        "clear": {
+          "description": "Clear notification after action button is tapped",
+          "name": "Clear notification"
+        },
+        "extras": {
+          "description": "Extras to include in the intent as key-value pairs for 'broadcast' actions",
+          "name": "Intent extras"
+        },
+        "headers": {
+          "description": "Additional HTTP headers as key-value pairs for 'http' actions",
+          "name": "HTTP headers"
+        },
+        "intent": {
+          "description": "Android intent to send when the 'broadcast' action is triggered",
+          "name": "Intent"
+        },
+        "label": {
+          "description": "Label of the action button",
+          "name": "Label"
+        },
+        "method": {
+          "description": "HTTP method to use for the 'http' action",
+          "name": "HTTP method"
+        },
+        "url": {
+          "description": "URL to open for the 'view' action or to request for the 'http' action",
+          "name": "URL"
+        },
+        "value": {
+          "description": "Value to copy to clipboard when the 'copy' action is triggered",
+          "name": "Value"
+        }
+      }
+    },
     "priority": {
       "options": {
         "1": "Minimum",
@@ -350,8 +394,12 @@
       "name": "Delete notification"
     },
     "publish": {
-      "description": "Publishes a notification message to a ntfy topic",
+      "description": "Publishes a notification message to a ntfy topic.",
       "fields": {
+        "actions": {
+          "description": "Up to three actions (`view`, `broadcast`, `http`, or `copy`) can be added as buttons below the notification. Actions are executed when the corresponding button is tapped or clicked.",
+          "name": "Action buttons"
+        },
         "attach": {
           "description": "Attach images or other files by URL.",
           "name": "Attachment URL"

homeassistant/components/portainer/quality_scale.yaml

@@ -30,11 +30,8 @@ rules:
   entity-unavailable: done
   integration-owner: done
   log-when-unavailable: done
-  parallel-updates: todo
-  reauthentication-flow:
-    status: todo
-    comment: |
-      No reauthentication flow is defined. It will be done in a next iteration.
+  parallel-updates: done
+  reauthentication-flow: done
   test-coverage: done
   # Gold
   devices: done
@@ -47,25 +44,27 @@ rules:
     status: exempt
     comment: |
       No discovery is implemented, since it's software based.
-  docs-data-update: todo
-  docs-examples: todo
-  docs-known-limitations: todo
-  docs-supported-devices: todo
-  docs-supported-functions: todo
-  docs-troubleshooting: todo
-  docs-use-cases: todo
-  dynamic-devices: todo
-  entity-category: todo
-  entity-device-class: todo
-  entity-disabled-by-default: todo
-  entity-translations: todo
-  exception-translations: todo
-  icon-translations: todo
+  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: done
+  entity-translations: done
+  exception-translations: done
+  icon-translations: done
   reconfiguration-flow: done
-  repair-issues: todo
-  stale-devices: todo
-
+  repair-issues:
+    status: exempt
+    comment: |
+      No repair issues are implemented, currently.
+  stale-devices: done
   # Platinum
-  async-dependency: todo
+  async-dependency: done
   inject-websession: done
   strict-typing: done

homeassistant/components/powerfox/manifest.json

@@ -1,6 +1,6 @@
 {
   "domain": "powerfox",
-  "name": "Powerfox",
+  "name": "Powerfox Cloud",
   "codeowners": ["@klaasnicolaas"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/powerfox",

homeassistant/components/proxmoxve/__init__.py

@@ -37,7 +37,10 @@ from .const import (
 )
 from .coordinator import ProxmoxConfigEntry, ProxmoxCoordinator
 
-PLATFORMS = [Platform.BINARY_SENSOR]
+PLATFORMS = [
+    Platform.BINARY_SENSOR,
+    Platform.BUTTON,
+]
 
 
 CONFIG_SCHEMA = vol.Schema(

homeassistant/components/proxmoxve/button.py

@@ -0,0 +1,339 @@
+"""Button platform for Proxmox VE."""
+
+from __future__ import annotations
+
+from abc import abstractmethod
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+
+from proxmoxer import AuthenticationError
+from proxmoxer.core import ResourceException
+import requests
+from requests.exceptions import ConnectTimeout, SSLError
+
+from homeassistant.components.button import (
+    ButtonDeviceClass,
+    ButtonEntity,
+    ButtonEntityDescription,
+)
+from homeassistant.const import EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .const import DOMAIN
+from .coordinator import ProxmoxConfigEntry, ProxmoxCoordinator, ProxmoxNodeData
+from .entity import ProxmoxContainerEntity, ProxmoxNodeEntity, ProxmoxVMEntity
+
+
+@dataclass(frozen=True, kw_only=True)
+class ProxmoxNodeButtonNodeEntityDescription(ButtonEntityDescription):
+    """Class to hold Proxmox node button description."""
+
+    press_action: Callable[[ProxmoxCoordinator, str], None]
+
+
+@dataclass(frozen=True, kw_only=True)
+class ProxmoxVMButtonEntityDescription(ButtonEntityDescription):
+    """Class to hold Proxmox VM button description."""
+
+    press_action: Callable[[ProxmoxCoordinator, str, int], None]
+
+
+@dataclass(frozen=True, kw_only=True)
+class ProxmoxContainerButtonEntityDescription(ButtonEntityDescription):
+    """Class to hold Proxmox container button description."""
+
+    press_action: Callable[[ProxmoxCoordinator, str, int], None]
+
+
+NODE_BUTTONS: tuple[ProxmoxNodeButtonNodeEntityDescription, ...] = (
+    ProxmoxNodeButtonNodeEntityDescription(
+        key="reboot",
+        press_action=lambda coordinator, node: coordinator.proxmox.nodes(
+            node
+        ).status.post(command="reboot"),
+        entity_category=EntityCategory.CONFIG,
+        device_class=ButtonDeviceClass.RESTART,
+    ),
+    ProxmoxNodeButtonNodeEntityDescription(
+        key="shutdown",
+        translation_key="shutdown",
+        press_action=lambda coordinator, node: coordinator.proxmox.nodes(
+            node
+        ).status.post(command="shutdown"),
+        entity_category=EntityCategory.CONFIG,
+    ),
+    ProxmoxNodeButtonNodeEntityDescription(
+        key="start_all",
+        translation_key="start_all",
+        press_action=lambda coordinator, node: coordinator.proxmox.nodes(
+            node
+        ).startall.post(),
+        entity_category=EntityCategory.CONFIG,
+    ),
+    ProxmoxNodeButtonNodeEntityDescription(
+        key="stop_all",
+        translation_key="stop_all",
+        press_action=lambda coordinator, node: coordinator.proxmox.nodes(
+            node
+        ).stopall.post(),
+        entity_category=EntityCategory.CONFIG,
+    ),
+)
+
+VM_BUTTONS: tuple[ProxmoxVMButtonEntityDescription, ...] = (
+    ProxmoxVMButtonEntityDescription(
+        key="start",
+        translation_key="start",
+        press_action=lambda coordinator, node, vmid: (
+            coordinator.proxmox.nodes(node).qemu(vmid).status.start.post()
+        ),
+        entity_category=EntityCategory.CONFIG,
+    ),
+    ProxmoxVMButtonEntityDescription(
+        key="stop",
+        translation_key="stop",
+        press_action=lambda coordinator, node, vmid: (
+            coordinator.proxmox.nodes(node).qemu(vmid).status.stop.post()
+        ),
+        entity_category=EntityCategory.CONFIG,
+    ),
+    ProxmoxVMButtonEntityDescription(
+        key="restart",
+        press_action=lambda coordinator, node, vmid: (
+            coordinator.proxmox.nodes(node).qemu(vmid).status.restart.post()
+        ),
+        entity_category=EntityCategory.CONFIG,
+        device_class=ButtonDeviceClass.RESTART,
+    ),
+    ProxmoxVMButtonEntityDescription(
+        key="hibernate",
+        translation_key="hibernate",
+        press_action=lambda coordinator, node, vmid: (
+            coordinator.proxmox.nodes(node).qemu(vmid).status.hibernate.post()
+        ),
+        entity_category=EntityCategory.CONFIG,
+    ),
+    ProxmoxVMButtonEntityDescription(
+        key="reset",
+        translation_key="reset",
+        press_action=lambda coordinator, node, vmid: (
+            coordinator.proxmox.nodes(node).qemu(vmid).status.reset.post()
+        ),
+        entity_category=EntityCategory.CONFIG,
+    ),
+)
+
+CONTAINER_BUTTONS: tuple[ProxmoxContainerButtonEntityDescription, ...] = (
+    ProxmoxContainerButtonEntityDescription(
+        key="start",
+        translation_key="start",
+        press_action=lambda coordinator, node, vmid: (
+            coordinator.proxmox.nodes(node).lxc(vmid).status.start.post()
+        ),
+        entity_category=EntityCategory.CONFIG,
+    ),
+    ProxmoxContainerButtonEntityDescription(
+        key="stop",
+        translation_key="stop",
+        press_action=lambda coordinator, node, vmid: (
+            coordinator.proxmox.nodes(node).lxc(vmid).status.stop.post()
+        ),
+        entity_category=EntityCategory.CONFIG,
+    ),
+    ProxmoxContainerButtonEntityDescription(
+        key="restart",
+        press_action=lambda coordinator, node, vmid: (
+            coordinator.proxmox.nodes(node).lxc(vmid).status.restart.post()
+        ),
+        entity_category=EntityCategory.CONFIG,
+        device_class=ButtonDeviceClass.RESTART,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: ProxmoxConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up ProxmoxVE buttons."""
+    coordinator = entry.runtime_data
+
+    def _async_add_new_nodes(nodes: list[ProxmoxNodeData]) -> None:
+        """Add new node buttons."""
+        async_add_entities(
+            ProxmoxNodeButtonEntity(coordinator, entity_description, node)
+            for node in nodes
+            for entity_description in NODE_BUTTONS
+        )
+
+    def _async_add_new_vms(
+        vms: list[tuple[ProxmoxNodeData, dict[str, Any]]],
+    ) -> None:
+        """Add new VM buttons."""
+        async_add_entities(
+            ProxmoxVMButtonEntity(coordinator, entity_description, vm, node_data)
+            for (node_data, vm) in vms
+            for entity_description in VM_BUTTONS
+        )
+
+    def _async_add_new_containers(
+        containers: list[tuple[ProxmoxNodeData, dict[str, Any]]],
+    ) -> None:
+        """Add new container buttons."""
+        async_add_entities(
+            ProxmoxContainerButtonEntity(
+                coordinator, entity_description, container, node_data
+            )
+            for (node_data, container) in containers
+            for entity_description in CONTAINER_BUTTONS
+        )
+
+    coordinator.new_nodes_callbacks.append(_async_add_new_nodes)
+    coordinator.new_vms_callbacks.append(_async_add_new_vms)
+    coordinator.new_containers_callbacks.append(_async_add_new_containers)
+
+    _async_add_new_nodes(
+        [
+            node_data
+            for node_data in coordinator.data.values()
+            if node_data.node["node"] in coordinator.known_nodes
+        ]
+    )
+    _async_add_new_vms(
+        [
+            (node_data, vm_data)
+            for node_data in coordinator.data.values()
+            for vmid, vm_data in node_data.vms.items()
+            if (node_data.node["node"], vmid) in coordinator.known_vms
+        ]
+    )
+    _async_add_new_containers(
+        [
+            (node_data, container_data)
+            for node_data in coordinator.data.values()
+            for vmid, container_data in node_data.containers.items()
+            if (node_data.node["node"], vmid) in coordinator.known_containers
+        ]
+    )
+
+
+class ProxmoxBaseButton(ButtonEntity):
+    """Common base for Proxmox buttons. Basically to ensure the async_press logic isn't duplicated."""
+
+    entity_description: ButtonEntityDescription
+    coordinator: ProxmoxCoordinator
+
+    @abstractmethod
+    async def _async_press_call(self) -> None:
+        """Abstract method used per Proxmox button class."""
+
+    async def async_press(self) -> None:
+        """Trigger the Proxmox button press service."""
+        try:
+            await self._async_press_call()
+        except AuthenticationError as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="cannot_connect_no_details",
+            ) from err
+        except SSLError as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="invalid_auth_no_details",
+            ) from err
+        except ConnectTimeout as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="timeout_connect_no_details",
+            ) from err
+        except (ResourceException, requests.exceptions.ConnectionError) as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="api_error_no_details",
+            ) from err
+
+
+class ProxmoxNodeButtonEntity(ProxmoxNodeEntity, ProxmoxBaseButton):
+    """Represents a Proxmox Node button entity."""
+
+    entity_description: ProxmoxNodeButtonNodeEntityDescription
+
+    def __init__(
+        self,
+        coordinator: ProxmoxCoordinator,
+        entity_description: ProxmoxNodeButtonNodeEntityDescription,
+        node_data: ProxmoxNodeData,
+    ) -> None:
+        """Initialize the Proxmox Node button entity."""
+        self.entity_description = entity_description
+        super().__init__(coordinator, node_data)
+
+        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{node_data.node['id']}_{entity_description.key}"
+
+    async def _async_press_call(self) -> None:
+        """Execute the node button action via executor."""
+        await self.hass.async_add_executor_job(
+            self.entity_description.press_action,
+            self.coordinator,
+            self._node_data.node["node"],
+        )
+
+
+class ProxmoxVMButtonEntity(ProxmoxVMEntity, ProxmoxBaseButton):
+    """Represents a Proxmox VM button entity."""
+
+    entity_description: ProxmoxVMButtonEntityDescription
+
+    def __init__(
+        self,
+        coordinator: ProxmoxCoordinator,
+        entity_description: ProxmoxVMButtonEntityDescription,
+        vm_data: dict[str, Any],
+        node_data: ProxmoxNodeData,
+    ) -> None:
+        """Initialize the Proxmox VM button entity."""
+        self.entity_description = entity_description
+        super().__init__(coordinator, vm_data, node_data)
+
+        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{self.device_id}_{entity_description.key}"
+
+    async def _async_press_call(self) -> None:
+        """Execute the VM button action via executor."""
+        await self.hass.async_add_executor_job(
+            self.entity_description.press_action,
+            self.coordinator,
+            self._node_name,
+            self.vm_data["vmid"],
+        )
+
+
+class ProxmoxContainerButtonEntity(ProxmoxContainerEntity, ProxmoxBaseButton):
+    """Represents a Proxmox Container button entity."""
+
+    entity_description: ProxmoxContainerButtonEntityDescription
+
+    def __init__(
+        self,
+        coordinator: ProxmoxCoordinator,
+        entity_description: ProxmoxContainerButtonEntityDescription,
+        container_data: dict[str, Any],
+        node_data: ProxmoxNodeData,
+    ) -> None:
+        """Initialize the Proxmox Container button entity."""
+        self.entity_description = entity_description
+        super().__init__(coordinator, container_data, node_data)
+
+        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{self.device_id}_{entity_description.key}"
+
+    async def _async_press_call(self) -> None:
+        """Execute the container button action via executor."""
+        await self.hass.async_add_executor_job(
+            self.entity_description.press_action,
+            self.coordinator,
+            self._node_name,
+            self.container_data["vmid"],
+        )

homeassistant/components/proxmoxve/icons.json

@@ -0,0 +1,18 @@
+{
+  "entity": {
+    "button": {
+      "hibernate": {
+        "default": "mdi:power-sleep"
+      },
+      "reset": {
+        "default": "mdi:restart"
+      },
+      "start": {
+        "default": "mdi:play"
+      },
+      "stop": {
+        "default": "mdi:stop"
+      }
+    }
+  }
+}

homeassistant/components/proxmoxve/strings.json

@@ -54,15 +54,47 @@
       "status": {
         "name": "Status"
       }
+    },
+    "button": {
+      "hibernate": {
+        "name": "Hibernate"
+      },
+      "reset": {
+        "name": "Reset"
+      },
+      "shutdown": {
+        "name": "Shutdown"
+      },
+      "start": {
+        "name": "Start"
+      },
+      "start_all": {
+        "name": "Start all"
+      },
+      "stop": {
+        "name": "Stop"
+      },
+      "stop_all": {
+        "name": "Stop all"
+      }
     }
   },
   "exceptions": {
+    "api_error_no_details": {
+      "message": "An error occurred while communicating with the Proxmox VE instance."
+    },
     "cannot_connect": {
       "message": "An error occurred while trying to connect to the Proxmox VE instance: {error}"
     },
+    "cannot_connect_no_details": {
+      "message": "Could not connect to the Proxmox VE instance."
+    },
     "invalid_auth": {
       "message": "An error occurred while trying to authenticate: {error}"
     },
+    "invalid_auth_no_details": {
+      "message": "Authentication failed for the Proxmox VE instance."
+    },
     "no_nodes_found": {
       "message": "No active nodes were found on the Proxmox VE server."
     },
@@ -71,6 +103,9 @@
     },
     "timeout_connect": {
       "message": "A timeout occurred while trying to connect to the Proxmox VE instance: {error}"
+    },
+    "timeout_connect_no_details": {
+      "message": "A timeout occurred while trying to connect to the Proxmox VE instance."
     }
   },
   "issues": {

homeassistant/components/satel_integra/coordinator.py

@@ -9,6 +9,7 @@ from satel_integra.satel_integra import AlarmState
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.debounce import Debouncer
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
 from .client import SatelClient
@@ -16,6 +17,8 @@ from .const import ZONES
 
 _LOGGER = logging.getLogger(__name__)
 
+PARTITION_UPDATE_DEBOUNCE_DELAY = 0.15
+
 
 @dataclass
 class SatelIntegraData:
@@ -106,9 +109,21 @@ class SatelIntegraPartitionsCoordinator(
 
         self.data = {}
 
+        self._debouncer = Debouncer(
+            hass=self.hass,
+            logger=_LOGGER,
+            cooldown=PARTITION_UPDATE_DEBOUNCE_DELAY,
+            immediate=False,
+            function=callback(
+                lambda: self.async_set_updated_data(
+                    self.client.controller.partition_states
+                )
+            ),
+        )
+
     @callback
     def partitions_update_callback(self) -> None:
         """Update partition objects as per notification from the alarm."""
         _LOGGER.debug("Sending request to update panel state")
 
-        self.async_set_updated_data(self.client.controller.partition_states)
+        self._debouncer.async_schedule_call()

homeassistant/components/splunk/manifest.json

@@ -7,7 +7,7 @@
   "integration_type": "service",
   "iot_class": "local_push",
   "loggers": ["hass_splunk"],
-  "quality_scale": "legacy",
+  "quality_scale": "bronze",
   "requirements": ["hass-splunk==0.1.4"],
   "single_config_entry": true
 }

homeassistant/components/splunk/quality_scale.yaml

@@ -18,18 +18,9 @@ rules:
     status: exempt
     comment: |
       Integration does not provide custom actions.
-  docs-high-level-description:
-    status: todo
-    comment: |
-      Verify integration docs at https://www.home-assistant.io/integrations/splunk/ include a high-level description of Splunk with a link to https://www.splunk.com/ and explain the integration's purpose for users unfamiliar with Splunk.
-  docs-installation-instructions:
-    status: todo
-    comment: |
-      Verify integration docs include clear prerequisites and step-by-step setup instructions including how to configure Splunk HTTP Event Collector and obtain the required token.
-  docs-removal-instructions:
-    status: todo
-    comment: |
-      Verify integration docs include instructions on how to remove the integration and clarify what happens to data already in Splunk.
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
   entity-event-setup:
     status: exempt
     comment: |

homeassistant/components/telegram_bot/bot.py

@@ -2,7 +2,7 @@
 
 from abc import abstractmethod
 import asyncio
-from collections.abc import Callable, Sequence
+from collections.abc import Awaitable, Callable, Sequence
 import io
 import logging
 import os
@@ -430,48 +430,35 @@ class TelegramNotificationService:
             params[ATTR_PARSER] = None
         return params
 
-    async def _send_msgs(
+    async def _send_msg_formatted(
         self,
-        func_send: Callable,
+        func_send: Callable[..., Awaitable[Message]],
         message_tag: str | None,
         *args_msg: Any,
         context: Context | None = None,
         **kwargs_msg: Any,
     ) -> dict[str, JsonValueType]:
-        """Sends a message to each of the targets.
-
-        If there is only 1 targtet, an error is raised if the send fails.
-        For multiple targets, errors are logged and the caller is responsible for checking which target is successful/failed based on the return value.
+        """Sends a message and formats the response.
 
         :return: dict with chat_id keys and message_id values for successful sends
         """
-        chat_ids = [kwargs_msg.pop(ATTR_CHAT_ID)]
-        msg_ids: dict[str, JsonValueType] = {}
-        for chat_id in chat_ids:
-            _LOGGER.debug("%s to chat ID %s", func_send.__name__, chat_id)
+        chat_id: int = kwargs_msg.pop(ATTR_CHAT_ID)
+        _LOGGER.debug("%s to chat ID %s", func_send.__name__, chat_id)
 
-            for file_type in _FILE_TYPES:
-                if file_type in kwargs_msg and isinstance(
-                    kwargs_msg[file_type], io.BytesIO
-                ):
-                    kwargs_msg[file_type].seek(0)
+        response: Message = await self._send_msg(
+            func_send,
+            message_tag,
+            chat_id,
+            *args_msg,
+            context=context,
+            **kwargs_msg,
+        )
 
-            response: Message = await self._send_msg(
-                func_send,
-                message_tag,
-                chat_id,
-                *args_msg,
-                context=context,
-                **kwargs_msg,
-            )
-            if response:
-                msg_ids[str(chat_id)] = response.id
-
-        return msg_ids
+        return {str(chat_id): response.id}
 
     async def _send_msg(
         self,
-        func_send: Callable,
+        func_send: Callable[..., Awaitable[Any]],
         message_tag: str | None,
         *args_msg: Any,
         context: Context | None = None,
@@ -518,7 +505,7 @@ class TelegramNotificationService:
         title = kwargs.get(ATTR_TITLE)
         text = f"{title}\n{message}" if title else message
         params = self._get_msg_kwargs(kwargs)
-        return await self._send_msgs(
+        return await self._send_msg_formatted(
             self.bot.send_message,
             params[ATTR_MESSAGE_TAG],
             text,
@@ -759,7 +746,7 @@ class TelegramNotificationService:
         )
 
         if file_type == SERVICE_SEND_PHOTO:
-            return await self._send_msgs(
+            return await self._send_msg_formatted(
                 self.bot.send_photo,
                 params[ATTR_MESSAGE_TAG],
                 chat_id=kwargs[ATTR_CHAT_ID],
@@ -775,7 +762,7 @@ class TelegramNotificationService:
             )
 
         if file_type == SERVICE_SEND_STICKER:
-            return await self._send_msgs(
+            return await self._send_msg_formatted(
                 self.bot.send_sticker,
                 params[ATTR_MESSAGE_TAG],
                 chat_id=kwargs[ATTR_CHAT_ID],
@@ -789,7 +776,7 @@ class TelegramNotificationService:
             )
 
         if file_type == SERVICE_SEND_VIDEO:
-            return await self._send_msgs(
+            return await self._send_msg_formatted(
                 self.bot.send_video,
                 params[ATTR_MESSAGE_TAG],
                 chat_id=kwargs[ATTR_CHAT_ID],
@@ -805,7 +792,7 @@ class TelegramNotificationService:
             )
 
         if file_type == SERVICE_SEND_DOCUMENT:
-            return await self._send_msgs(
+            return await self._send_msg_formatted(
                 self.bot.send_document,
                 params[ATTR_MESSAGE_TAG],
                 chat_id=kwargs[ATTR_CHAT_ID],
@@ -821,7 +808,7 @@ class TelegramNotificationService:
             )
 
         if file_type == SERVICE_SEND_VOICE:
-            return await self._send_msgs(
+            return await self._send_msg_formatted(
                 self.bot.send_voice,
                 params[ATTR_MESSAGE_TAG],
                 chat_id=kwargs[ATTR_CHAT_ID],
@@ -836,7 +823,7 @@ class TelegramNotificationService:
             )
 
         # SERVICE_SEND_ANIMATION
-        return await self._send_msgs(
+        return await self._send_msg_formatted(
             self.bot.send_animation,
             params[ATTR_MESSAGE_TAG],
             chat_id=kwargs[ATTR_CHAT_ID],
@@ -861,7 +848,7 @@ class TelegramNotificationService:
         stickerid = kwargs.get(ATTR_STICKER_ID)
 
         if stickerid:
-            return await self._send_msgs(
+            return await self._send_msg_formatted(
                 self.bot.send_sticker,
                 params[ATTR_MESSAGE_TAG],
                 chat_id=kwargs[ATTR_CHAT_ID],
@@ -886,7 +873,7 @@ class TelegramNotificationService:
         latitude = float(latitude)
         longitude = float(longitude)
         params = self._get_msg_kwargs(kwargs)
-        return await self._send_msgs(
+        return await self._send_msg_formatted(
             self.bot.send_location,
             params[ATTR_MESSAGE_TAG],
             chat_id=kwargs[ATTR_CHAT_ID],
@@ -911,7 +898,7 @@ class TelegramNotificationService:
         """Send a poll."""
         params = self._get_msg_kwargs(kwargs)
         openperiod = kwargs.get(ATTR_OPEN_PERIOD)
-        return await self._send_msgs(
+        return await self._send_msg_formatted(
             self.bot.send_poll,
             params[ATTR_MESSAGE_TAG],
             chat_id=kwargs[ATTR_CHAT_ID],

homeassistant/components/xbox/manifest.json

@@ -12,6 +12,8 @@
   "documentation": "https://www.home-assistant.io/integrations/xbox",
   "integration_type": "hub",
   "iot_class": "cloud_polling",
+  "quality_scale": "platinum",
+
   "requirements": ["python-xbox==0.1.3"],
   "ssdp": [
     {

homeassistant/components/xbox/quality_scale.yaml

@@ -0,0 +1,74 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: has only entity actions
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: has only entity actions
+  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: done
+  config-entry-unloading: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: The integration has no configuration options
+  docs-installation-parameters:
+    status: exempt
+    comment: The integration has no installation parameters
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: done
+  reauthentication-flow: done
+  test-coverage: done
+
+  # Gold
+  devices: done
+  diagnostics: done
+  discovery-update-info:
+    status: exempt
+    comment: Discovery is only used to start/suggest the OAuth flow; there is no connection info to update
+  discovery: done
+  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: done
+  entity-translations: done
+  exception-translations: done
+  icon-translations: done
+  reconfiguration-flow:
+    status: exempt
+    comment: nothing to reconfigure
+  repair-issues:
+    status: exempt
+    comment: has no repairs
+  stale-devices: done
+
+  # Platinum
+  async-dependency: done
+  inject-websession: done
+  strict-typing: done

homeassistant/generated/dhcp.py

@@ -17,6 +17,10 @@ DHCP: Final[list[dict[str, str | bool]]] = [
         "domain": "airobot",
         "hostname": "airobot-thermostat-*",
     },
+    {
+        "domain": "airos",
+        "registered_devices": True,
+    },
     {
         "domain": "airthings",
         "hostname": "airthings-view",

homeassistant/generated/integrations.json

@@ -5302,7 +5302,7 @@
           "integration_type": "hub",
           "config_flow": true,
           "iot_class": "cloud_polling",
-          "name": "Powerfox"
+          "name": "Powerfox Cloud"
         },
         "powerfox_local": {
           "integration_type": "device",

homeassistant/generated/usb.py

@@ -4,6 +4,13 @@ To update, run python3 -m script.hassfest
 """
 
 USB = [
+    {
+        "description": "*usb 300*",
+        "domain": "enocean",
+        "manufacturer": "*enocean*",
+        "pid": "6001",
+        "vid": "0403",
+    },
     {
         "description": "*zbt-2*",
         "domain": "homeassistant_connect_zbt2",

homeassistant/helpers/selector.py

@@ -838,6 +838,7 @@ class DurationSelectorConfig(BaseSelectorConfig, total=False):
     """Class to represent a duration selector config."""
 
     enable_day: bool
+    enable_second: bool
     enable_millisecond: bool
     allow_negative: bool
 
@@ -853,6 +854,8 @@ class DurationSelector(Selector[DurationSelectorConfig]):
             # Enable day field in frontend. A selection with `days` set is allowed
             # even if `enable_day` is not set
             vol.Optional("enable_day"): cv.boolean,
+            # Enable seconds field in frontend.
+            vol.Optional("enable_second", default=True): cv.boolean,
             # Enable millisecond field in frontend.
             vol.Optional("enable_millisecond"): cv.boolean,
             # Allow negative durations.

requirements_all.txt

@@ -254,7 +254,7 @@ aioelectricitymaps==1.1.1
 aioemonitor==1.0.5
 
 # homeassistant.components.esphome
-aioesphomeapi==44.0.0
+aioesphomeapi==44.1.0
 
 # homeassistant.components.matrix
 # homeassistant.components.slack
@@ -509,7 +509,7 @@ anova-wifi==0.17.0
 anthemav==1.4.1
 
 # homeassistant.components.anthropic
-anthropic==0.78.0
+anthropic==0.83.0
 
 # homeassistant.components.mcp_server
 anyio==4.10.0
@@ -1452,7 +1452,7 @@ loqedAPI==2.1.10
 luftdaten==0.7.4
 
 # homeassistant.components.lunatone
-lunatone-rest-api-client==0.6.3
+lunatone-rest-api-client==0.7.0
 
 # homeassistant.components.lupusec
 lupupy==0.3.2
@@ -3326,7 +3326,7 @@ youless-api==2.2.0
 youtubeaio==2.1.1
 
 # homeassistant.components.media_extractor
-yt-dlp[default]==2026.02.04
+yt-dlp[default]==2026.02.21
 
 # homeassistant.components.zabbix
 zabbix-utils==2.0.3

requirements_test_all.txt

@@ -245,7 +245,7 @@ aioelectricitymaps==1.1.1
 aioemonitor==1.0.5
 
 # homeassistant.components.esphome
-aioesphomeapi==44.0.0
+aioesphomeapi==44.1.0
 
 # homeassistant.components.matrix
 # homeassistant.components.slack
@@ -485,7 +485,7 @@ anova-wifi==0.17.0
 anthemav==1.4.1
 
 # homeassistant.components.anthropic
-anthropic==0.78.0
+anthropic==0.83.0
 
 # homeassistant.components.mcp_server
 anyio==4.10.0
@@ -1271,7 +1271,7 @@ loqedAPI==2.1.10
 luftdaten==0.7.4
 
 # homeassistant.components.lunatone
-lunatone-rest-api-client==0.6.3
+lunatone-rest-api-client==0.7.0
 
 # homeassistant.components.lupusec
 lupupy==0.3.2
@@ -2799,7 +2799,7 @@ youless-api==2.2.0
 youtubeaio==2.1.1
 
 # homeassistant.components.media_extractor
-yt-dlp[default]==2026.02.04
+yt-dlp[default]==2026.02.21
 
 # homeassistant.components.zamg
 zamg==0.3.6

script/hassfest/quality_scale.py

@@ -449,7 +449,6 @@ INTEGRATIONS_WITHOUT_QUALITY_SCALE_FILE = [
     "hdmi_cec",
     "heatmiser",
     "here_travel_time",
-    "hikvision",
     "hikvisioncam",
     "hisense_aehw4a1",
     "history_stats",
@@ -1053,7 +1052,6 @@ INTEGRATIONS_WITHOUT_QUALITY_SCALE_FILE = [
     "wsdot",
     "wyoming",
     "x10",
-    "xbox",
     "xeoma",
     "xiaomi",
     "xiaomi_aqara",
@@ -1897,7 +1895,6 @@ INTEGRATIONS_WITHOUT_SCALE = [
     "spc",
     "speedtestdotnet",
     "spider",
-    "splunk",
     "spotify",
     "sql",
     "srp_energy",
@@ -2067,7 +2064,6 @@ INTEGRATIONS_WITHOUT_SCALE = [
     "wsdot",
     "wyoming",
     "x10",
-    "xbox",
     "xeoma",
     "xiaomi",
     "xiaomi_aqara",

tests/components/airos/test_config_flow.py

@@ -22,7 +22,7 @@ from homeassistant.components.airos.const import (
     MAC_ADDRESS,
     SECTION_ADVANCED_SETTINGS,
 )
-from homeassistant.config_entries import SOURCE_RECONFIGURE, SOURCE_USER
+from homeassistant.config_entries import SOURCE_DHCP, SOURCE_RECONFIGURE, SOURCE_USER
 from homeassistant.const import (
     CONF_HOST,
     CONF_PASSWORD,
@@ -32,6 +32,7 @@ from homeassistant.const import (
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
+from homeassistant.helpers.service_info.dhcp import DhcpServiceInfo
 
 from tests.common import MockConfigEntry
 
@@ -680,3 +681,72 @@ async def test_configure_device_flow_exceptions(
 
     assert result["type"] is FlowResultType.FORM
     assert result["errors"] == {"base": "cannot_connect"}
+
+
+async def test_dhcp_ip_changed_updates_entry(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+) -> None:
+    """DHCP event with new IP should update the config entry and reload."""
+    mock_config_entry.add_to_hass(hass)
+
+    macaddress = mock_config_entry.unique_id.lower().replace(":", "").replace("-", "")
+
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN,
+        context={"source": SOURCE_DHCP},
+        data=DhcpServiceInfo(
+            ip="1.1.1.2",
+            hostname="airos",
+            macaddress=macaddress,
+        ),
+    )
+
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "already_configured"
+
+    assert mock_config_entry.data[CONF_HOST] == "1.1.1.2"
+
+
+async def test_dhcp_mac_mismatch(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+) -> None:
+    """DHCP event with non-matching MAC should abort."""
+    mock_config_entry.add_to_hass(hass)
+
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN,
+        context={"source": SOURCE_DHCP},
+        data=DhcpServiceInfo(
+            ip="1.1.1.2",
+            hostname="airos",
+            macaddress="aabbccddeeff",
+        ),
+    )
+
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "unreachable"
+
+
+async def test_dhcp_ip_unchanged(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+) -> None:
+    """DHCP event with same IP should abort."""
+    mock_config_entry.add_to_hass(hass)
+
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN,
+        context={"source": SOURCE_DHCP},
+        data=DhcpServiceInfo(
+            ip=mock_config_entry.data[CONF_HOST],
+            hostname="airos",
+            macaddress=mock_config_entry.unique_id.lower()
+            .replace(":", "")
+            .replace("-", ""),
+        ),
+    )
+
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "already_configured"

tests/components/aladdin_connect/__init__.py

@@ -1 +1,12 @@
 """Tests for the Aladdin Connect Garage Door integration."""
+
+from homeassistant.core import HomeAssistant
+
+from tests.common import MockConfigEntry
+
+
+async def init_integration(hass: HomeAssistant, entry: MockConfigEntry) -> None:
+    """Set up the Aladdin Connect integration for testing."""
+    entry.add_to_hass(hass)
+    await hass.config_entries.async_setup(entry.entry_id)
+    await hass.async_block_till_done()

tests/components/aladdin_connect/conftest.py

@@ -1,5 +1,9 @@
 """Fixtures for aladdin_connect tests."""
 
+from collections.abc import Generator
+from time import time
+from unittest.mock import AsyncMock, patch
+
 import pytest
 
 from homeassistant.components.aladdin_connect import DOMAIN
@@ -27,6 +31,42 @@ async def setup_credentials(hass: HomeAssistant) -> None:
     )
 
 
+@pytest.fixture(autouse=True)
+def mock_aladdin_connect_api() -> Generator[AsyncMock]:
+    """Mock the AladdinConnectClient."""
+    mock_door = AsyncMock()
+    mock_door.device_id = "test_device_id"
+    mock_door.door_number = 1
+    mock_door.name = "Test Door"
+    mock_door.status = "closed"
+    mock_door.link_status = "connected"
+    mock_door.battery_level = 100
+    mock_door.unique_id = f"{mock_door.device_id}-{mock_door.door_number}"
+
+    with (
+        patch(
+            "homeassistant.components.aladdin_connect.AladdinConnectClient",
+            autospec=True,
+        ) as mock_client,
+        patch(
+            "homeassistant.components.aladdin_connect.config_flow.AladdinConnectClient",
+            new=mock_client,
+        ),
+    ):
+        client = mock_client.return_value
+        client.get_doors.return_value = [mock_door]
+        yield client
+
+
+@pytest.fixture
+def mock_setup_entry() -> AsyncMock:
+    """Fixture to mock setup entry."""
+    with patch(
+        "homeassistant.components.aladdin_connect.async_setup_entry", return_value=True
+    ):
+        yield
+
+
 @pytest.fixture
 def mock_config_entry() -> MockConfigEntry:
     """Define a mock config entry fixture."""
@@ -41,7 +81,7 @@ def mock_config_entry() -> MockConfigEntry:
                 "access_token": "old-token",
                 "refresh_token": "old-refresh-token",
                 "expires_in": 3600,
-                "expires_at": 1234567890,
+                "expires_at": time() + 3600,
             },
         },
         source="user",

tests/components/aladdin_connect/test_config_flow.py

@@ -1,6 +1,6 @@
 """Test the Aladdin Connect Garage Door config flow."""
 
-from unittest.mock import patch
+from unittest.mock import AsyncMock
 
 import pytest
 
@@ -43,7 +43,12 @@ async def access_token(hass: HomeAssistant) -> str:
     )
 
 
-@pytest.mark.usefixtures("current_request_with_host", "use_cloud")
+@pytest.mark.usefixtures(
+    "current_request_with_host",
+    "use_cloud",
+    "mock_setup_entry",
+    "mock_aladdin_connect_api",
+)
 async def test_full_flow(
     hass: HomeAssistant,
     hass_client_no_auth: ClientSessionGenerator,
@@ -83,10 +88,7 @@ async def test_full_flow(
         },
     )
 
-    with patch(
-        "homeassistant.components.aladdin_connect.async_setup_entry", return_value=True
-    ):
-        result = await hass.config_entries.flow.async_configure(result["flow_id"])
+    result = await hass.config_entries.flow.async_configure(result["flow_id"])
 
     assert result["type"] is FlowResultType.CREATE_ENTRY
     assert result["title"] == "Aladdin Connect"
@@ -103,7 +105,12 @@ async def test_full_flow(
     assert result["result"].unique_id == USER_ID
 
 
-@pytest.mark.usefixtures("current_request_with_host", "use_cloud")
+@pytest.mark.usefixtures(
+    "current_request_with_host",
+    "use_cloud",
+    "mock_setup_entry",
+    "mock_aladdin_connect_api",
+)
 async def test_full_dhcp_flow(
     hass: HomeAssistant,
     hass_client_no_auth: ClientSessionGenerator,
@@ -156,10 +163,7 @@ async def test_full_dhcp_flow(
         },
     )
 
-    with patch(
-        "homeassistant.components.aladdin_connect.async_setup_entry", return_value=True
-    ):
-        result = await hass.config_entries.flow.async_configure(result["flow_id"])
+    result = await hass.config_entries.flow.async_configure(result["flow_id"])
 
     assert result["type"] is FlowResultType.CREATE_ENTRY
     assert result["title"] == "Aladdin Connect"
@@ -176,7 +180,9 @@ async def test_full_dhcp_flow(
     assert result["result"].unique_id == USER_ID
 
 
-@pytest.mark.usefixtures("current_request_with_host", "use_cloud")
+@pytest.mark.usefixtures(
+    "current_request_with_host", "use_cloud", "mock_aladdin_connect_api"
+)
 async def test_duplicate_entry(
     hass: HomeAssistant,
     hass_client_no_auth: ClientSessionGenerator,
@@ -218,10 +224,7 @@ async def test_duplicate_entry(
         },
     )
 
-    with patch(
-        "homeassistant.components.aladdin_connect.async_setup_entry", return_value=True
-    ):
-        result = await hass.config_entries.flow.async_configure(result["flow_id"])
+    result = await hass.config_entries.flow.async_configure(result["flow_id"])
 
     assert result["type"] is FlowResultType.ABORT
     assert result["reason"] == "already_configured"
@@ -249,7 +252,12 @@ async def test_duplicate_dhcp_entry(
     assert result["reason"] == "already_configured"
 
 
-@pytest.mark.usefixtures("current_request_with_host", "use_cloud")
+@pytest.mark.usefixtures(
+    "current_request_with_host",
+    "use_cloud",
+    "mock_setup_entry",
+    "mock_aladdin_connect_api",
+)
 async def test_flow_reauth(
     hass: HomeAssistant,
     hass_client_no_auth: ClientSessionGenerator,
@@ -301,10 +309,7 @@ async def test_flow_reauth(
         },
     )
 
-    with patch(
-        "homeassistant.components.aladdin_connect.async_setup_entry", return_value=True
-    ):
-        result = await hass.config_entries.flow.async_configure(result["flow_id"])
+    result = await hass.config_entries.flow.async_configure(result["flow_id"])
 
     assert result["type"] is FlowResultType.ABORT
     assert result["reason"] == "reauth_successful"
@@ -312,7 +317,9 @@ async def test_flow_reauth(
     assert len(hass.config_entries.async_entries(DOMAIN)) == 1
 
 
-@pytest.mark.usefixtures("current_request_with_host", "use_cloud")
+@pytest.mark.usefixtures(
+    "current_request_with_host", "use_cloud", "mock_aladdin_connect_api"
+)
 async def test_flow_wrong_account_reauth(
     hass: HomeAssistant,
     hass_client_no_auth: ClientSessionGenerator,
@@ -412,3 +419,82 @@ async def test_reauthentication_no_cloud(
 
     assert result["type"] is FlowResultType.ABORT
     assert result["reason"] == "cloud_not_enabled"
+
+
+@pytest.mark.usefixtures("current_request_with_host", "use_cloud")
+async def test_flow_connection_error(
+    hass: HomeAssistant,
+    hass_client_no_auth: ClientSessionGenerator,
+    aioclient_mock: AiohttpClientMocker,
+    access_token: str,
+    mock_aladdin_connect_api: AsyncMock,
+) -> None:
+    """Test config flow aborts when API connection fails."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
+    )
+    state = config_entry_oauth2_flow._encode_jwt(
+        hass,
+        {
+            "flow_id": result["flow_id"],
+            "redirect_uri": "https://example.com/auth/external/callback",
+        },
+    )
+
+    client = await hass_client_no_auth()
+    resp = await client.get(f"/auth/external/callback?code=abcd&state={state}")
+    assert resp.status == 200
+
+    aioclient_mock.post(
+        OAUTH2_TOKEN,
+        json={
+            "refresh_token": "mock-refresh-token",
+            "access_token": access_token,
+            "type": "Bearer",
+            "expires_in": 60,
+        },
+    )
+
+    mock_aladdin_connect_api.get_doors.side_effect = Exception("Connection failed")
+    result = await hass.config_entries.flow.async_configure(result["flow_id"])
+
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "cannot_connect"
+
+
+@pytest.mark.usefixtures("current_request_with_host", "use_cloud")
+async def test_flow_invalid_token(
+    hass: HomeAssistant,
+    hass_client_no_auth: ClientSessionGenerator,
+    aioclient_mock: AiohttpClientMocker,
+) -> None:
+    """Test config flow aborts when JWT token is invalid."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
+    )
+    state = config_entry_oauth2_flow._encode_jwt(
+        hass,
+        {
+            "flow_id": result["flow_id"],
+            "redirect_uri": "https://example.com/auth/external/callback",
+        },
+    )
+
+    client = await hass_client_no_auth()
+    resp = await client.get(f"/auth/external/callback?code=abcd&state={state}")
+    assert resp.status == 200
+
+    aioclient_mock.post(
+        OAUTH2_TOKEN,
+        json={
+            "refresh_token": "mock-refresh-token",
+            "access_token": "not-a-valid-jwt-token",
+            "type": "Bearer",
+            "expires_in": 60,
+        },
+    )
+
+    result = await hass.config_entries.flow.async_configure(result["flow_id"])
+
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "oauth_error"

tests/components/aladdin_connect/test_init.py

@@ -1,116 +1,108 @@
 """Tests for the Aladdin Connect integration."""
 
+import http
 from unittest.mock import AsyncMock, patch
 
-from homeassistant.components.aladdin_connect.const import DOMAIN
+from aiohttp import ClientConnectionError, RequestInfo
+from aiohttp.client_exceptions import ClientResponseError
+import pytest
+
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.core import HomeAssistant
 
+from . import init_integration
+
 from tests.common import MockConfigEntry
 
 
-async def test_setup_entry(hass: HomeAssistant) -> None:
+async def test_setup_entry(
+    hass: HomeAssistant, mock_config_entry: MockConfigEntry
+) -> None:
     """Test a successful setup entry."""
-    config_entry = MockConfigEntry(
-        domain=DOMAIN,
-        data={
-            "token": {
-                "access_token": "test_token",
-                "refresh_token": "test_refresh_token",
-            }
-        },
-        unique_id="test_unique_id",
-    )
-    config_entry.add_to_hass(hass)
-
-    mock_door = AsyncMock()
-    mock_door.device_id = "test_device_id"
-    mock_door.door_number = 1
-    mock_door.name = "Test Door"
-    mock_door.status = "closed"
-    mock_door.link_status = "connected"
-    mock_door.battery_level = 100
-    mock_door.unique_id = f"{mock_door.device_id}-{mock_door.door_number}"
-
-    mock_client = AsyncMock()
-    mock_client.get_doors.return_value = [mock_door]
-
-    with (
-        patch(
-            "homeassistant.components.aladdin_connect.config_entry_oauth2_flow.async_get_config_entry_implementation",
-            return_value=AsyncMock(),
-        ),
-        patch(
-            "homeassistant.components.aladdin_connect.config_entry_oauth2_flow.OAuth2Session",
-            return_value=AsyncMock(),
-        ),
-        patch(
-            "homeassistant.components.aladdin_connect.AladdinConnectClient",
-            return_value=mock_client,
-        ),
-        patch(
-            "homeassistant.components.aladdin_connect.api.AsyncConfigEntryAuth",
-            return_value=AsyncMock(),
-        ),
-    ):
-        await hass.config_entries.async_setup(config_entry.entry_id)
-        await hass.async_block_till_done()
-
-    assert config_entry.state is ConfigEntryState.LOADED
+    await init_integration(hass, mock_config_entry)
+    assert mock_config_entry.state is ConfigEntryState.LOADED
 
 
-async def test_unload_entry(hass: HomeAssistant) -> None:
+async def test_unload_entry(
+    hass: HomeAssistant, mock_config_entry: MockConfigEntry
+) -> None:
     """Test a successful unload entry."""
-    config_entry = MockConfigEntry(
-        domain=DOMAIN,
-        data={
-            "token": {
-                "access_token": "test_token",
-                "refresh_token": "test_refresh_token",
-            }
-        },
-        unique_id="test_unique_id",
-    )
-    config_entry.add_to_hass(hass)
+    await init_integration(hass, mock_config_entry)
+    assert mock_config_entry.state is ConfigEntryState.LOADED
 
-    # Mock door data
-    mock_door = AsyncMock()
-    mock_door.device_id = "test_device_id"
-    mock_door.door_number = 1
-    mock_door.name = "Test Door"
-    mock_door.status = "closed"
-    mock_door.link_status = "connected"
-    mock_door.battery_level = 100
-    mock_door.unique_id = f"{mock_door.device_id}-{mock_door.door_number}"
+    await hass.config_entries.async_unload(mock_config_entry.entry_id)
+    await hass.async_block_till_done()
+    assert mock_config_entry.state is ConfigEntryState.NOT_LOADED
 
-    # Mock client
-    mock_client = AsyncMock()
-    mock_client.get_doors.return_value = [mock_door]
 
-    with (
-        patch(
-            "homeassistant.components.aladdin_connect.config_entry_oauth2_flow.async_get_config_entry_implementation",
-            return_value=AsyncMock(),
-        ),
-        patch(
-            "homeassistant.components.aladdin_connect.config_entry_oauth2_flow.OAuth2Session",
-            return_value=AsyncMock(),
-        ),
-        patch(
-            "homeassistant.components.aladdin_connect.AladdinConnectClient",
-            return_value=mock_client,
-        ),
-        patch(
-            "homeassistant.components.aladdin_connect.api.AsyncConfigEntryAuth",
-            return_value=AsyncMock(),
+@pytest.mark.parametrize(
+    ("status", "expected_state"),
+    [
+        (http.HTTPStatus.UNAUTHORIZED, ConfigEntryState.SETUP_ERROR),
+        (http.HTTPStatus.INTERNAL_SERVER_ERROR, ConfigEntryState.SETUP_RETRY),
+    ],
+    ids=["auth_failure", "server_error"],
+)
+async def test_setup_entry_token_error(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    status: http.HTTPStatus,
+    expected_state: ConfigEntryState,
+) -> None:
+    """Test setup entry fails when token validation fails."""
+    with patch(
+        "homeassistant.helpers.config_entry_oauth2_flow.OAuth2Session.async_ensure_token_valid",
+        side_effect=ClientResponseError(
+            RequestInfo("", "POST", {}, ""), None, status=status
         ),
     ):
-        await hass.config_entries.async_setup(config_entry.entry_id)
-        await hass.async_block_till_done()
+        await init_integration(hass, mock_config_entry)
 
-    assert config_entry.state is ConfigEntryState.LOADED
+    assert mock_config_entry.state is expected_state
 
-    await hass.config_entries.async_unload(config_entry.entry_id)
-    await hass.async_block_till_done()
 
-    assert config_entry.state is ConfigEntryState.NOT_LOADED
+async def test_setup_entry_token_connection_error(
+    hass: HomeAssistant, mock_config_entry: MockConfigEntry
+) -> None:
+    """Test setup entry retries when token validation has a connection error."""
+    with patch(
+        "homeassistant.helpers.config_entry_oauth2_flow.OAuth2Session.async_ensure_token_valid",
+        side_effect=ClientConnectionError(),
+    ):
+        await init_integration(hass, mock_config_entry)
+
+    assert mock_config_entry.state is ConfigEntryState.SETUP_RETRY
+
+
+@pytest.mark.parametrize(
+    ("status", "expected_state"),
+    [
+        (http.HTTPStatus.UNAUTHORIZED, ConfigEntryState.SETUP_ERROR),
+        (http.HTTPStatus.INTERNAL_SERVER_ERROR, ConfigEntryState.SETUP_RETRY),
+    ],
+    ids=["auth_failure", "server_error"],
+)
+async def test_setup_entry_api_error(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    mock_aladdin_connect_api: AsyncMock,
+    status: http.HTTPStatus,
+    expected_state: ConfigEntryState,
+) -> None:
+    """Test setup entry fails when API call fails."""
+    mock_aladdin_connect_api.get_doors.side_effect = ClientResponseError(
+        RequestInfo("", "GET", {}, ""), None, status=status
+    )
+    await init_integration(hass, mock_config_entry)
+    assert mock_config_entry.state is expected_state
+
+
+async def test_setup_entry_api_connection_error(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    mock_aladdin_connect_api: AsyncMock,
+) -> None:
+    """Test setup entry retries when API has a connection error."""
+    mock_aladdin_connect_api.get_doors.side_effect = ClientConnectionError()
+    await init_integration(hass, mock_config_entry)
+    assert mock_config_entry.state is ConfigEntryState.SETUP_RETRY

tests/components/anthropic/conftest.py

@@ -81,6 +81,12 @@ async def mock_init_component(
     """Initialize integration."""
     model_list = AsyncPage(
         data=[
+            ModelInfo(
+                id="claude-sonnet-4-6",
+                created_at=datetime.datetime(2026, 2, 17, 0, 0, tzinfo=datetime.UTC),
+                display_name="Claude Sonnet 4.6",
+                type="model",
+            ),
             ModelInfo(
                 id="claude-opus-4-6",
                 created_at=datetime.datetime(2026, 2, 4, 0, 0, tzinfo=datetime.UTC),
@@ -123,30 +129,12 @@ async def mock_init_component(
                 display_name="Claude Sonnet 4",
                 type="model",
             ),
-            ModelInfo(
-                id="claude-3-7-sonnet-20250219",
-                created_at=datetime.datetime(2025, 2, 24, 0, 0, tzinfo=datetime.UTC),
-                display_name="Claude Sonnet 3.7",
-                type="model",
-            ),
-            ModelInfo(
-                id="claude-3-5-haiku-20241022",
-                created_at=datetime.datetime(2024, 10, 22, 0, 0, tzinfo=datetime.UTC),
-                display_name="Claude Haiku 3.5",
-                type="model",
-            ),
             ModelInfo(
                 id="claude-3-haiku-20240307",
                 created_at=datetime.datetime(2024, 3, 7, 0, 0, tzinfo=datetime.UTC),
                 display_name="Claude Haiku 3",
                 type="model",
             ),
-            ModelInfo(
-                id="claude-3-opus-20240229",
-                created_at=datetime.datetime(2024, 2, 29, 0, 0, tzinfo=datetime.UTC),
-                display_name="Claude Opus 3",
-                type="model",
-            ),
         ]
     )
     with patch(
@@ -204,7 +192,7 @@ def mock_create_stream() -> Generator[AsyncMock]:
                 id="msg_1234567890ABCDEFGHIJKLMN",
                 content=[],
                 role="assistant",
-                model="claude-3-5-sonnet-20240620",
+                model=kwargs["model"],
                 usage=Usage(input_tokens=0, output_tokens=0),
             ),
             type="message_start",

tests/components/anthropic/snapshots/test_config_flow.ambr

@@ -1,6 +1,10 @@
 # serializer version: 1
 # name: test_model_list
   list([
+    dict({
+      'label': 'Claude Sonnet 4.6',
+      'value': 'claude-sonnet-4-6',
+    }),
     dict({
       'label': 'Claude Opus 4.6',
       'value': 'claude-opus-4-6',
@@ -29,21 +33,9 @@
       'label': 'Claude Sonnet 4',
       'value': 'claude-sonnet-4-0',
     }),
-    dict({
-      'label': 'Claude Sonnet 3.7',
-      'value': 'claude-3-7-sonnet-latest',
-    }),
-    dict({
-      'label': 'Claude Haiku 3.5',
-      'value': 'claude-3-5-haiku-20241022',
-    }),
     dict({
       'label': 'Claude Haiku 3',
       'value': 'claude-3-haiku-20240307',
     }),
-    dict({
-      'label': 'Claude Opus 3',
-      'value': 'claude-3-opus-20240229',
-    }),
   ])
 # ---

tests/components/anthropic/snapshots/test_conversation.ambr

@@ -86,7 +86,7 @@
         'role': 'assistant',
       }),
     ]),
-    'model': 'claude-3-7-sonnet-latest',
+    'model': 'claude-sonnet-4-5',
     'stream': True,
     'system': list([
       dict({

tests/components/anthropic/test_config_flow.py

@@ -427,7 +427,7 @@ async def test_model_list_error(
                     CONF_PROMPT: "Speak like a pirate",
                 },
                 {
-                    CONF_CHAT_MODEL: "claude-3-opus",
+                    CONF_CHAT_MODEL: "claude-3-haiku-20240307",
                     CONF_TEMPERATURE: 1.0,
                 },
             ),
@@ -435,7 +435,7 @@ async def test_model_list_error(
                 CONF_RECOMMENDED: False,
                 CONF_PROMPT: "Speak like a pirate",
                 CONF_TEMPERATURE: 1.0,
-                CONF_CHAT_MODEL: "claude-3-opus",
+                CONF_CHAT_MODEL: "claude-3-haiku-20240307",
                 CONF_MAX_TOKENS: DEFAULT[CONF_MAX_TOKENS],
             },
         ),
@@ -459,7 +459,7 @@ async def test_model_list_error(
                     CONF_LLM_HASS_API: [],
                 },
                 {
-                    CONF_CHAT_MODEL: "claude-3-5-haiku-20241022",
+                    CONF_CHAT_MODEL: "claude-haiku-4-5",
                     CONF_TEMPERATURE: 1.0,
                 },
                 {
@@ -472,8 +472,9 @@ async def test_model_list_error(
                 CONF_RECOMMENDED: False,
                 CONF_PROMPT: "Speak like a pirate",
                 CONF_TEMPERATURE: 1.0,
-                CONF_CHAT_MODEL: "claude-3-5-haiku-20241022",
+                CONF_CHAT_MODEL: "claude-haiku-4-5",
                 CONF_MAX_TOKENS: DEFAULT[CONF_MAX_TOKENS],
+                CONF_THINKING_BUDGET: 0,
                 CONF_WEB_SEARCH: False,
                 CONF_WEB_SEARCH_MAX_USES: 10,
                 CONF_WEB_SEARCH_USER_LOCATION: False,

tests/components/anthropic/test_conversation.py

@@ -539,7 +539,7 @@ async def test_extended_thinking(
         next(iter(mock_config_entry.subentries.values())),
         data={
             CONF_LLM_HASS_API: llm.LLM_API_ASSIST,
-            CONF_CHAT_MODEL: "claude-3-7-sonnet-latest",
+            CONF_CHAT_MODEL: "claude-sonnet-4-5",
             CONF_THINKING_BUDGET: 1500,
         },
     )

tests/components/anthropic/test_init.py

@@ -103,7 +103,7 @@ async def test_downgrade_from_v3_to_v2(
                     "recommended": True,
                     "llm_hass_api": ["assist"],
                     "prompt": "You are a helpful assistant",
-                    "chat_model": "claude-3-haiku-20240307",
+                    "chat_model": "claude-haiku-4-5",
                 },
                 "subentry_id": "mock_id",
                 "subentry_type": "conversation",
@@ -154,7 +154,7 @@ async def test_migration_from_v1_to_v2(
         "recommended": True,
         "llm_hass_api": ["assist"],
         "prompt": "You are a helpful assistant",
-        "chat_model": "claude-3-haiku-20240307",
+        "chat_model": "claude-haiku-4-5",
     }
     mock_config_entry = MockConfigEntry(
         domain=DOMAIN,
@@ -315,7 +315,7 @@ async def test_migration_from_v1_disabled(
         "recommended": True,
         "llm_hass_api": ["assist"],
         "prompt": "You are a helpful assistant",
-        "chat_model": "claude-3-haiku-20240307",
+        "chat_model": "claude-haiku-4-5",
     }
     mock_config_entry = MockConfigEntry(
         domain=DOMAIN,
@@ -444,7 +444,7 @@ async def test_migration_from_v1_to_v2_with_multiple_keys(
         "recommended": True,
         "llm_hass_api": ["assist"],
         "prompt": "You are a helpful assistant",
-        "chat_model": "claude-3-haiku-20240307",
+        "chat_model": "claude-haiku-4-5",
     }
     mock_config_entry = MockConfigEntry(
         domain=DOMAIN,
@@ -534,7 +534,7 @@ async def test_migration_from_v1_to_v2_with_same_keys(
         "recommended": True,
         "llm_hass_api": ["assist"],
         "prompt": "You are a helpful assistant",
-        "chat_model": "claude-3-haiku-20240307",
+        "chat_model": "claude-haiku-4-5",
     }
     mock_config_entry = MockConfigEntry(
         domain=DOMAIN,
@@ -639,7 +639,7 @@ async def test_migration_from_v2_1_to_v2_2(
         "recommended": True,
         "llm_hass_api": ["assist"],
         "prompt": "You are a helpful assistant",
-        "chat_model": "claude-3-haiku-20240307",
+        "chat_model": "claude-haiku-4-5",
     }
     mock_config_entry = MockConfigEntry(
         domain=DOMAIN,
@@ -901,7 +901,7 @@ async def test_migrate_entry_to_v2_3(
                     "recommended": True,
                     "llm_hass_api": ["assist"],
                     "prompt": "You are a helpful assistant",
-                    "chat_model": "claude-3-haiku-20240307",
+                    "chat_model": "claude-haiku-4-5",
                 },
                 "subentry_id": conversation_subentry_id,
                 "subentry_type": "conversation",

tests/components/anthropic/test_repairs.py

@@ -114,8 +114,8 @@ async def test_repair_flow_iterates_subentries(
 
     model_options: list[dict[str, str]] = [
         {"label": "Claude Haiku 4.5", "value": "claude-haiku-4-5"},
-        {"label": "Claude Sonnet 4.5", "value": "claude-sonnet-4-5"},
-        {"label": "Claude Opus 4.5", "value": "claude-opus-4-5"},
+        {"label": "Claude Sonnet 4.6", "value": "claude-sonnet-4-6"},
+        {"label": "Claude Opus 4.6", "value": "claude-opus-4-6"},
     ]
 
     with patch(
@@ -152,12 +152,12 @@ async def test_repair_flow_iterates_subentries(
         result = await process_repair_fix_flow(
             client,
             flow_id,
-            json={CONF_CHAT_MODEL: "claude-sonnet-4-5"},
+            json={CONF_CHAT_MODEL: "claude-sonnet-4-6"},
         )
         assert result["type"] == FlowResultType.FORM
         assert (
             _get_subentry(entry_one, "ai_task_data").data[CONF_CHAT_MODEL]
-            == "claude-sonnet-4-5"
+            == "claude-sonnet-4-6"
         )
         assert (
             _get_subentry(entry_one, "conversation").data[CONF_CHAT_MODEL]
@@ -172,12 +172,12 @@ async def test_repair_flow_iterates_subentries(
         result = await process_repair_fix_flow(
             client,
             flow_id,
-            json={CONF_CHAT_MODEL: "claude-opus-4-5"},
+            json={CONF_CHAT_MODEL: "claude-opus-4-6"},
         )
         assert result["type"] == FlowResultType.CREATE_ENTRY
         assert (
             _get_subentry(entry_two, "conversation").data[CONF_CHAT_MODEL]
-            == "claude-opus-4-5"
+            == "claude-opus-4-6"
         )
 
     assert issue_registry.async_get_issue(DOMAIN, "model_deprecated") is None

tests/components/backup/snapshots/test_websocket.ambr

@@ -188,7 +188,7 @@
     'type': 'result',
   })
 # ---
-# name: test_can_decrypt_on_download[backup.local-c0cb53bd-hunter2]
+# name: test_can_decrypt_on_download[backup.local-backup_compressed_protected_v2-hunter2]
   dict({
     'id': 1,
     'result': None,
@@ -196,7 +196,26 @@
     'type': 'result',
   })
 # ---
-# name: test_can_decrypt_on_download[backup.local-c0cb53bd-wrong_password]
+# name: test_can_decrypt_on_download[backup.local-backup_compressed_protected_v2-wrong_password]
+  dict({
+    'error': dict({
+      'code': 'password_incorrect',
+      'message': 'Incorrect password',
+    }),
+    'id': 1,
+    'success': False,
+    'type': 'result',
+  })
+# ---
+# name: test_can_decrypt_on_download[backup.local-backup_compressed_protected_v3-hunter2]
+  dict({
+    'id': 1,
+    'result': None,
+    'success': True,
+    'type': 'result',
+  })
+# ---
+# name: test_can_decrypt_on_download[backup.local-backup_compressed_protected_v3-wrong_password]
   dict({
     'error': dict({
       'code': 'password_incorrect',

tests/components/backup/test_util.py

@@ -131,32 +131,75 @@ def test_read_backup(backup_json_content: bytes, expected_backup: AgentBackup) -
 
 
 @pytest.mark.parametrize(
-    ("backup", "password", "validation_result"),
+    ("backup", "password", "validation_result", "expected_messages"),
     [
         # Backup not protected, no password provided -> validation passes
-        (Path("backup_v2_compressed.tar"), None, True),
-        (Path("backup_v2_uncompressed.tar"), None, True),
+        (Path("backup_compressed.tar"), None, True, []),
+        (Path("backup_uncompressed.tar"), None, True, []),
         # Backup not protected, password provided -> validation fails
-        (Path("backup_v2_compressed.tar"), "hunter2", False),
-        (Path("backup_v2_uncompressed.tar"), "hunter2", False),
+        (Path("backup_compressed.tar"), "hunter2", False, ["Invalid password"]),
+        (Path("backup_uncompressed.tar"), "hunter2", False, ["Invalid password"]),
         # Backup protected, correct password provided -> validation passes
-        (Path("backup_v2_compressed_protected.tar"), "hunter2", True),
-        (Path("backup_v2_uncompressed_protected.tar"), "hunter2", True),
+        (Path("backup_compressed_protected_v2.tar"), "hunter2", True, []),
+        (Path("backup_uncompressed_protected_v2.tar"), "hunter2", True, []),
+        (Path("backup_compressed_protected_v3.tar"), "hunter2", True, []),
+        (Path("backup_uncompressed_protected_v3.tar"), "hunter2", True, []),
         # Backup protected, no password provided -> validation fails
-        (Path("backup_v2_compressed_protected.tar"), None, False),
-        (Path("backup_v2_uncompressed_protected.tar"), None, False),
+        (Path("backup_compressed_protected_v2.tar"), None, False, ["Invalid password"]),
+        (
+            Path("backup_uncompressed_protected_v2.tar"),
+            None,
+            False,
+            ["Invalid password"],
+        ),
+        (Path("backup_compressed_protected_v3.tar"), None, False, ["Invalid password"]),
+        (
+            Path("backup_uncompressed_protected_v3.tar"),
+            None,
+            False,
+            ["Invalid password"],
+        ),
         # Backup protected, wrong password provided -> validation fails
-        (Path("backup_v2_compressed_protected.tar"), "wrong_password", False),
-        (Path("backup_v2_uncompressed_protected.tar"), "wrong_password", False),
+        (
+            Path("backup_compressed_protected_v2.tar"),
+            "wrong_password",
+            False,
+            ["Invalid password"],
+        ),
+        (
+            Path("backup_uncompressed_protected_v2.tar"),
+            "wrong_password",
+            False,
+            ["Invalid password"],
+        ),
+        (
+            Path("backup_compressed_protected_v3.tar"),
+            "wrong_password",
+            False,
+            ["Invalid password"],
+        ),
+        (
+            Path("backup_uncompressed_protected_v3.tar"),
+            "wrong_password",
+            False,
+            ["Invalid password"],
+        ),
     ],
 )
 def test_validate_password(
-    password: str | None, backup: Path, validation_result: bool
+    password: str | None,
+    backup: Path,
+    validation_result: bool,
+    expected_messages: list[str],
+    caplog: pytest.LogCaptureFixture,
 ) -> None:
     """Test validating a password."""
     test_backups = get_fixture_path("test_backups", DOMAIN)
 
     assert validate_password(test_backups / backup, password) == validation_result
+    for message in expected_messages:
+        assert message in caplog.text
+    assert "Unexpected error validating password" not in caplog.text
 
 
 @pytest.mark.parametrize("password", [None, "hunter2"])

tests/components/backup/test_websocket.py

@@ -4048,8 +4048,10 @@ async def test_subscribe_event(
         # Legacy backup, which can't be streamed
         ("backup.local", "2bcb3113", "hunter2"),
         # New backup, which can be streamed, try with correct and wrong password
-        ("backup.local", "c0cb53bd", "hunter2"),
-        ("backup.local", "c0cb53bd", "wrong_password"),
+        ("backup.local", "backup_compressed_protected_v2", "hunter2"),
+        ("backup.local", "backup_compressed_protected_v2", "wrong_password"),
+        ("backup.local", "backup_compressed_protected_v3", "hunter2"),
+        ("backup.local", "backup_compressed_protected_v3", "wrong_password"),
     ],
 )
 @pytest.mark.usefixtures("mock_backups")

tests/components/bsblan/fixtures/sensor.json

@@ -16,5 +16,14 @@
     "dataType": 0,
     "readonly": 1,
     "unit": "°C"
+  },
+  "total_energy": {
+    "name": "Total energy",
+    "error": 0,
+    "value": "7968",
+    "desc": "",
+    "dataType": 0,
+    "readonly": 1,
+    "unit": "kWh"
   }
 }

tests/components/bsblan/snapshots/test_diagnostics.ambr

@@ -102,7 +102,19 @@
           'unit': '°C',
           'value': 6.1,
         }),
-        'total_energy': None,
+        'total_energy': dict({
+          'data_type': 0,
+          'data_type_family': '',
+          'data_type_name': '',
+          'desc': '',
+          'error': 0,
+          'name': 'Total energy',
+          'precision': None,
+          'readonly': 1,
+          'readwrite': 0,
+          'unit': 'kWh',
+          'value': 7968,
+        }),
       }),
       'state': dict({
         'current_temperature': dict({

tests/components/bsblan/snapshots/test_sensor.ambr

@@ -113,3 +113,60 @@
     'state': '6.1',
   })
 # ---
+# name: test_sensor_entity_properties[sensor.bsb_lan_total_energy-entry]
+  EntityRegistryEntrySnapshot({
+    'aliases': set({
+    }),
+    'area_id': None,
+    'capabilities': dict({
+      'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
+    }),
+    'config_entry_id': <ANY>,
+    'config_subentry_id': <ANY>,
+    'device_class': None,
+    'device_id': <ANY>,
+    'disabled_by': None,
+    'domain': 'sensor',
+    'entity_category': None,
+    'entity_id': 'sensor.bsb_lan_total_energy',
+    'has_entity_name': True,
+    'hidden_by': None,
+    'icon': None,
+    'id': <ANY>,
+    'labels': set({
+    }),
+    'name': None,
+    'object_id_base': 'Total energy',
+    'options': dict({
+      'sensor': dict({
+        'suggested_display_precision': 2,
+      }),
+    }),
+    'original_device_class': <SensorDeviceClass.ENERGY: 'energy'>,
+    'original_icon': None,
+    'original_name': 'Total energy',
+    'platform': 'bsblan',
+    'previous_unique_id': None,
+    'suggested_object_id': None,
+    'supported_features': 0,
+    'translation_key': 'total_energy',
+    'unique_id': '00:80:41:19:69:90-total_energy',
+    'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
+  })
+# ---
+# name: test_sensor_entity_properties[sensor.bsb_lan_total_energy-state]
+  StateSnapshot({
+    'attributes': ReadOnlyDict({
+      'device_class': 'energy',
+      'friendly_name': 'BSB-LAN Total energy',
+      'state_class': <SensorStateClass.TOTAL_INCREASING: 'total_increasing'>,
+      'unit_of_measurement': <UnitOfEnergy.KILO_WATT_HOUR: 'kWh'>,
+    }),
+    'context': <ANY>,
+    'entity_id': 'sensor.bsb_lan_total_energy',
+    'last_changed': <ANY>,
+    'last_reported': <ANY>,
+    'last_updated': <ANY>,
+    'state': '7968',
+  })
+# ---

tests/components/bsblan/test_sensor.py

@@ -15,6 +15,7 @@ from tests.common import MockConfigEntry, snapshot_platform
 
 ENTITY_CURRENT_TEMP = "sensor.bsb_lan_current_temperature"
 ENTITY_OUTSIDE_TEMP = "sensor.bsb_lan_outside_temperature"
+ENTITY_TOTAL_ENERGY = "sensor.bsb_lan_total_energy"
 
 
 async def test_sensor_entity_properties(
@@ -40,6 +41,7 @@ async def test_sensors_not_created_when_data_unavailable(
     # Set all sensor data to None to simulate no sensors available
     mock_bsblan.sensor.return_value.current_temperature = None
     mock_bsblan.sensor.return_value.outside_temperature = None
+    mock_bsblan.sensor.return_value.total_energy = None
 
     await setup_with_selected_platforms(hass, mock_config_entry, [Platform.SENSOR])
 
@@ -58,8 +60,9 @@ async def test_partial_sensors_created_when_some_data_available(
     entity_registry: er.EntityRegistry,
 ) -> None:
     """Test only available sensors are created when some sensor data is available."""
-    # Only current temperature available, outside temperature not
+    # Only current temperature available, outside temperature and energy not
     mock_bsblan.sensor.return_value.outside_temperature = None
+    mock_bsblan.sensor.return_value.total_energy = None
 
     await setup_with_selected_platforms(hass, mock_config_entry, [Platform.SENSOR])
 

tests/components/ecovacs/test_vacuum.py

@@ -0,0 +1,491 @@
+"""Tests for Ecovacs vacuum entities."""
+
+from dataclasses import asdict
+import logging
+
+from deebot_client.events import CachedMapInfoEvent, Event, RoomsEvent
+from deebot_client.events.map import Map
+from deebot_client.models import CleanMode, Room
+from deebot_client.rs.map import RotationAngle  # pylint: disable=no-name-in-module
+import pytest
+
+from homeassistant.components import vacuum
+from homeassistant.components.ecovacs.controller import EcovacsController
+from homeassistant.const import ATTR_ENTITY_ID, Platform
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import entity_registry as er, issue_registry as ir
+
+from .util import notify_and_wait
+
+from tests.typing import WebSocketGenerator
+
+pytestmark = [pytest.mark.usefixtures("init_integration")]
+
+
+@pytest.fixture
+def platforms() -> Platform | list[Platform]:
+    """Platforms, which should be loaded during the test."""
+    return Platform.VACUUM
+
+
+def _prepare_test(
+    hass: HomeAssistant,
+    entity_registry: er.EntityRegistry,
+    entity_id: str,
+) -> None:
+    entity_registry.async_update_entity_options(
+        entity_id,
+        vacuum.DOMAIN,
+        {
+            "area_mapping": {
+                "area_kitchen": ["1_1"],
+                "area_living_room": ["1_2"],
+                "area_bedroom": ["2_1"],
+            },
+            "last_seen_segments": [
+                {"id": "1_1", "name": "Kitchen", "group": "Main map"},
+                {"id": "1_2", "name": "Living room", "group": "Main map"},
+                {"id": "2_1", "name": "Bedroom", "group": "Second map"},
+            ],
+        },
+    )
+
+    vacuum_obj = hass.data[vacuum.DATA_COMPONENT].get_entity(entity_id)
+    assert vacuum_obj.last_seen_segments == [
+        vacuum.Segment(id="1_1", name="Kitchen", group="Main map"),
+        vacuum.Segment(id="1_2", name="Living room", group="Main map"),
+        vacuum.Segment(id="2_1", name="Bedroom", group="Second map"),
+    ]
+    assert vacuum_obj.supported_features & vacuum.VacuumEntityFeature.CLEAN_AREA
+
+
+@pytest.mark.parametrize(("device_fixture", "entity_id"), [("qhe2o2", "vacuum.dusty")])
+async def test_clean_area(
+    hass: HomeAssistant,
+    entity_registry: er.EntityRegistry,
+    controller: EcovacsController,
+    entity_id: str,
+) -> None:
+    """Test clean_area service call."""
+    _prepare_test(hass, entity_registry, entity_id)
+
+    device = controller.devices[0]
+    event_bus = device.events
+
+    await notify_and_wait(
+        hass,
+        event_bus,
+        CachedMapInfoEvent(
+            {
+                Map(
+                    id="1",
+                    name="Main map",
+                    using=True,
+                    built=True,
+                    angle=RotationAngle.DEG_0,
+                ),
+                Map(
+                    id="2",
+                    name="Second map",
+                    using=False,
+                    built=True,
+                    angle=RotationAngle.DEG_0,
+                ),
+            }
+        ),
+    )
+
+    device._execute_command.reset_mock()
+
+    await hass.services.async_call(
+        vacuum.DOMAIN,
+        vacuum.SERVICE_CLEAN_AREA,
+        {
+            ATTR_ENTITY_ID: entity_id,
+            "cleaning_area_id": ["area_living_room", "area_kitchen"],
+        },
+        blocking=True,
+    )
+
+    assert device._execute_command.call_count == 1
+    command = device._execute_command.call_args.args[0]
+    expected_command = device.capabilities.clean.action.area(
+        CleanMode.SPOT_AREA, [2, 1], 1
+    )
+    assert command == expected_command
+
+
+@pytest.mark.parametrize(("device_fixture", "entity_id"), [("qhe2o2", "vacuum.dusty")])
+async def test_clean_area_no_map(
+    hass: HomeAssistant,
+    entity_registry: er.EntityRegistry,
+    caplog: pytest.LogCaptureFixture,
+    controller: EcovacsController,
+    entity_id: str,
+) -> None:
+    """Test clean_area service call logs warning when no map info is available."""
+    _prepare_test(hass, entity_registry, entity_id)
+
+    device = controller.devices[0]
+    device._execute_command.reset_mock()
+
+    await hass.services.async_call(
+        vacuum.DOMAIN,
+        vacuum.SERVICE_CLEAN_AREA,
+        {
+            ATTR_ENTITY_ID: entity_id,
+            "cleaning_area_id": ["area_living_room", "area_kitchen"],
+        },
+        blocking=True,
+    )
+    assert caplog.record_tuples == [
+        (
+            "homeassistant.components.ecovacs.vacuum",
+            logging.WARNING,
+            "No map information available, cannot clean segments",
+        ),
+    ]
+    assert device._execute_command.call_count == 0
+
+
+@pytest.mark.parametrize(("device_fixture", "entity_id"), [("qhe2o2", "vacuum.dusty")])
+async def test_clean_area_invalid_map_id(
+    hass: HomeAssistant,
+    entity_registry: er.EntityRegistry,
+    caplog: pytest.LogCaptureFixture,
+    controller: EcovacsController,
+    entity_id: str,
+) -> None:
+    """Test clean_area service call logs warning when invalid map ID is provided."""
+    _prepare_test(hass, entity_registry, entity_id)
+
+    device = controller.devices[0]
+    event_bus = device.events
+    await notify_and_wait(
+        hass,
+        event_bus,
+        CachedMapInfoEvent(
+            {
+                Map(
+                    id="2",
+                    name="Second map",
+                    using=False,
+                    built=True,
+                    angle=RotationAngle.DEG_0,
+                ),
+            }
+        ),
+    )
+    device._execute_command.reset_mock()
+    caplog.clear()
+
+    await hass.services.async_call(
+        vacuum.DOMAIN,
+        vacuum.SERVICE_CLEAN_AREA,
+        {
+            ATTR_ENTITY_ID: entity_id,
+            "cleaning_area_id": ["area_living_room", "area_kitchen"],
+        },
+        blocking=True,
+    )
+
+    assert caplog.record_tuples == [
+        (
+            "homeassistant.components.ecovacs.vacuum",
+            logging.WARNING,
+            "Map ID 1 not found in available maps",
+        ),
+        # twice as both areas reference the same missing map ID
+        (
+            "homeassistant.components.ecovacs.vacuum",
+            logging.WARNING,
+            "Map ID 1 not found in available maps",
+        ),
+        (
+            "homeassistant.components.ecovacs.vacuum",
+            logging.WARNING,
+            "No valid segments to clean after validation, skipping clean segments command",
+        ),
+    ]
+    assert device._execute_command.call_count == 0
+
+
+@pytest.mark.parametrize(("device_fixture", "entity_id"), [("qhe2o2", "vacuum.dusty")])
+async def test_clean_area_room_from_not_current_map(
+    hass: HomeAssistant,
+    entity_registry: er.EntityRegistry,
+    caplog: pytest.LogCaptureFixture,
+    controller: EcovacsController,
+    entity_id: str,
+) -> None:
+    """Test clean_area service call logs warning when room is from a not current map."""
+    _prepare_test(hass, entity_registry, entity_id)
+
+    device = controller.devices[0]
+    event_bus = device.events
+    await notify_and_wait(
+        hass,
+        event_bus,
+        CachedMapInfoEvent(
+            {
+                Map(
+                    id="1",
+                    name="Main map",
+                    using=True,
+                    built=True,
+                    angle=RotationAngle.DEG_0,
+                ),
+                Map(
+                    id="2",
+                    name="Second map",
+                    using=False,
+                    built=True,
+                    angle=RotationAngle.DEG_0,
+                ),
+            }
+        ),
+    )
+
+    await notify_and_wait(
+        hass,
+        event_bus,
+        RoomsEvent(
+            map_id="1",
+            rooms=[
+                Room(name="Kitchen", id=1, coordinates=""),
+                Room(name="Living room", id=2, coordinates=""),
+            ],
+        ),
+    )
+    device._execute_command.reset_mock()
+    caplog.clear()
+
+    await hass.services.async_call(
+        vacuum.DOMAIN,
+        vacuum.SERVICE_CLEAN_AREA,
+        {
+            ATTR_ENTITY_ID: entity_id,
+            "cleaning_area_id": ["area_bedroom", "area_kitchen"],
+        },
+        blocking=True,
+    )
+
+    assert caplog.record_tuples == [
+        (
+            "homeassistant.components.ecovacs.vacuum",
+            logging.WARNING,
+            'Map "Second map" is not currently selected, skipping segment "Bedroom" (1)',
+        ),
+    ]
+    assert device._execute_command.call_count == 1
+    command = device._execute_command.call_args.args[0]
+    expected_command = device.capabilities.clean.action.area(
+        CleanMode.SPOT_AREA, [1], 1
+    )
+    assert command == expected_command
+
+
+@pytest.mark.parametrize(
+    "events",
+    [
+        (
+            CachedMapInfoEvent(
+                {
+                    Map(
+                        id="1",
+                        name="Main map",
+                        using=True,
+                        built=True,
+                        angle=RotationAngle.DEG_0,
+                    ),
+                    Map(
+                        id="2",
+                        name="Second map",
+                        using=False,
+                        built=True,
+                        angle=RotationAngle.DEG_0,
+                    ),
+                }
+            ),
+            RoomsEvent(
+                map_id="1",
+                rooms=[
+                    Room(name="Kitchen", id=1, coordinates=""),
+                ],
+            ),
+        ),
+        (
+            CachedMapInfoEvent(
+                {
+                    Map(
+                        id="1",
+                        name="Main map",
+                        using=True,
+                        built=True,
+                        angle=RotationAngle.DEG_0,
+                    ),
+                }
+            ),
+            RoomsEvent(
+                map_id="1",
+                rooms=[
+                    Room(name="Kitchen", id=1, coordinates=""),
+                    Room(name="Living room", id=2, coordinates=""),
+                ],
+            ),
+        ),
+        (
+            CachedMapInfoEvent(
+                {
+                    Map(
+                        id="1",
+                        name="Main map",
+                        using=True,
+                        built=True,
+                        angle=RotationAngle.DEG_0,
+                    ),
+                    Map(
+                        id="2",
+                        name="Second map",
+                        using=False,
+                        built=True,
+                        angle=RotationAngle.DEG_0,
+                    ),
+                }
+            ),
+            RoomsEvent(
+                map_id="1",
+                rooms=[
+                    Room(name="Kitchen", id=1, coordinates=""),
+                    Room(name="Living room", id=2, coordinates=""),
+                    Room(name="Bedroom", id=3, coordinates=""),
+                ],
+            ),
+        ),
+    ],
+    ids=[
+        "room removed",
+        "map removed",
+        "room added",
+    ],
+)
+@pytest.mark.parametrize(("device_fixture", "entity_id"), [("qhe2o2", "vacuum.dusty")])
+async def test_raise_segment_changed_issue(
+    hass: HomeAssistant,
+    entity_registry: er.EntityRegistry,
+    controller: EcovacsController,
+    entity_id: str,
+    events: tuple[Event, ...],
+) -> None:
+    """Test that the issue is raised on segment changes."""
+    _prepare_test(hass, entity_registry, entity_id)
+
+    device = controller.devices[0]
+    event_bus = device.events
+
+    for event in events:
+        await notify_and_wait(hass, event_bus, event)
+
+    entity_entry = entity_registry.async_get(entity_id)
+    issue_id = f"{vacuum.ISSUE_SEGMENTS_CHANGED}_{entity_entry.id}"
+    issue = ir.async_get(hass).async_get_issue(vacuum.DOMAIN, issue_id)
+    assert issue is not None
+
+
+@pytest.mark.parametrize(
+    ("events", "expected_segments", "expected_log_messages"),
+    [
+        ((), [], []),
+        (
+            (
+                CachedMapInfoEvent(
+                    {
+                        Map(
+                            id="1",
+                            name="Main map",
+                            using=True,
+                            built=True,
+                            angle=RotationAngle.DEG_0,
+                        ),
+                    }
+                ),
+                RoomsEvent(
+                    map_id="2",
+                    rooms=[
+                        Room(name="Kitchen", id=1, coordinates=""),
+                        Room(name="Living room", id=2, coordinates=""),
+                    ],
+                ),
+            ),
+            [],
+            [
+                (
+                    "homeassistant.components.ecovacs.vacuum",
+                    logging.WARNING,
+                    "Map ID 2 not found in available maps",
+                )
+            ],
+        ),
+        (
+            (
+                CachedMapInfoEvent(
+                    {
+                        Map(
+                            id="1",
+                            name="Main map",
+                            using=True,
+                            built=True,
+                            angle=RotationAngle.DEG_0,
+                        ),
+                    }
+                ),
+                RoomsEvent(
+                    map_id="1",
+                    rooms=[
+                        Room(name="Kitchen", id=1, coordinates=""),
+                        Room(name="Living room", id=2, coordinates=""),
+                    ],
+                ),
+            ),
+            [
+                vacuum.Segment(id="1_1", name="Kitchen", group="Main map"),
+                vacuum.Segment(id="1_2", name="Living room", group="Main map"),
+            ],
+            [],
+        ),
+    ],
+    ids=[
+        "no room event available",
+        "invalid map ID in room event",
+        "room added",
+    ],
+)
+@pytest.mark.parametrize(("device_fixture", "entity_id"), [("qhe2o2", "vacuum.dusty")])
+async def test_get_segments(
+    hass: HomeAssistant,
+    hass_ws_client: WebSocketGenerator,
+    caplog: pytest.LogCaptureFixture,
+    controller: EcovacsController,
+    entity_id: str,
+    events: tuple[Event, ...],
+    expected_segments: list[vacuum.Segment],
+    expected_log_messages: list[tuple[str, int, str]],
+) -> None:
+    """Test vacuum/get_segments websocket command."""
+    device = controller.devices[0]
+    event_bus = device.events
+
+    for event in events:
+        await notify_and_wait(hass, event_bus, event)
+
+    caplog.clear()
+
+    client = await hass_ws_client(hass)
+    await client.send_json_auto_id(
+        {"type": "vacuum/get_segments", "entity_id": entity_id}
+    )
+    msg = await client.receive_json()
+    assert msg["success"]
+    assert msg["result"] == {"segments": [asdict(seg) for seg in expected_segments]}
+    for log_message in expected_log_messages:
+        assert log_message in caplog.record_tuples

tests/components/enocean/test_config_flow.py

@@ -1,18 +1,25 @@
 """Tests for EnOcean config flow."""
 
-from unittest.mock import Mock, patch
+from unittest.mock import AsyncMock, Mock, patch
 
-from homeassistant import config_entries
 from homeassistant.components.enocean.config_flow import EnOceanFlowHandler
-from homeassistant.components.enocean.const import DOMAIN
+from homeassistant.components.enocean.const import DOMAIN, MANUFACTURER
+from homeassistant.config_entries import (
+    SOURCE_IMPORT,
+    SOURCE_USB,
+    SOURCE_USER,
+    ConfigEntryState,
+)
 from homeassistant.const import CONF_DEVICE
 from homeassistant.core import HomeAssistant
 from homeassistant.data_entry_flow import FlowResultType
+from homeassistant.helpers.service_info.usb import UsbServiceInfo
 
 from tests.common import MockConfigEntry
 
 DONGLE_VALIDATE_PATH_METHOD = "homeassistant.components.enocean.dongle.validate_path"
 DONGLE_DETECT_METHOD = "homeassistant.components.enocean.dongle.detect"
+SETUP_ENTRY_METHOD = "homeassistant.components.enocean.async_setup_entry"
 
 
 async def test_user_flow_cannot_create_multiple_instances(hass: HomeAssistant) -> None:
@@ -24,7 +31,7 @@ async def test_user_flow_cannot_create_multiple_instances(hass: HomeAssistant) -
 
     with patch(DONGLE_VALIDATE_PATH_METHOD, Mock(return_value=True)):
         result = await hass.config_entries.flow.async_init(
-            DOMAIN, context={"source": config_entries.SOURCE_USER}
+            DOMAIN, context={"source": SOURCE_USER}
         )
 
     assert result["type"] is FlowResultType.ABORT
@@ -37,7 +44,7 @@ async def test_user_flow_with_detected_dongle(hass: HomeAssistant) -> None:
 
     with patch(DONGLE_DETECT_METHOD, Mock(return_value=[FAKE_DONGLE_PATH])):
         result = await hass.config_entries.flow.async_init(
-            DOMAIN, context={"source": config_entries.SOURCE_USER}
+            DOMAIN, context={"source": SOURCE_USER}
         )
 
     assert result["type"] is FlowResultType.FORM
@@ -51,7 +58,7 @@ async def test_user_flow_with_no_detected_dongle(hass: HomeAssistant) -> None:
     """Test the user flow with a detected EnOcean dongle."""
     with patch(DONGLE_DETECT_METHOD, Mock(return_value=[])):
         result = await hass.config_entries.flow.async_init(
-            DOMAIN, context={"source": config_entries.SOURCE_USER}
+            DOMAIN, context={"source": SOURCE_USER}
         )
 
     assert result["type"] is FlowResultType.FORM
@@ -147,7 +154,7 @@ async def test_import_flow_with_valid_path(hass: HomeAssistant) -> None:
     with patch(DONGLE_VALIDATE_PATH_METHOD, Mock(return_value=True)):
         result = await hass.config_entries.flow.async_init(
             DOMAIN,
-            context={"source": config_entries.SOURCE_IMPORT},
+            context={"source": SOURCE_IMPORT},
             data=DATA_TO_IMPORT,
         )
 
@@ -165,9 +172,86 @@ async def test_import_flow_with_invalid_path(hass: HomeAssistant) -> None:
     ):
         result = await hass.config_entries.flow.async_init(
             DOMAIN,
-            context={"source": config_entries.SOURCE_IMPORT},
+            context={"source": SOURCE_IMPORT},
             data=DATA_TO_IMPORT,
         )
 
     assert result["type"] is FlowResultType.ABORT
     assert result["reason"] == "invalid_dongle_path"
+
+
+async def test_usb_discovery(
+    hass: HomeAssistant,
+) -> None:
+    """Test usb discovery success path."""
+    usb_discovery_info = UsbServiceInfo(
+        device="/dev/enocean0",
+        pid="6001",
+        vid="0403",
+        serial_number="1234",
+        description="USB 300",
+        manufacturer="EnOcean GmbH",
+    )
+    device = "/dev/enocean0"
+    # test discovery step
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN,
+        context={"source": SOURCE_USB},
+        data=usb_discovery_info,
+    )
+
+    assert result["type"] is FlowResultType.FORM
+    assert result["step_id"] == "usb_confirm"
+    assert result["errors"] is None
+
+    # test device path
+    with (
+        patch(DONGLE_VALIDATE_PATH_METHOD, Mock(return_value=True)),
+        patch(SETUP_ENTRY_METHOD, AsyncMock(return_value=True)),
+        patch(
+            "homeassistant.components.usb.get_serial_by_id",
+            side_effect=lambda x: x,
+        ),
+    ):
+        result = await hass.config_entries.flow.async_configure(result["flow_id"], {})
+
+    assert result["type"] is FlowResultType.CREATE_ENTRY
+    assert result["title"] == MANUFACTURER
+    assert result["data"] == {"device": device}
+    assert result["context"]["unique_id"] == "0403:6001_1234_EnOcean GmbH_USB 300"
+    assert result["context"]["title_placeholders"] == {
+        "name": "USB 300 - /dev/enocean0, s/n: 1234 - EnOcean GmbH - 0403:6001"
+    }
+    assert result["result"].state is ConfigEntryState.LOADED
+
+
+async def test_usb_discovery_already_configured_updates_path(
+    hass: HomeAssistant,
+) -> None:
+    """Test usb discovery aborts when already configured and updates device path."""
+    # Existing entry with the same unique_id but an old device path
+    existing_entry = MockConfigEntry(
+        domain=DOMAIN,
+        data={CONF_DEVICE: "/dev/enocean-old"},
+        unique_id="0403:6001_1234_EnOcean GmbH_USB 300",
+    )
+    existing_entry.add_to_hass(hass)
+
+    # New USB discovery for the same dongle but with an updated device path
+    usb_discovery_info = UsbServiceInfo(
+        device="/dev/enocean-new",
+        pid="6001",
+        vid="0403",
+        serial_number="1234",
+        description="USB 300",
+        manufacturer="EnOcean GmbH",
+    )
+
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN,
+        context={"source": SOURCE_USB},
+        data=usb_discovery_info,
+    )
+
+    assert result["type"] is FlowResultType.ABORT
+    assert result["reason"] == "single_instance_allowed"