Fix

Co-authored-by: Robert Resch <robert@resch.dev>

.github/actions/builder/generic/action.yml

@@ -0,0 +1,118 @@
+name: "Image builder"
+description: "Build a Docker image"
+inputs:
+  base-image:
+    description: "Base image to use for the build"
+    required: true
+    # example: 'ghcr.io/home-assistant/amd64-homeassistant-base:2024.6.0'
+  tags:
+    description: "Tag(s) for the built image (can be multiline for multiple tags)"
+    required: true
+    # example: 'ghcr.io/home-assistant/amd64-homeassistant:2026.2.0' or multiline for multiple tags
+  arch:
+    description: "Architecture for the build (used for default labels)"
+    required: true
+    # example: 'amd64'
+  version:
+    description: "Version for the build (used for default labels)"
+    required: true
+    # example: '2026.2.0'
+  dockerfile:
+    description: "Path to the Dockerfile to build"
+    required: true
+    # example: './Dockerfile'
+  cosign-base-identity:
+    description: "Certificate identity regexp for base image verification"
+    required: true
+    # example: 'https://github.com/home-assistant/docker/.*'
+  additional-labels:
+    description: "Additional labels to add to the built image (merged with default labels)"
+    required: false
+    default: ""
+    # example: 'custom.label=value'
+  push:
+    description: "Whether to push the image to the registry"
+    required: false
+    default: "true"
+    # example: 'true' or 'false'
+runs:
+  using: "composite"
+  steps:
+    - name: Install Cosign
+      uses: sigstore/cosign-installer@faadad0cce49287aee09b3a48701e75088a2c6ad # v4.0.0
+      with:
+        cosign-release: "v2.5.3"
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.12.0
+
+    - name: Verify base image signature
+      shell: bash
+      run: |
+        cosign verify \
+          --certificate-oidc-issuer https://token.actions.githubusercontent.com \
+          --certificate-identity-regexp "${{ inputs.cosign-base-identity }}" \
+          "${{ inputs.base-image }}"
+
+    - name: Verify cache image signature
+      id: cache
+      continue-on-error: true
+      shell: bash
+      run: |
+        cosign verify \
+          --certificate-oidc-issuer https://token.actions.githubusercontent.com \
+          --certificate-identity-regexp "https://github.com/home-assistant/core/.*" \
+          "ghcr.io/home-assistant/${{ inputs.arch }}-homeassistant:latest"
+
+    - name: Prepare labels
+      id: labels
+      shell: bash
+      run: |
+        # Generate creation timestamp
+        CREATED=$(date --rfc-3339=seconds --utc)
+
+        # Build default labels array
+        LABELS=(
+          "io.hass.arch=${{ inputs.arch }}"
+          "io.hass.version=${{ inputs.version }}"
+          "org.opencontainers.image.created=${CREATED}"
+          "org.opencontainers.image.version=${{ inputs.version }}"
+        )
+
+        # Append additional labels if provided
+        if [ -n "${{ inputs.additional-labels }}" ]; then
+          while IFS= read -r label; do
+            [ -n "$label" ] && LABELS+=("$label")
+          done <<< "${{ inputs.additional-labels }}"
+        fi
+
+        # Output the combined labels using EOF delimiter for multiline
+        {
+          echo 'result<<EOF'
+          printf '%s\n' "${LABELS[@]}"
+          echo 'EOF'
+        } >> "$GITHUB_OUTPUT"
+
+    - name: Build base image
+      id: build
+      uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
+      with:
+        context: .
+        file: ${{ inputs.dockerfile }}
+        platforms: ${{ steps.vars.outputs.platform }}
+        push: ${{ inputs.push }}
+        cache-from: ${{ steps.cache.outcome == 'success' && format('ghcr.io/home-assistant/{0}-homeassistant:latest', inputs.arch) || '' }}
+        build-args: |
+          BUILD_FROM=${{ inputs.base-image }}
+        tags: ${{ inputs.tags }}
+        outputs: type=image,compression=zstd,compression-level=9,force-compression=true,oci-mediatypes=true
+        labels: ${{ steps.labels.outputs.result }}
+
+    - name: Sign image
+      if: ${{ inputs.push == 'true' }}
+      shell: bash
+      run: |
+        # Sign each tag
+        while IFS= read -r tag; do
+          [ -n "$tag" ] && cosign sign --yes "${tag}@${{ steps.build.outputs.digest }}"
+        done <<< "${{ inputs.tags }}"

.github/actions/builder/machine/action.yml

@@ -0,0 +1,69 @@
+name: "Machine image builder"
+description: "Build or copy a machine-specific Docker image"
+inputs:
+  machine:
+    description: "Machine name"
+    required: true
+    # example: 'raspberrypi4-64'
+  version:
+    description: "Version for the build"
+    required: true
+    # example: '2026.2.0'
+  arch:
+    description: "Architecture for the build"
+    required: true
+    # example: 'aarch64'
+runs:
+  using: "composite"
+  steps:
+    - name: Prepare build variables
+      id: vars
+      shell: bash
+      run: |
+        echo "base_image=ghcr.io/home-assistant/${{ inputs.arch }}-homeassistant:${{ inputs.version }}" >> "$GITHUB_OUTPUT"
+
+        # Build tags array with version-specific tag
+        TAGS=(
+          "ghcr.io/home-assistant/${{ inputs.machine }}-homeassistant:${{ inputs.version }}"
+        )
+
+        # # Add general tag based on version
+        # if [[ "${{ inputs.version }}" =~ d ]]; then
+        #   TAGS+=("ghcr.io/home-assistant/${{ inputs.machine }}-homeassistant:dev")
+        # elif [[ "${{ inputs.version }}" =~ b ]]; then
+        #   TAGS+=("ghcr.io/home-assistant/${{ inputs.machine }}-homeassistant:beta")
+        # else
+        #   TAGS+=("ghcr.io/home-assistant/${{ inputs.machine }}-homeassistant:stable")
+        # fi
+
+        # Output tags using EOF delimiter for multiline
+        {
+          echo 'tags<<EOF'
+          printf '%s\n' "${TAGS[@]}"
+          echo 'EOF'
+        } >> "$GITHUB_OUTPUT"
+
+        LABELS=(
+          "io.hass.type=core"
+          "io.hass.machine=${{ inputs.machine }}"
+          "org.opencontainers.image.source=https://github.com/home-assistant/core"
+        )
+
+        # Output the labels using EOF delimiter for multiline
+        {
+          echo 'labels<<EOF'
+          printf '%s\n' "${LABELS[@]}"
+          echo 'EOF'
+        } >> "$GITHUB_OUTPUT"
+
+    - name: Build machine image
+      uses: ./.github/actions/builder/generic
+      with:
+        base-image: ${{ steps.vars.outputs.base_image }}
+        tags: ${{ steps.vars.outputs.tags }}
+        arch: ${{ inputs.arch }}
+        version: ${{ inputs.version }}
+        dockerfile: machine/${{ inputs.machine }}
+        cosign-base-identity: "https://github.com/home-assistant/core/.*"
+        additional-labels: ${{ steps.vars.outputs.labels }}
+        push: false

.github/workflows/builder.yml

@@ -47,10 +47,10 @@ jobs:
         with:
           type: ${{ env.BUILD_TYPE }}
 
-      - name: Verify version
-        uses: home-assistant/actions/helpers/verify-version@master
-        with:
-          ignore-dev: true
+      # - name: Verify version
+      #   uses: home-assistant/actions/helpers/verify-version@master
+      #   with:
+      #     ignore-dev: true
 
       - name: Fail if translations files are checked in
         run: |
@@ -190,161 +190,27 @@ jobs:
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - &install_cosign
-        name: Install Cosign
-        uses: sigstore/cosign-installer@faadad0cce49287aee09b3a48701e75088a2c6ad # v4.0.0
-        with:
-          cosign-release: "v2.5.3"
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.12.0
-
       - name: Build variables
         id: vars
         shell: bash
         run: |
           echo "base_image=ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant-base:${{ env.BASE_IMAGE_VERSION }}" >> "$GITHUB_OUTPUT"
-          echo "cache_image=ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:latest" >> "$GITHUB_OUTPUT"
-          echo "created=$(date --rfc-3339=seconds --utc)" >> "$GITHUB_OUTPUT"
-
-      - name: Verify base image signature
-        run: |
-          cosign verify \
-            --certificate-oidc-issuer https://token.actions.githubusercontent.com \
-            --certificate-identity-regexp "https://github.com/home-assistant/docker/.*" \
-            "${{ steps.vars.outputs.base_image }}"
-
-      - name: Verify cache image signature
-        id: cache
-        continue-on-error: true
-        run: |
-          cosign verify \
-            --certificate-oidc-issuer https://token.actions.githubusercontent.com \
-            --certificate-identity-regexp "https://github.com/home-assistant/core/.*" \
-            "${{ steps.vars.outputs.cache_image }}"
 
       - name: Build base image
-        id: build
-        uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
+        uses: ./.github/actions/builder/generic
         with:
-          context: .
-          file: ./Dockerfile
-          platforms: ${{ steps.vars.outputs.platform }}
-          push: true
-          cache-from: ${{ steps.cache.outcome == 'success' && steps.vars.outputs.cache_image || '' }}
-          build-args: |
-            BUILD_FROM=${{ steps.vars.outputs.base_image }}
+          base-image: ${{ steps.vars.outputs.base_image }}
           tags: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
-          labels: |
-            io.hass.arch=${{ matrix.arch }}
-            io.hass.version=${{ needs.init.outputs.version }}
-            org.opencontainers.image.created=${{ steps.vars.outputs.created }}
-            org.opencontainers.image.version=${{ needs.init.outputs.version }}
-
-      - name: Sign image
-        run: |
-          cosign sign --yes "ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}@${{ steps.build.outputs.digest }}"
+          arch: ${{ matrix.arch }}
+          version: ${{ needs.init.outputs.version }}
+          dockerfile: ./Dockerfile
+          cosign-base-identity: "https://github.com/home-assistant/docker/.*"
 
   build_machine:
-    name: Build ${{ matrix.machine }} machine core image
+    name: Build ${{ matrix.machine.name }} machine core image
     if: github.repository_owner == 'home-assistant'
     needs: ["init", "build_base"]
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      packages: write
-      id-token: write
-    strategy:
-      matrix:
-        machine:
-          - generic-x86-64
-          - intel-nuc
-          - khadas-vim3
-          - odroid-c2
-          - odroid-c4
-          - odroid-m1
-          - odroid-n2
-          - qemuarm-64
-          - qemux86-64
-          - raspberrypi3-64
-          - raspberrypi4-64
-          - raspberrypi5-64
-          - yellow
-          - green
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-
-      - name: Set build additional args
-        run: |
-          # Create general tags
-          if [[ "${{ needs.init.outputs.version }}" =~ d ]]; then
-            echo "BUILD_ARGS=--additional-tag dev" >> $GITHUB_ENV
-          elif [[ "${{ needs.init.outputs.version }}" =~ b ]]; then
-            echo "BUILD_ARGS=--additional-tag beta" >> $GITHUB_ENV
-          else
-            echo "BUILD_ARGS=--additional-tag stable" >> $GITHUB_ENV
-          fi
-
-      - 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 }}
-
-      # home-assistant/builder doesn't support sha pinning
-      - name: Build base image
-        uses: home-assistant/builder@2025.11.0
-        with:
-          args: |
-            $BUILD_ARGS \
-            --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
-    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-
-      - name: Initialize git
-        uses: home-assistant/actions/helpers/git-init@master
-        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
-        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
-        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
+    runs-on: ${{ matrix.machine.arch == 'amd64' && 'ubuntu-latest' || 'ubuntu-24.04-arm' }}
     permissions:
       contents: read
       packages: write
@@ -352,175 +218,25 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        registry: ["ghcr.io/home-assistant", "docker.io/homeassistant"]
-    steps:
-      - *install_cosign
-
-      - 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
-        run: |
-          ARCHS=$(echo '${{ needs.init.outputs.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:${{ needs.init.outputs.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
-        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 '${{ needs.init.outputs.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:${{ needs.init.outputs.version }}" \
-                "ghcr.io/home-assistant/${arch}-homeassistant:${{ needs.init.outputs.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:${{ needs.init.outputs.version }}"
-          done
-
-      - name: Create and push multi-arch manifests
-        shell: bash
-        run: |
-          # Build list of architecture images dynamically
-          ARCHS=$(echo '${{ needs.init.outputs.architectures }}' | jq -r '.[]')
-          ARCH_IMAGES=()
-          for arch in $ARCHS; do
-            ARCH_IMAGES+=("${{ matrix.registry }}/${arch}-homeassistant:${{ needs.init.outputs.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 <<< "${{ steps.meta.outputs.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
-      id-token: write
-    if: github.repository_owner == 'home-assistant' && needs.init.outputs.publish == 'true'
+        machine:
+          - { name: generic-x86-64, arch: amd64 }
+          - { name: intel-nuc, arch: amd64 }
+          - { name: qemux86-64, arch: amd64 }
+          - { name: khadas-vim3, arch: aarch64 }
+          - { name: odroid-c2, arch: aarch64 }
+          - { name: odroid-c4, arch: aarch64 }
+          - { name: odroid-m1, arch: aarch64 }
+          - { name: odroid-n2, arch: aarch64 }
+          - { name: qemuarm-64, arch: aarch64 }
+          - { name: raspberrypi3-64, arch: aarch64 }
+          - { name: raspberrypi4-64, arch: aarch64 }
+          - { name: raspberrypi5-64, arch: aarch64 }
+          - { name: yellow, arch: aarch64 }
+          - { name: green, arch: aarch64 }
     steps:
       - name: Checkout the repository
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
-      - 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
-      packages: write
-      attestations: write
-      id-token: write
-    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
-
       - name: Login to GitHub Container Registry
         uses: docker/login-action@c94ce9fb468520275223c153574b00df6fe4bcc9 # v3.7.0
         with:
@@ -528,31 +244,266 @@ jobs:
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Build Docker image
-        uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
+      - name: Build machine image
+        uses: ./.github/actions/builder/machine
         with:
-          context: . # So action will not pull the repository again
-          file: ./script/hassfest/docker/Dockerfile
-          load: true
-          tags: ${{ env.HASSFEST_IMAGE_TAG }}
+          machine: ${{ matrix.machine.name }}
+          version: ${{ needs.init.outputs.version }}
+          arch: ${{ matrix.machine.arch }}
 
-      - name: Run hassfest against core
-        run: docker run --rm -v ${{ github.workspace }}:/github/workspace ${{ env.HASSFEST_IMAGE_TAG }} --core-path=/github/workspace
+  # 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
+  #   steps:
+  #     - name: Checkout the repository
+  #       uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
-      - name: Push Docker image
-        if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
-        id: push
-        uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
-        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: Initialize git
+  #       uses: home-assistant/actions/helpers/git-init@master
+  #       with:
+  #         name: ${{ secrets.GIT_NAME }}
+  #         email: ${{ secrets.GIT_EMAIL }}
+  #         token: ${{ secrets.GIT_TOKEN }}
 
-      - 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
+  #     - name: Update version file
+  #       uses: home-assistant/actions/helpers/version-push@master
+  #       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
+  #       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
+  #     packages: write
+  #     id-token: write
+  #   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
+  #       run: |
+  #         ARCHS=$(echo '${{ needs.init.outputs.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:${{ needs.init.outputs.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
+  #       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 '${{ needs.init.outputs.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:${{ needs.init.outputs.version }}" \
+  #               "ghcr.io/home-assistant/${arch}-homeassistant:${{ needs.init.outputs.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:${{ needs.init.outputs.version }}"
+  #         done
+
+  #     - name: Create and push multi-arch manifests
+  #       shell: bash
+  #       run: |
+  #         # Build list of architecture images dynamically
+  #         ARCHS=$(echo '${{ needs.init.outputs.architectures }}' | jq -r '.[]')
+  #         ARCH_IMAGES=()
+  #         for arch in $ARCHS; do
+  #           ARCH_IMAGES+=("${{ matrix.registry }}/${arch}-homeassistant:${{ needs.init.outputs.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 <<< "${{ steps.meta.outputs.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
+  #     id-token: write
+  #   if: github.repository_owner == 'home-assistant' && needs.init.outputs.publish == 'true'
+  #   steps:
+  #     - name: Checkout the repository
+  #       uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+  #     - 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
+  #     packages: write
+  #     attestations: write
+  #     id-token: write
+  #   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
+
+  #     - 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@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
+  #       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 ${{ env.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@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
+  #       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

.github/workflows/codeql.yml

@@ -24,11 +24,11 @@ jobs:
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@b20883b0cd1f46c72ae0ba6d1090936928f9fa30 # v4.32.0
+        uses: github/codeql-action/init@6bc82e05fd0ea64601dd4b465378bbcf57de0314 # v4.32.1
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@b20883b0cd1f46c72ae0ba6d1090936928f9fa30 # v4.32.0
+        uses: github/codeql-action/analyze@6bc82e05fd0ea64601dd4b465378bbcf57de0314 # v4.32.1
         with:
           category: "/language:python"

homeassistant/brands/heatit.json

@@ -0,0 +1,5 @@
+{
+  "domain": "heatit",
+  "name": "Heatit",
+  "iot_standards": ["zwave"]
+}

homeassistant/brands/heiman.json

@@ -0,0 +1,5 @@
+{
+  "domain": "heiman",
+  "name": "Heiman",
+  "iot_standards": ["matter", "zigbee"]
+}

homeassistant/components/alexa_devices/manifest.json

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

homeassistant/components/alexa_devices/sensor.py

@@ -28,6 +28,7 @@ from homeassistant.helpers.typing import StateType
 from .const import CATEGORY_NOTIFICATIONS, CATEGORY_SENSORS
 from .coordinator import AmazonConfigEntry
 from .entity import AmazonEntity
+from .utils import async_remove_unsupported_notification_sensors
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -105,6 +106,9 @@ async def async_setup_entry(
 
     coordinator = entry.runtime_data
 
+    # Remove notification sensors from unsupported devices
+    await async_remove_unsupported_notification_sensors(hass, coordinator)
+
     known_devices: set[str] = set()
 
     def _check_device() -> None:
@@ -122,6 +126,7 @@ async def async_setup_entry(
                 AmazonSensorEntity(coordinator, serial_num, notification_desc)
                 for notification_desc in NOTIFICATIONS
                 for serial_num in new_devices
+                if coordinator.data[serial_num].notifications_supported
             ]
             async_add_entities(sensors_list + notifications_list)
 

homeassistant/components/alexa_devices/switch.py

@@ -59,13 +59,15 @@ async def async_setup_entry(
 
     coordinator = entry.runtime_data
 
-    # Replace unique id for "DND" switch and remove from Speaker Group
-    await async_update_unique_id(
-        hass, coordinator, SWITCH_DOMAIN, "do_not_disturb", "dnd"
-    )
+    # DND keys
+    old_key = "do_not_disturb"
+    new_key = "dnd"
 
-    # Remove DND switch from virtual groups
-    await async_remove_dnd_from_virtual_group(hass, coordinator)
+    # Remove old DND switch from virtual groups
+    await async_remove_dnd_from_virtual_group(hass, coordinator, old_key)
+
+    # Replace unique id for DND switch
+    await async_update_unique_id(hass, coordinator, SWITCH_DOMAIN, old_key, new_key)
 
     known_devices: set[str] = set()
 

homeassistant/components/alexa_devices/utils.py

@@ -5,8 +5,14 @@ from functools import wraps
 from typing import Any, Concatenate
 
 from aioamazondevices.const.devices import SPEAKER_GROUP_FAMILY
+from aioamazondevices.const.schedules import (
+    NOTIFICATION_ALARM,
+    NOTIFICATION_REMINDER,
+    NOTIFICATION_TIMER,
+)
 from aioamazondevices.exceptions import CannotConnect, CannotRetrieveData
 
+from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
 from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
@@ -48,7 +54,7 @@ def alexa_api_call[_T: AmazonEntity, **_P](
 async def async_update_unique_id(
     hass: HomeAssistant,
     coordinator: AmazonDevicesCoordinator,
-    domain: str,
+    platform: str,
     old_key: str,
     new_key: str,
 ) -> None:
@@ -57,7 +63,9 @@ async def async_update_unique_id(
 
     for serial_num in coordinator.data:
         unique_id = f"{serial_num}-{old_key}"
-        if entity_id := entity_registry.async_get_entity_id(domain, DOMAIN, unique_id):
+        if entity_id := entity_registry.async_get_entity_id(
+            DOMAIN, platform, unique_id
+        ):
             _LOGGER.debug("Updating unique_id for %s", entity_id)
             new_unique_id = unique_id.replace(old_key, new_key)
 
@@ -68,12 +76,13 @@ async def async_update_unique_id(
 async def async_remove_dnd_from_virtual_group(
     hass: HomeAssistant,
     coordinator: AmazonDevicesCoordinator,
+    key: str,
 ) -> None:
     """Remove entity DND from virtual group."""
     entity_registry = er.async_get(hass)
 
     for serial_num in coordinator.data:
-        unique_id = f"{serial_num}-do_not_disturb"
+        unique_id = f"{serial_num}-{key}"
         entity_id = entity_registry.async_get_entity_id(
             DOMAIN, SWITCH_DOMAIN, unique_id
         )
@@ -81,3 +90,27 @@ async def async_remove_dnd_from_virtual_group(
         if entity_id and is_group:
             entity_registry.async_remove(entity_id)
             _LOGGER.debug("Removed DND switch from virtual group %s", entity_id)
+
+
+async def async_remove_unsupported_notification_sensors(
+    hass: HomeAssistant,
+    coordinator: AmazonDevicesCoordinator,
+) -> None:
+    """Remove notification sensors from unsupported devices."""
+    entity_registry = er.async_get(hass)
+
+    for serial_num in coordinator.data:
+        for notification_key in (
+            NOTIFICATION_ALARM,
+            NOTIFICATION_REMINDER,
+            NOTIFICATION_TIMER,
+        ):
+            unique_id = f"{serial_num}-{notification_key}"
+            entity_id = entity_registry.async_get_entity_id(
+                DOMAIN, SENSOR_DOMAIN, unique_id=unique_id
+            )
+            is_unsupported = not coordinator.data[serial_num].notifications_supported
+
+            if entity_id and is_unsupported:
+                entity_registry.async_remove(entity_id)
+                _LOGGER.debug("Removed unsupported notification sensor %s", entity_id)

homeassistant/components/amcrest/__init__.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import AsyncIterator, Callable
+from collections.abc import AsyncGenerator, Callable
 from contextlib import asynccontextmanager, suppress
 from dataclasses import dataclass
 from datetime import datetime, timedelta
@@ -202,7 +202,7 @@ class AmcrestChecker(ApiWrapper):
     @asynccontextmanager
     async def async_stream_command(
         self, *args: Any, **kwargs: Any
-    ) -> AsyncIterator[httpx.Response]:
+    ) -> AsyncGenerator[httpx.Response]:
         """amcrest.ApiWrapper.command wrapper to catch errors."""
         async with (
             self._async_command_wrapper(),
@@ -211,7 +211,7 @@ class AmcrestChecker(ApiWrapper):
             yield ret
 
     @asynccontextmanager
-    async def _async_command_wrapper(self) -> AsyncIterator[None]:
+    async def _async_command_wrapper(self) -> AsyncGenerator[None]:
         try:
             yield
         except LoginError as ex:

homeassistant/components/analytics/manifest.json

@@ -10,6 +10,7 @@
   "preview_features": {
     "snapshots": {
       "feedback_url": "https://forms.gle/GqvRmgmghSDco8M46",
+      "learn_more_url": "https://www.home-assistant.io/blog/2026/02/02/about-device-database/",
       "report_issue_url": "https://github.com/OHF-Device-Database/device-database/issues/new"
     }
   },

homeassistant/components/analytics/strings.json

@@ -1,7 +1,7 @@
 {
   "preview_features": {
     "snapshots": {
-      "description": "This free, open source device database of the Open Home Foundation helps users find useful information about smart home devices used in real installations.\n\nYou can help build it by anonymously sharing data about your devices. Only device-specific details (like model or manufacturer) are shared — never personally identifying information (like the names you assign).\n\nLearn more about the device database and how we process your data in our [Data Use Statement](https://www.openhomefoundation.org/device-database-data-use-statement), which you accept by opting in.",
+      "description": "We're creating the [Open Home Foundation Device Database](https://www.home-assistant.io/blog/2026/02/02/about-device-database/): a free, open source community-powered resource to help users find practical information about how smart home devices perform in real installations.\n\nYou can help us build it by opting in to share anonymized data about your devices. This data will only ever include device-specific details (like model or manufacturer) – never personally identifying information (like the names you assign).\n\nFind out how we process your data (should you choose to contribute) in our [Data Use Statement](https://www.openhomefoundation.org/device-database-data-use-statement).",
       "disable_confirmation": "Your data will no longer be shared with the Open Home Foundation's device database.",
       "enable_confirmation": "This feature is still in development and may change. The device database is being refined based on user feedback and is not yet complete.",
       "name": "Device database"

homeassistant/components/anthropic/__init__.py

@@ -14,10 +14,18 @@ from homeassistant.helpers import (
     config_validation as cv,
     device_registry as dr,
     entity_registry as er,
+    issue_registry as ir,
 )
 from homeassistant.helpers.typing import ConfigType
 
-from .const import DEFAULT_CONVERSATION_NAME, DOMAIN, LOGGER
+from .const import (
+    CONF_CHAT_MODEL,
+    DATA_REPAIR_DEFER_RELOAD,
+    DEFAULT_CONVERSATION_NAME,
+    DEPRECATED_MODELS,
+    DOMAIN,
+    LOGGER,
+)
 
 PLATFORMS = (Platform.AI_TASK, Platform.CONVERSATION)
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
@@ -27,6 +35,7 @@ type AnthropicConfigEntry = ConfigEntry[anthropic.AsyncClient]
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up Anthropic."""
+    hass.data.setdefault(DOMAIN, {}).setdefault(DATA_REPAIR_DEFER_RELOAD, set())
     await async_migrate_integration(hass)
     return True
 
@@ -50,6 +59,22 @@ async def async_setup_entry(hass: HomeAssistant, entry: AnthropicConfigEntry) ->
 
     entry.async_on_unload(entry.add_update_listener(async_update_options))
 
+    for subentry in entry.subentries.values():
+        if (model := subentry.data.get(CONF_CHAT_MODEL)) and model.startswith(
+            tuple(DEPRECATED_MODELS)
+        ):
+            ir.async_create_issue(
+                hass,
+                DOMAIN,
+                "model_deprecated",
+                is_fixable=True,
+                is_persistent=False,
+                learn_more_url="https://platform.claude.com/docs/en/about-claude/model-deprecations",
+                severity=ir.IssueSeverity.WARNING,
+                translation_key="model_deprecated",
+            )
+            break
+
     return True
 
 
@@ -62,6 +87,11 @@ async def async_update_options(
     hass: HomeAssistant, entry: AnthropicConfigEntry
 ) -> None:
     """Update options."""
+    defer_reload_entries: set[str] = hass.data.setdefault(DOMAIN, {}).setdefault(
+        DATA_REPAIR_DEFER_RELOAD, set()
+    )
+    if entry.entry_id in defer_reload_entries:
+        return
     await hass.config_entries.async_reload(entry.entry_id)
 
 

homeassistant/components/anthropic/config_flow.py

@@ -92,6 +92,40 @@ async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> None:
     await client.models.list(timeout=10.0)
 
 
+async def get_model_list(client: anthropic.AsyncAnthropic) -> list[SelectOptionDict]:
+    """Get list of available models."""
+    try:
+        models = (await client.models.list()).data
+    except anthropic.AnthropicError:
+        models = []
+    _LOGGER.debug("Available models: %s", models)
+    model_options: list[SelectOptionDict] = []
+    short_form = re.compile(r"[^\d]-\d$")
+    for model_info in models:
+        # 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",
+            )
+            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,
+                value=model_alias,
+            )
+        )
+    return model_options
+
+
 class AnthropicConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Anthropic."""
 
@@ -401,38 +435,13 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
 
     async def _get_model_list(self) -> list[SelectOptionDict]:
         """Get list of available models."""
-        try:
-            client = await self.hass.async_add_executor_job(
-                partial(
-                    anthropic.AsyncAnthropic,
-                    api_key=self._get_entry().data[CONF_API_KEY],
-                )
+        client = await self.hass.async_add_executor_job(
+            partial(
+                anthropic.AsyncAnthropic,
+                api_key=self._get_entry().data[CONF_API_KEY],
             )
-            models = (await client.models.list()).data
-        except anthropic.AnthropicError:
-            models = []
-        _LOGGER.debug("Available models: %s", models)
-        model_options: list[SelectOptionDict] = []
-        short_form = re.compile(r"[^\d]-\d$")
-        for model_info in models:
-            # Resolve alias from versioned model name:
-            model_alias = (
-                model_info.id[:-9]
-                if model_info.id
-                not in ("claude-3-haiku-20240307", "claude-3-opus-20240229")
-                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,
-                    value=model_alias,
-                )
-            )
-        return model_options
+        )
+        return await get_model_list(client)
 
     async def _get_location_data(self) -> dict[str, str]:
         """Get approximate location data of the user."""

homeassistant/components/anthropic/const.py

@@ -22,8 +22,10 @@ CONF_WEB_SEARCH_REGION = "region"
 CONF_WEB_SEARCH_COUNTRY = "country"
 CONF_WEB_SEARCH_TIMEZONE = "timezone"
 
+DATA_REPAIR_DEFER_RELOAD = "repair_defer_reload"
+
 DEFAULT = {
-    CONF_CHAT_MODEL: "claude-3-5-haiku-latest",
+    CONF_CHAT_MODEL: "claude-haiku-4-5",
     CONF_MAX_TOKENS: 3000,
     CONF_TEMPERATURE: 1.0,
     CONF_THINKING_BUDGET: 0,
@@ -46,3 +48,10 @@ WEB_SEARCH_UNSUPPORTED_MODELS = [
     "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",
+]

homeassistant/components/anthropic/repairs.py

@@ -0,0 +1,275 @@
+"""Issue repair flow for Anthropic."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import cast
+
+import voluptuous as vol
+
+from homeassistant import data_entry_flow
+from homeassistant.components.repairs import RepairsFlow
+from homeassistant.config_entries import ConfigEntry, ConfigEntryState, ConfigSubentry
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.selector import SelectSelector, SelectSelectorConfig
+
+from .config_flow import get_model_list
+from .const import (
+    CONF_CHAT_MODEL,
+    DATA_REPAIR_DEFER_RELOAD,
+    DEFAULT,
+    DEPRECATED_MODELS,
+    DOMAIN,
+)
+
+
+class ModelDeprecatedRepairFlow(RepairsFlow):
+    """Handler for an issue fixing flow."""
+
+    _subentry_iter: Iterator[tuple[str, str]] | None
+    _current_entry_id: str | None
+    _current_subentry_id: str | None
+    _reload_pending: set[str]
+    _pending_updates: dict[str, dict[str, str]]
+
+    def __init__(self) -> None:
+        """Initialize the flow."""
+        super().__init__()
+        self._subentry_iter = None
+        self._current_entry_id = None
+        self._current_subentry_id = None
+        self._reload_pending = set()
+        self._pending_updates = {}
+
+    async def async_step_init(
+        self, user_input: dict[str, str] | None = None
+    ) -> data_entry_flow.FlowResult:
+        """Handle the first step of a fix flow."""
+        previous_entry_id: str | None = None
+        if user_input is not None:
+            previous_entry_id = self._async_update_current_subentry(user_input)
+            self._clear_current_target()
+
+        target = await self._async_next_target()
+        next_entry_id = target[0].entry_id if target else None
+        if previous_entry_id and previous_entry_id != next_entry_id:
+            await self._async_apply_pending_updates(previous_entry_id)
+        if target is None:
+            await self._async_apply_all_pending_updates()
+            return self.async_create_entry(data={})
+
+        entry, subentry, model = target
+        client = entry.runtime_data
+        model_list = [
+            model_option
+            for model_option in await get_model_list(client)
+            if not model_option["value"].startswith(tuple(DEPRECATED_MODELS))
+        ]
+
+        if "opus" in model:
+            suggested_model = "claude-opus-4-5"
+        elif "haiku" in model:
+            suggested_model = "claude-haiku-4-5"
+        elif "sonnet" in model:
+            suggested_model = "claude-sonnet-4-5"
+        else:
+            suggested_model = cast(str, DEFAULT[CONF_CHAT_MODEL])
+
+        schema = vol.Schema(
+            {
+                vol.Required(
+                    CONF_CHAT_MODEL,
+                    default=suggested_model,
+                ): SelectSelector(
+                    SelectSelectorConfig(options=model_list, custom_value=True)
+                ),
+            }
+        )
+
+        return self.async_show_form(
+            step_id="init",
+            data_schema=schema,
+            description_placeholders={
+                "entry_name": entry.title,
+                "model": model,
+                "subentry_name": subentry.title,
+                "subentry_type": self._format_subentry_type(subentry.subentry_type),
+            },
+        )
+
+    def _iter_deprecated_subentries(self) -> Iterator[tuple[str, str]]:
+        """Yield entry/subentry pairs that use deprecated models."""
+        for entry in self.hass.config_entries.async_entries(DOMAIN):
+            if entry.state is not ConfigEntryState.LOADED:
+                continue
+            for subentry in entry.subentries.values():
+                model = subentry.data.get(CONF_CHAT_MODEL)
+                if model and model.startswith(tuple(DEPRECATED_MODELS)):
+                    yield entry.entry_id, subentry.subentry_id
+
+    async def _async_next_target(
+        self,
+    ) -> tuple[ConfigEntry, ConfigSubentry, str] | None:
+        """Return the next deprecated subentry target."""
+        if self._subentry_iter is None:
+            self._subentry_iter = self._iter_deprecated_subentries()
+
+        while True:
+            try:
+                entry_id, subentry_id = next(self._subentry_iter)
+            except StopIteration:
+                return None
+
+            entry = self.hass.config_entries.async_get_entry(entry_id)
+            if entry is None:
+                continue
+
+            subentry = entry.subentries.get(subentry_id)
+            if subentry is None:
+                continue
+
+            model = self._pending_model(entry_id, subentry_id)
+            if model is None:
+                model = subentry.data.get(CONF_CHAT_MODEL)
+            if not model or not model.startswith(tuple(DEPRECATED_MODELS)):
+                continue
+
+            self._current_entry_id = entry_id
+            self._current_subentry_id = subentry_id
+            return entry, subentry, model
+
+    def _async_update_current_subentry(self, user_input: dict[str, str]) -> str | None:
+        """Update the currently selected subentry."""
+        if not self._current_entry_id or not self._current_subentry_id:
+            return None
+
+        entry = self.hass.config_entries.async_get_entry(self._current_entry_id)
+        if entry is None:
+            return None
+
+        subentry = entry.subentries.get(self._current_subentry_id)
+        if subentry is None:
+            return None
+
+        updated_data = {
+            **subentry.data,
+            CONF_CHAT_MODEL: user_input[CONF_CHAT_MODEL],
+        }
+        if updated_data == subentry.data:
+            return entry.entry_id
+        self._queue_pending_update(
+            entry.entry_id,
+            subentry.subentry_id,
+            updated_data[CONF_CHAT_MODEL],
+        )
+        return entry.entry_id
+
+    def _clear_current_target(self) -> None:
+        """Clear current target tracking."""
+        self._current_entry_id = None
+        self._current_subentry_id = None
+
+    def _format_subentry_type(self, subentry_type: str) -> str:
+        """Return a user-friendly subentry type label."""
+        if subentry_type == "conversation":
+            return "Conversation agent"
+        if subentry_type in ("ai_task", "ai_task_data"):
+            return "AI task"
+        return subentry_type
+
+    def _queue_pending_update(
+        self, entry_id: str, subentry_id: str, model: str
+    ) -> None:
+        """Store a pending model update for a subentry."""
+        self._pending_updates.setdefault(entry_id, {})[subentry_id] = model
+
+    def _pending_model(self, entry_id: str, subentry_id: str) -> str | None:
+        """Return a pending model update if one exists."""
+        return self._pending_updates.get(entry_id, {}).get(subentry_id)
+
+    def _mark_entry_for_reload(self, entry_id: str) -> None:
+        """Prevent reload until repairs are complete for the entry."""
+        self._reload_pending.add(entry_id)
+        defer_reload_entries: set[str] = self.hass.data.setdefault(
+            DOMAIN, {}
+        ).setdefault(DATA_REPAIR_DEFER_RELOAD, set())
+        defer_reload_entries.add(entry_id)
+
+    async def _async_reload_entry(self, entry_id: str) -> None:
+        """Reload an entry once all repairs are completed."""
+        if entry_id not in self._reload_pending:
+            return
+
+        entry = self.hass.config_entries.async_get_entry(entry_id)
+        if entry is not None and entry.state is not ConfigEntryState.LOADED:
+            self._clear_defer_reload(entry_id)
+            self._reload_pending.discard(entry_id)
+            return
+
+        if entry is not None:
+            await self.hass.config_entries.async_reload(entry_id)
+
+        self._clear_defer_reload(entry_id)
+        self._reload_pending.discard(entry_id)
+
+    def _clear_defer_reload(self, entry_id: str) -> None:
+        """Remove entry from the deferred reload set."""
+        defer_reload_entries: set[str] = self.hass.data.setdefault(
+            DOMAIN, {}
+        ).setdefault(DATA_REPAIR_DEFER_RELOAD, set())
+        defer_reload_entries.discard(entry_id)
+
+    async def _async_apply_pending_updates(self, entry_id: str) -> None:
+        """Apply pending subentry updates for a single entry."""
+        updates = self._pending_updates.pop(entry_id, None)
+        if not updates:
+            return
+
+        entry = self.hass.config_entries.async_get_entry(entry_id)
+        if entry is None or entry.state is not ConfigEntryState.LOADED:
+            return
+
+        changed = False
+        for subentry_id, model in updates.items():
+            subentry = entry.subentries.get(subentry_id)
+            if subentry is None:
+                continue
+
+            updated_data = {
+                **subentry.data,
+                CONF_CHAT_MODEL: model,
+            }
+            if updated_data == subentry.data:
+                continue
+
+            if not changed:
+                self._mark_entry_for_reload(entry_id)
+                changed = True
+
+            self.hass.config_entries.async_update_subentry(
+                entry,
+                subentry,
+                data=updated_data,
+            )
+
+        if not changed:
+            return
+
+        await self._async_reload_entry(entry_id)
+
+    async def _async_apply_all_pending_updates(self) -> None:
+        """Apply all pending updates across entries."""
+        for entry_id in list(self._pending_updates):
+            await self._async_apply_pending_updates(entry_id)
+
+
+async def async_create_fix_flow(
+    hass: HomeAssistant,
+    issue_id: str,
+    data: dict[str, str | int | float | None] | None,
+) -> RepairsFlow:
+    """Create flow."""
+    if issue_id == "model_deprecated":
+        return ModelDeprecatedRepairFlow()
+    raise HomeAssistantError("Unknown issue ID")

homeassistant/components/anthropic/strings.json

@@ -109,5 +109,21 @@
         }
       }
     }
+  },
+  "issues": {
+    "model_deprecated": {
+      "fix_flow": {
+        "step": {
+          "init": {
+            "data": {
+              "chat_model": "[%key:common::generic::model%]"
+            },
+            "description": "You are updating {subentry_name} ({subentry_type}) in {entry_name}. The current model {model} is deprecated. Select a supported model to continue.",
+            "title": "Update model"
+          }
+        }
+      },
+      "title": "Model deprecated"
+    }
   }
 }

homeassistant/components/aosmith/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/aosmith",
   "integration_type": "hub",
   "iot_class": "cloud_polling",
-  "requirements": ["py-aosmith==1.0.15"]
+  "requirements": ["py-aosmith==1.0.16"]
 }

homeassistant/components/apple_tv/binary_sensor.py

@@ -2,15 +2,16 @@
 
 from __future__ import annotations
 
-from pyatv.const import KeyboardFocusState
+from pyatv.const import FeatureName, FeatureState, KeyboardFocusState
 from pyatv.interface import AppleTV, KeyboardListener
 
 from homeassistant.components.binary_sensor import BinarySensorEntity
 from homeassistant.const import CONF_NAME
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import AppleTvConfigEntry
+from . import SIGNAL_CONNECTED, AppleTvConfigEntry
 from .entity import AppleTVEntity
 
 
@@ -21,10 +22,22 @@ async def async_setup_entry(
 ) -> None:
     """Load Apple TV binary sensor based on a config entry."""
     # apple_tv config entries always have a unique id
-    assert config_entry.unique_id is not None
-    name: str = config_entry.data[CONF_NAME]
     manager = config_entry.runtime_data
-    async_add_entities([AppleTVKeyboardFocused(name, config_entry.unique_id, manager)])
+    cb: CALLBACK_TYPE
+
+    def setup_entities(atv: AppleTV) -> None:
+        if atv.features.in_state(FeatureState.Available, FeatureName.TextFocusState):
+            assert config_entry.unique_id is not None
+            name: str = config_entry.data[CONF_NAME]
+            async_add_entities(
+                [AppleTVKeyboardFocused(name, config_entry.unique_id, manager)]
+            )
+            cb()
+
+    cb = async_dispatcher_connect(
+        hass, f"{SIGNAL_CONNECTED}_{config_entry.unique_id}", setup_entities
+    )
+    config_entry.async_on_unload(cb)
 
 
 class AppleTVKeyboardFocused(AppleTVEntity, BinarySensorEntity, KeyboardListener):

homeassistant/components/axis/config_flow.py

@@ -52,7 +52,7 @@ from .const import (
 from .errors import AuthenticationRequired, CannotConnect
 from .hub import AxisHub, get_axis_api
 
-AXIS_OUI = {"00:40:8c", "ac:cc:8e", "b8:a4:4f"}
+AXIS_OUI = {"00:40:8c", "ac:cc:8e", "b8:a4:4f", "e8:27:25"}
 DEFAULT_PORT = 443
 DEFAULT_PROTOCOL = "https"
 PROTOCOL_CHOICES = ["https", "http"]

homeassistant/components/backup/const.py

@@ -26,6 +26,7 @@ EXCLUDE_FROM_BACKUP = [
     "tmp_backups/*.tar",
     "OZW_Log.txt",
     "tts/*",
+    ".cache/*",
 ]
 
 EXCLUDE_DATABASE_FROM_BACKUP = [

homeassistant/components/baidu/tts.py

@@ -1,6 +1,7 @@
 """Support for Baidu speech service."""
 
 import logging
+from typing import Any
 
 from aip import AipSpeech
 import voluptuous as vol
@@ -9,6 +10,7 @@ from homeassistant.components.tts import (
     CONF_LANG,
     PLATFORM_SCHEMA as TTS_PLATFORM_SCHEMA,
     Provider,
+    TtsAudioType,
 )
 from homeassistant.const import CONF_API_KEY
 from homeassistant.helpers import config_validation as cv
@@ -85,17 +87,17 @@ class BaiduTTSProvider(Provider):
         }
 
     @property
-    def default_language(self):
+    def default_language(self) -> str:
         """Return the default language."""
         return self._lang
 
     @property
-    def supported_languages(self):
+    def supported_languages(self) -> list[str]:
         """Return a list of supported languages."""
         return SUPPORTED_LANGUAGES
 
     @property
-    def default_options(self):
+    def default_options(self) -> dict[str, Any]:
         """Return a dict including default options."""
         return {
             CONF_PERSON: self._speech_conf_data[_OPTIONS[CONF_PERSON]],
@@ -105,11 +107,16 @@ class BaiduTTSProvider(Provider):
         }
 
     @property
-    def supported_options(self):
+    def supported_options(self) -> list[str]:
         """Return a list of supported options."""
         return SUPPORTED_OPTIONS
 
-    def get_tts_audio(self, message, language, options):
+    def get_tts_audio(
+        self,
+        message: str,
+        language: str,
+        options: dict[str, Any],
+    ) -> TtsAudioType:
         """Load TTS from BaiduTTS."""
 
         aip_speech = AipSpeech(

homeassistant/components/bond/__init__.py

@@ -16,14 +16,17 @@ from homeassistant.const import (
 )
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers import config_validation as cv, device_registry as dr
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.entity import SLOW_UPDATE_WARNING
+from homeassistant.helpers.typing import ConfigType
 
 from .const import BRIDGE_MAKE, DOMAIN
 from .models import BondData
+from .services import async_setup_services
 from .utils import BondHub
 
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 PLATFORMS = [
     Platform.BUTTON,
     Platform.COVER,
@@ -38,6 +41,12 @@ _LOGGER = logging.getLogger(__name__)
 type BondConfigEntry = ConfigEntry[BondData]
 
 
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the component."""
+    async_setup_services(hass)
+    return True
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: BondConfigEntry) -> bool:
     """Set up Bond from a config entry."""
     host = entry.data[CONF_HOST]

homeassistant/components/bond/const.py

@@ -5,10 +5,3 @@ BRIDGE_MAKE = "Olibra"
 DOMAIN = "bond"
 
 CONF_BOND_ID: str = "bond_id"
-
-
-SERVICE_SET_FAN_SPEED_TRACKED_STATE = "set_fan_speed_tracked_state"
-SERVICE_SET_POWER_TRACKED_STATE = "set_switch_power_tracked_state"
-SERVICE_SET_LIGHT_POWER_TRACKED_STATE = "set_light_power_tracked_state"
-SERVICE_SET_LIGHT_BRIGHTNESS_TRACKED_STATE = "set_light_brightness_tracked_state"
-ATTR_POWER_STATE = "power_state"

homeassistant/components/bond/fan.py

@@ -8,7 +8,6 @@ from typing import Any
 
 from aiohttp.client_exceptions import ClientResponseError
 from bond_async import Action, DeviceType, Direction
-import voluptuous as vol
 
 from homeassistant.components.fan import (
     DIRECTION_FORWARD,
@@ -18,7 +17,6 @@ from homeassistant.components.fan import (
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import entity_platform
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util.percentage import (
     percentage_to_ranged_value,
@@ -27,7 +25,6 @@ from homeassistant.util.percentage import (
 from homeassistant.util.scaling import int_states_in_range
 
 from . import BondConfigEntry
-from .const import SERVICE_SET_FAN_SPEED_TRACKED_STATE
 from .entity import BondEntity
 from .models import BondData
 from .utils import BondDevice
@@ -44,12 +41,6 @@ async def async_setup_entry(
 ) -> None:
     """Set up Bond fan devices."""
     data = entry.runtime_data
-    platform = entity_platform.async_get_current_platform()
-    platform.async_register_entity_service(
-        SERVICE_SET_FAN_SPEED_TRACKED_STATE,
-        {vol.Required("speed"): vol.All(vol.Number(scale=0), vol.Range(0, 100))},
-        "async_set_speed_belief",
-    )
 
     async_add_entities(
         BondFan(data, device)

homeassistant/components/bond/light.py

@@ -7,37 +7,20 @@ from typing import Any
 
 from aiohttp.client_exceptions import ClientResponseError
 from bond_async import Action, DeviceType
-import voluptuous as vol
 
 from homeassistant.components.light import ATTR_BRIGHTNESS, ColorMode, LightEntity
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import BondConfigEntry
-from .const import (
-    ATTR_POWER_STATE,
-    SERVICE_SET_LIGHT_BRIGHTNESS_TRACKED_STATE,
-    SERVICE_SET_LIGHT_POWER_TRACKED_STATE,
-)
 from .entity import BondEntity
 from .models import BondData
 from .utils import BondDevice
 
 _LOGGER = logging.getLogger(__name__)
 
-SERVICE_START_INCREASING_BRIGHTNESS = "start_increasing_brightness"
-SERVICE_START_DECREASING_BRIGHTNESS = "start_decreasing_brightness"
-SERVICE_STOP = "stop"
-
-ENTITY_SERVICES = [
-    SERVICE_START_INCREASING_BRIGHTNESS,
-    SERVICE_START_DECREASING_BRIGHTNESS,
-    SERVICE_STOP,
-]
-
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -48,14 +31,6 @@ async def async_setup_entry(
     data = entry.runtime_data
     hub = data.hub
 
-    platform = entity_platform.async_get_current_platform()
-    for service in ENTITY_SERVICES:
-        platform.async_register_entity_service(
-            service,
-            None,
-            f"async_{service}",
-        )
-
     fan_lights: list[Entity] = [
         BondLight(data, device)
         for device in hub.devices
@@ -94,22 +69,6 @@ async def async_setup_entry(
         if DeviceType.is_light(device.type)
     ]
 
-    platform.async_register_entity_service(
-        SERVICE_SET_LIGHT_BRIGHTNESS_TRACKED_STATE,
-        {
-            vol.Required(ATTR_BRIGHTNESS): vol.All(
-                vol.Number(scale=0), vol.Range(0, 255)
-            )
-        },
-        "async_set_brightness_belief",
-    )
-
-    platform.async_register_entity_service(
-        SERVICE_SET_LIGHT_POWER_TRACKED_STATE,
-        {vol.Required(ATTR_POWER_STATE): vol.All(cv.boolean)},
-        "async_set_power_belief",
-    )
-
     async_add_entities(
         fan_lights + fan_up_lights + fan_down_lights + fireplaces + fp_lights + lights,
     )

homeassistant/components/bond/services.py

@@ -0,0 +1,101 @@
+"""Support for Bond services."""
+
+from __future__ import annotations
+
+import voluptuous as vol
+
+from homeassistant.components.fan import DOMAIN as FAN_DOMAIN
+from homeassistant.components.light import ATTR_BRIGHTNESS, DOMAIN as LIGHT_DOMAIN
+from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import config_validation as cv, service
+
+from .const import DOMAIN
+
+ATTR_POWER_STATE = "power_state"
+
+# Fan
+SERVICE_SET_FAN_SPEED_TRACKED_STATE = "set_fan_speed_tracked_state"
+
+# Switch
+SERVICE_SET_POWER_TRACKED_STATE = "set_switch_power_tracked_state"
+
+# Light
+SERVICE_SET_LIGHT_POWER_TRACKED_STATE = "set_light_power_tracked_state"
+SERVICE_SET_LIGHT_BRIGHTNESS_TRACKED_STATE = "set_light_brightness_tracked_state"
+SERVICE_START_INCREASING_BRIGHTNESS = "start_increasing_brightness"
+SERVICE_START_DECREASING_BRIGHTNESS = "start_decreasing_brightness"
+SERVICE_STOP = "stop"
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Home Assistant services."""
+
+    # Fan entity services
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_SET_FAN_SPEED_TRACKED_STATE,
+        entity_domain=FAN_DOMAIN,
+        schema={vol.Required("speed"): vol.All(vol.Number(scale=0), vol.Range(0, 100))},
+        func="async_set_speed_belief",
+    )
+
+    # Light entity services
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_START_INCREASING_BRIGHTNESS,
+        entity_domain=LIGHT_DOMAIN,
+        schema=None,
+        func="async_start_increasing_brightness",
+    )
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_START_DECREASING_BRIGHTNESS,
+        entity_domain=LIGHT_DOMAIN,
+        schema=None,
+        func="async_start_decreasing_brightness",
+    )
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_STOP,
+        entity_domain=LIGHT_DOMAIN,
+        schema=None,
+        func="async_stop",
+    )
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_SET_LIGHT_BRIGHTNESS_TRACKED_STATE,
+        entity_domain=LIGHT_DOMAIN,
+        schema={
+            vol.Required(ATTR_BRIGHTNESS): vol.All(
+                vol.Number(scale=0), vol.Range(0, 255)
+            )
+        },
+        func="async_set_brightness_belief",
+    )
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_SET_LIGHT_POWER_TRACKED_STATE,
+        entity_domain=LIGHT_DOMAIN,
+        schema={vol.Required(ATTR_POWER_STATE): vol.All(cv.boolean)},
+        func="async_set_power_belief",
+    )
+
+    # Switch entity services
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_SET_POWER_TRACKED_STATE,
+        entity_domain=SWITCH_DOMAIN,
+        schema={vol.Required(ATTR_POWER_STATE): cv.boolean},
+        func="async_set_power_belief",
+    )

homeassistant/components/bond/switch.py

@@ -6,16 +6,13 @@ from typing import Any
 
 from aiohttp.client_exceptions import ClientResponseError
 from bond_async import Action, DeviceType
-import voluptuous as vol
 
 from homeassistant.components.switch import SwitchEntity
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import BondConfigEntry
-from .const import ATTR_POWER_STATE, SERVICE_SET_POWER_TRACKED_STATE
 from .entity import BondEntity
 
 
@@ -26,12 +23,6 @@ async def async_setup_entry(
 ) -> None:
     """Set up Bond generic devices."""
     data = entry.runtime_data
-    platform = entity_platform.async_get_current_platform()
-    platform.async_register_entity_service(
-        SERVICE_SET_POWER_TRACKED_STATE,
-        {vol.Required(ATTR_POWER_STATE): cv.boolean},
-        "async_set_power_belief",
-    )
 
     async_add_entities(
         BondSwitch(data, device)

homeassistant/components/bring/const.py

@@ -1,14 +1,3 @@
 """Constants for the Bring! integration."""
 
-from typing import Final
-
 DOMAIN = "bring"
-
-ATTR_SENDER: Final = "sender"
-ATTR_ITEM_NAME: Final = "item"
-ATTR_NOTIFICATION_TYPE: Final = "message"
-ATTR_REACTION: Final = "reaction"
-ATTR_ACTIVITY: Final = "uuid"
-ATTR_RECEIVER: Final = "publicUserUuid"
-SERVICE_PUSH_NOTIFICATION = "send_message"
-SERVICE_ACTIVITY_STREAM_REACTION = "send_reaction"

homeassistant/components/bring/services.py

@@ -1,6 +1,5 @@
 """Actions for Bring! integration."""
 
-import logging
 from typing import TYPE_CHECKING
 
 from bring_api import (
@@ -13,22 +12,28 @@ from bring_api import (
 import voluptuous as vol
 
 from homeassistant.components.event import ATTR_EVENT_TYPE
+from homeassistant.components.todo import DOMAIN as TODO_DOMAIN
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import ATTR_ENTITY_ID
-from homeassistant.core import HomeAssistant, ServiceCall
+from homeassistant.core import HomeAssistant, ServiceCall, callback
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
-from homeassistant.helpers import config_validation as cv, entity_registry as er
-
-from .const import (
-    ATTR_ACTIVITY,
-    ATTR_REACTION,
-    ATTR_RECEIVER,
-    DOMAIN,
-    SERVICE_ACTIVITY_STREAM_REACTION,
+from homeassistant.helpers import (
+    config_validation as cv,
+    entity_registry as er,
+    service,
 )
+
+from .const import DOMAIN
 from .coordinator import BringConfigEntry
 
-_LOGGER = logging.getLogger(__name__)
+ATTR_ACTIVITY = "uuid"
+ATTR_ITEM_NAME = "item"
+ATTR_NOTIFICATION_TYPE = "message"
+ATTR_REACTION = "reaction"
+ATTR_RECEIVER = "publicUserUuid"
+
+SERVICE_PUSH_NOTIFICATION = "send_message"
+SERVICE_ACTIVITY_STREAM_REACTION = "send_reaction"
 
 SERVICE_ACTIVITY_STREAM_REACTION_SCHEMA = vol.Schema(
     {
@@ -54,6 +59,7 @@ def get_config_entry(hass: HomeAssistant, entry_id: str) -> BringConfigEntry:
     return entry
 
 
+@callback
 def async_setup_services(hass: HomeAssistant) -> None:
     """Set up services for Bring! integration."""
 
@@ -108,3 +114,17 @@ def async_setup_services(hass: HomeAssistant) -> None:
         async_send_activity_stream_reaction,
         SERVICE_ACTIVITY_STREAM_REACTION_SCHEMA,
     )
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_PUSH_NOTIFICATION,
+        entity_domain=TODO_DOMAIN,
+        schema={
+            vol.Required(ATTR_NOTIFICATION_TYPE): vol.All(
+                vol.Upper, vol.Coerce(BringNotificationType)
+            ),
+            vol.Optional(ATTR_ITEM_NAME): cv.string,
+        },
+        func="async_send_message",
+    )

homeassistant/components/bring/todo.py

@@ -13,7 +13,6 @@ from bring_api import (
     BringNotificationType,
     BringRequestException,
 )
-import voluptuous as vol
 
 from homeassistant.components.todo import (
     TodoItem,
@@ -23,15 +22,9 @@ from homeassistant.components.todo import (
 )
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
-from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import (
-    ATTR_ITEM_NAME,
-    ATTR_NOTIFICATION_TYPE,
-    DOMAIN,
-    SERVICE_PUSH_NOTIFICATION,
-)
+from .const import DOMAIN
 from .coordinator import BringConfigEntry, BringData, BringDataUpdateCoordinator
 from .entity import BringBaseEntity
 
@@ -63,19 +56,6 @@ async def async_setup_entry(
     coordinator.async_add_listener(add_entities)
     add_entities()
 
-    platform = entity_platform.async_get_current_platform()
-
-    platform.async_register_entity_service(
-        SERVICE_PUSH_NOTIFICATION,
-        {
-            vol.Required(ATTR_NOTIFICATION_TYPE): vol.All(
-                vol.Upper, vol.Coerce(BringNotificationType)
-            ),
-            vol.Optional(ATTR_ITEM_NAME): cv.string,
-        },
-        "async_send_message",
-    )
-
 
 class BringTodoListEntity(BringBaseEntity, TodoListEntity):
     """A To-do List representation of the Bring! Shopping List."""

homeassistant/components/climate/__init__.py

@@ -49,6 +49,7 @@ from .const import (  # noqa: F401
     ATTR_SWING_HORIZONTAL_MODES,
     ATTR_SWING_MODE,
     ATTR_SWING_MODES,
+    ATTR_TARGET_HUMIDITY_STEP,
     ATTR_TARGET_TEMP_HIGH,
     ATTR_TARGET_TEMP_LOW,
     ATTR_TARGET_TEMP_STEP,
@@ -234,6 +235,7 @@ CACHED_PROPERTIES_WITH_ATTR_ = {
     "max_temp",
     "min_humidity",
     "max_humidity",
+    "target_humidity_step",
 }
 
 
@@ -249,6 +251,7 @@ class ClimateEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
             ATTR_MAX_TEMP,
             ATTR_MIN_HUMIDITY,
             ATTR_MAX_HUMIDITY,
+            ATTR_TARGET_HUMIDITY_STEP,
             ATTR_TARGET_TEMP_STEP,
             ATTR_PRESET_MODES,
         }
@@ -275,6 +278,7 @@ class ClimateEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
     _attr_swing_horizontal_mode: str | None
     _attr_swing_horizontal_modes: list[str] | None
     _attr_target_humidity: float | None = None
+    _attr_target_humidity_step: int | None = None
     _attr_target_temperature_high: float | None
     _attr_target_temperature_low: float | None
     _attr_target_temperature_step: float | None = None
@@ -323,6 +327,9 @@ class ClimateEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
             data[ATTR_MIN_HUMIDITY] = self.min_humidity
             data[ATTR_MAX_HUMIDITY] = self.max_humidity
 
+            if self.target_humidity_step is not None:
+                data[ATTR_TARGET_HUMIDITY_STEP] = self.target_humidity_step
+
         if ClimateEntityFeature.FAN_MODE in supported_features:
             data[ATTR_FAN_MODES] = self.fan_modes
 
@@ -728,6 +735,11 @@ class ClimateEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
         """Return the maximum humidity."""
         return self._attr_max_humidity
 
+    @cached_property
+    def target_humidity_step(self) -> int | None:
+        """Return the supported step of humidity."""
+        return self._attr_target_humidity_step
+
 
 async def async_service_humidity_set(
     entity: ClimateEntity, service_call: ServiceCall

homeassistant/components/climate/const.py

@@ -114,6 +114,7 @@ ATTR_SWING_MODES = "swing_modes"
 ATTR_SWING_MODE = "swing_mode"
 ATTR_SWING_HORIZONTAL_MODE = "swing_horizontal_mode"
 ATTR_SWING_HORIZONTAL_MODES = "swing_horizontal_modes"
+ATTR_TARGET_HUMIDITY_STEP = "target_humidity_step"
 ATTR_TARGET_TEMP_HIGH = "target_temp_high"
 ATTR_TARGET_TEMP_LOW = "target_temp_low"
 ATTR_TARGET_TEMP_STEP = "target_temp_step"

homeassistant/components/cloud/entity.py

@@ -459,8 +459,17 @@ class BaseCloudLLMEntity(Entity):
         last_content: Any = chat_log.content[-1]
         if last_content.role == "user" and last_content.attachments:
             files = await self._async_prepare_files_for_prompt(last_content.attachments)
-            current_content = last_content.content
-            last_content = [*(current_content or []), *files]
+
+            last_message = cast(dict[str, Any], messages[-1])
+            assert (
+                last_message["type"] == "message"
+                and last_message["role"] == "user"
+                and isinstance(last_message["content"], str)
+            )
+            last_message["content"] = [
+                {"type": "input_text", "text": last_message["content"]},
+                *files,
+            ]
 
         tools: list[ToolParam] = []
         tool_choice: str | None = None

homeassistant/components/compit/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["compit"],
   "quality_scale": "bronze",
-  "requirements": ["compit-inext-api==0.7.0"]
+  "requirements": ["compit-inext-api==0.8.0"]
 }

homeassistant/components/demo/climate.py

@@ -67,6 +67,7 @@ async def async_setup_entry(
                 target_temp_high=None,
                 target_temp_low=None,
                 hvac_modes=[cls for cls in HVACMode if cls != HVACMode.HEAT_COOL],
+                target_humidity_step=5,
             ),
             DemoClimate(
                 unique_id="climate_3",
@@ -118,6 +119,7 @@ class DemoClimate(ClimateEntity):
         target_temp_low: float | None,
         hvac_modes: list[HVACMode],
         preset_modes: list[str] | None = None,
+        target_humidity_step: int | None = None,
     ) -> None:
         """Initialize the climate device."""
         self._unique_id = unique_id
@@ -163,6 +165,7 @@ class DemoClimate(ClimateEntity):
             identifiers={(DOMAIN, unique_id)},
             name=device_name,
         )
+        self._attr_target_humidity_step = target_humidity_step
 
     @property
     def unique_id(self) -> str:

homeassistant/components/denonavr/__init__.py

@@ -9,8 +9,9 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, EVENT_HOMEASSISTANT_STOP, Platform
 from homeassistant.core import Event, HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import entity_registry as er
+from homeassistant.helpers import config_validation as cv, entity_registry as er
 from homeassistant.helpers.httpx_client import get_async_client
+from homeassistant.helpers.typing import ConfigType
 
 from .const import (
     CONF_SHOW_ALL_SOURCES,
@@ -24,9 +25,12 @@ from .const import (
     DEFAULT_USE_TELNET,
     DEFAULT_ZONE2,
     DEFAULT_ZONE3,
+    DOMAIN,
 )
 from .receiver import ConnectDenonAVR
+from .services import async_setup_services
 
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 PLATFORMS = [Platform.MEDIA_PLAYER]
 
 _LOGGER = logging.getLogger(__name__)
@@ -34,6 +38,12 @@ _LOGGER = logging.getLogger(__name__)
 type DenonavrConfigEntry = ConfigEntry[DenonAVR]
 
 
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the component."""
+    async_setup_services(hass)
+    return True
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: DenonavrConfigEntry) -> bool:
     """Set up the denonavr components from a config entry."""
     # Connect to receiver

homeassistant/components/denonavr/const.py

@@ -2,6 +2,7 @@
 
 DOMAIN = "denonavr"
 
+ATTR_DYNAMIC_EQ = "dynamic_eq"
 
 CONF_SHOW_ALL_SOURCES = "show_all_sources"
 CONF_ZONE2 = "zone2"

homeassistant/components/denonavr/manifest.json

@@ -7,7 +7,7 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["denonavr"],
-  "requirements": ["denonavr==1.2.0"],
+  "requirements": ["denonavr==1.3.1"],
   "ssdp": [
     {
       "deviceType": "urn:schemas-upnp-org:device:MediaRenderer:1",

homeassistant/components/denonavr/media_player.py

@@ -26,7 +26,6 @@ from denonavr.exceptions import (
     AvrTimoutError,
     DenonAvrError,
 )
-import voluptuous as vol
 
 from homeassistant.components.media_player import (
     MediaPlayerDeviceClass,
@@ -35,14 +34,14 @@ from homeassistant.components.media_player import (
     MediaPlayerState,
     MediaType,
 )
-from homeassistant.const import ATTR_COMMAND, CONF_HOST, CONF_MODEL, CONF_TYPE
+from homeassistant.const import CONF_HOST, CONF_MODEL, CONF_TYPE
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import DenonavrConfigEntry
 from .const import (
+    ATTR_DYNAMIC_EQ,
     CONF_MANUFACTURER,
     CONF_SERIAL_NUMBER,
     CONF_UPDATE_AUDYSSEY,
@@ -53,7 +52,6 @@ from .const import (
 _LOGGER = logging.getLogger(__name__)
 
 ATTR_SOUND_MODE_RAW = "sound_mode_raw"
-ATTR_DYNAMIC_EQ = "dynamic_eq"
 
 SUPPORT_DENON = (
     MediaPlayerEntityFeature.VOLUME_STEP
@@ -76,11 +74,6 @@ SUPPORT_MEDIA_MODES = (
 SCAN_INTERVAL = timedelta(seconds=10)
 PARALLEL_UPDATES = 1
 
-# Services
-SERVICE_GET_COMMAND = "get_command"
-SERVICE_SET_DYNAMIC_EQ = "set_dynamic_eq"
-SERVICE_UPDATE_AUDYSSEY = "update_audyssey"
-
 # HA Telnet events
 TELNET_EVENTS = {
     "HD",
@@ -134,24 +127,6 @@ async def async_setup_entry(
         "%s receiver at host %s initialized", receiver.manufacturer, receiver.host
     )
 
-    # Register additional services
-    platform = entity_platform.async_get_current_platform()
-    platform.async_register_entity_service(
-        SERVICE_GET_COMMAND,
-        {vol.Required(ATTR_COMMAND): cv.string},
-        f"async_{SERVICE_GET_COMMAND}",
-    )
-    platform.async_register_entity_service(
-        SERVICE_SET_DYNAMIC_EQ,
-        {vol.Required(ATTR_DYNAMIC_EQ): cv.boolean},
-        f"async_{SERVICE_SET_DYNAMIC_EQ}",
-    )
-    platform.async_register_entity_service(
-        SERVICE_UPDATE_AUDYSSEY,
-        None,
-        f"async_{SERVICE_UPDATE_AUDYSSEY}",
-    )
-
     async_add_entities(entities, update_before_add=True)
 
 

homeassistant/components/denonavr/services.py

@@ -0,0 +1,47 @@
+"""Support for Denon AVR receivers using their HTTP interface."""
+
+from __future__ import annotations
+
+import voluptuous as vol
+
+from homeassistant.components.media_player import DOMAIN as MEDIA_PLAYER_DOMAIN
+from homeassistant.const import ATTR_COMMAND
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import config_validation as cv, service
+
+from .const import ATTR_DYNAMIC_EQ, DOMAIN
+
+# Services
+SERVICE_GET_COMMAND = "get_command"
+SERVICE_SET_DYNAMIC_EQ = "set_dynamic_eq"
+SERVICE_UPDATE_AUDYSSEY = "update_audyssey"
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Set up services."""
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_GET_COMMAND,
+        entity_domain=MEDIA_PLAYER_DOMAIN,
+        schema={vol.Required(ATTR_COMMAND): cv.string},
+        func=f"async_{SERVICE_GET_COMMAND}",
+    )
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_SET_DYNAMIC_EQ,
+        entity_domain=MEDIA_PLAYER_DOMAIN,
+        schema={vol.Required(ATTR_DYNAMIC_EQ): cv.boolean},
+        func=f"async_{SERVICE_SET_DYNAMIC_EQ}",
+    )
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_UPDATE_AUDYSSEY,
+        entity_domain=MEDIA_PLAYER_DOMAIN,
+        schema=None,
+        func=f"async_{SERVICE_UPDATE_AUDYSSEY}",
+    )

homeassistant/components/ecovacs/__init__.py

@@ -5,8 +5,12 @@ from sucks import VacBot
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.typing import ConfigType
 
+from .const import DOMAIN
 from .controller import EcovacsController
+from .services import async_setup_services
 
 PLATFORMS = [
     Platform.BINARY_SENSOR,
@@ -22,6 +26,14 @@ PLATFORMS = [
 ]
 type EcovacsConfigEntry = ConfigEntry[EcovacsController]
 
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the component."""
+    async_setup_services(hass)
+    return True
+
 
 async def async_setup_entry(hass: HomeAssistant, entry: EcovacsConfigEntry) -> bool:
     """Set up this integration using UI."""

homeassistant/components/ecovacs/services.py

@@ -0,0 +1,27 @@
+"""Ecovacs services."""
+
+from __future__ import annotations
+
+from homeassistant.components.vacuum import DOMAIN as VACUUM_DOMAIN
+from homeassistant.core import HomeAssistant, SupportsResponse, callback
+from homeassistant.helpers import service
+
+from .const import DOMAIN
+
+SERVICE_RAW_GET_POSITIONS = "raw_get_positions"
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Set up services."""
+
+    # Vacuum Services
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_RAW_GET_POSITIONS,
+        entity_domain=VACUUM_DOMAIN,
+        schema=None,
+        func="async_raw_get_positions",
+        supports_response=SupportsResponse.ONLY,
+    )

homeassistant/components/ecovacs/vacuum.py

@@ -18,9 +18,8 @@ from homeassistant.components.vacuum import (
     VacuumActivity,
     VacuumEntityFeature,
 )
-from homeassistant.core import HomeAssistant, SupportsResponse
+from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ServiceValidationError
-from homeassistant.helpers import entity_platform
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import slugify
 
@@ -32,9 +31,6 @@ from .util import get_name_key
 _LOGGER = logging.getLogger(__name__)
 
 ATTR_ERROR = "error"
-ATTR_COMPONENT_PREFIX = "component_"
-
-SERVICE_RAW_GET_POSITIONS = "raw_get_positions"
 
 
 async def async_setup_entry(
@@ -56,14 +52,6 @@ async def async_setup_entry(
     _LOGGER.debug("Adding Ecovacs Vacuums to Home Assistant: %s", vacuums)
     async_add_entities(vacuums)
 
-    platform = entity_platform.async_get_current_platform()
-    platform.async_register_entity_service(
-        SERVICE_RAW_GET_POSITIONS,
-        None,
-        "async_raw_get_positions",
-        supports_response=SupportsResponse.ONLY,
-    )
-
 
 class EcovacsLegacyVacuum(EcovacsLegacyEntity, StateVacuumEntity):
     """Legacy Ecovacs vacuums."""

homeassistant/components/elgato/__init__.py

@@ -2,12 +2,23 @@
 
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.typing import ConfigType
 
+from .const import DOMAIN
 from .coordinator import ElgatoConfigEntry, ElgatoDataUpdateCoordinator
+from .services import async_setup_services
 
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 PLATFORMS = [Platform.BUTTON, Platform.LIGHT, Platform.SENSOR, Platform.SWITCH]
 
 
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the component."""
+    async_setup_services(hass)
+    return True
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: ElgatoConfigEntry) -> bool:
     """Set up Elgato Light from a config entry."""
     coordinator = ElgatoDataUpdateCoordinator(hass, entry)

homeassistant/components/elgato/const.py

@@ -14,6 +14,3 @@ SCAN_INTERVAL = timedelta(seconds=10)
 
 # Attributes
 ATTR_ON = "on"
-
-# Services
-SERVICE_IDENTIFY = "identify"

homeassistant/components/elgato/light.py

@@ -15,13 +15,9 @@ from homeassistant.components.light import (
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.entity_platform import (
-    AddConfigEntryEntitiesCallback,
-    async_get_current_platform,
-)
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import color as color_util
 
-from .const import SERVICE_IDENTIFY
 from .coordinator import ElgatoConfigEntry, ElgatoDataUpdateCoordinator
 from .entity import ElgatoEntity
 
@@ -37,13 +33,6 @@ async def async_setup_entry(
     coordinator = entry.runtime_data
     async_add_entities([ElgatoLight(coordinator)])
 
-    platform = async_get_current_platform()
-    platform.async_register_entity_service(
-        SERVICE_IDENTIFY,
-        None,
-        ElgatoLight.async_identify.__name__,
-    )
-
 
 class ElgatoLight(ElgatoEntity, LightEntity):
     """Defines an Elgato Light."""

homeassistant/components/elgato/services.py

@@ -0,0 +1,25 @@
+"""Support for Elgato services."""
+
+from __future__ import annotations
+
+from homeassistant.components.light import DOMAIN as LIGHT_DOMAIN
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import service
+
+from .const import DOMAIN
+
+SERVICE_IDENTIFY = "identify"
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Set up services."""
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_IDENTIFY,
+        entity_domain=LIGHT_DOMAIN,
+        schema=None,
+        func="async_identify",
+    )

homeassistant/components/epson/__init__.py

@@ -11,11 +11,15 @@ from epson_projector.const import (
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.typing import ConfigType
 
-from .const import CONF_CONNECTION_TYPE, HTTP
+from .const import CONF_CONNECTION_TYPE, DOMAIN, HTTP
 from .exceptions import CannotConnect, PoweredOff
+from .services import async_setup_services
 
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 PLATFORMS = [Platform.MEDIA_PLAYER]
 
 _LOGGER = logging.getLogger(__name__)
@@ -47,6 +51,12 @@ async def validate_projector(
     return epson_proj
 
 
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the component."""
+    async_setup_services(hass)
+    return True
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: EpsonConfigEntry) -> bool:
     """Set up epson from a config entry."""
     projector = await validate_projector(

homeassistant/components/epson/const.py

@@ -1,7 +1,7 @@
 """Constants for the epson integration."""
 
 DOMAIN = "epson"
-SERVICE_SELECT_CMODE = "select_cmode"
+
 CONF_CONNECTION_TYPE = "connection_type"
 
 ATTR_CMODE = "cmode"

homeassistant/components/epson/media_player.py

@@ -27,7 +27,6 @@ from epson_projector.const import (
     VOL_UP,
     VOLUME,
 )
-import voluptuous as vol
 
 from homeassistant.components.media_player import (
     MediaPlayerEntity,
@@ -36,17 +35,12 @@ from homeassistant.components.media_player import (
 )
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import (
-    config_validation as cv,
-    device_registry as dr,
-    entity_platform,
-    entity_registry as er,
-)
+from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import EpsonConfigEntry
-from .const import ATTR_CMODE, DOMAIN, SERVICE_SELECT_CMODE
+from .const import ATTR_CMODE, DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -63,12 +57,6 @@ async def async_setup_entry(
         entry=config_entry,
     )
     async_add_entities([projector_entity], True)
-    platform = entity_platform.async_get_current_platform()
-    platform.async_register_entity_service(
-        SERVICE_SELECT_CMODE,
-        {vol.Required(ATTR_CMODE): vol.All(cv.string, vol.Any(*CMODE_LIST_SET))},
-        SERVICE_SELECT_CMODE,
-    )
 
 
 class EpsonProjectorMediaPlayer(MediaPlayerEntity):

homeassistant/components/epson/services.py

@@ -0,0 +1,27 @@
+"""Support for Epson projector."""
+
+from __future__ import annotations
+
+from epson_projector.const import CMODE_LIST_SET
+import voluptuous as vol
+
+from homeassistant.components.media_player import DOMAIN as MEDIA_PLAYER_DOMAIN
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import config_validation as cv, service
+
+from .const import ATTR_CMODE, DOMAIN
+
+SERVICE_SELECT_CMODE = "select_cmode"
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Set up services."""
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_SELECT_CMODE,
+        entity_domain=MEDIA_PLAYER_DOMAIN,
+        schema={vol.Required(ATTR_CMODE): vol.All(cv.string, vol.Any(*CMODE_LIST_SET))},
+        func=SERVICE_SELECT_CMODE,
+    )

homeassistant/components/esphome/manifest.json

@@ -19,7 +19,7 @@
   "requirements": [
     "aioesphomeapi==43.14.0",
     "esphome-dashboard-api==1.3.0",
-    "bleak-esphome==3.5.0"
+    "bleak-esphome==3.6.0"
   ],
   "zeroconf": ["_esphomelib._tcp.local."]
 }

homeassistant/components/evohome/entity.py

@@ -181,7 +181,7 @@ class EvoChild(EvoEntity):
 
         self._device_state_attrs = {
             "activeFaults": self._evo_device.active_faults,
-            "setpoints": self._setpoints,
+            "setpoints": self.setpoints,
         }
 
         super()._handle_coordinator_update()

homeassistant/components/file_upload/__init__.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Iterator
+from collections.abc import Generator
 from contextlib import contextmanager
 from dataclasses import dataclass
 from pathlib import Path
@@ -35,7 +35,7 @@ CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
 
 
 @contextmanager
-def process_uploaded_file(hass: HomeAssistant, file_id: str) -> Iterator[Path]:
+def process_uploaded_file(hass: HomeAssistant, file_id: str) -> Generator[Path]:
     """Get an uploaded file.
 
     File is removed at the end of the context.

homeassistant/components/fjaraskupan/coordinator.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from collections.abc import AsyncIterator
+from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager, contextmanager
 from datetime import timedelta
 import logging
@@ -132,7 +132,7 @@ class FjaraskupanCoordinator(DataUpdateCoordinator[State]):
         self.async_set_updated_data(self.device.state)
 
     @asynccontextmanager
-    async def async_connect_and_update(self) -> AsyncIterator[Device]:
+    async def async_connect_and_update(self) -> AsyncGenerator[Device]:
         """Provide an up-to-date device for use during connections."""
         if (
             ble_device := async_ble_device_from_address(

homeassistant/components/fressnapf_tracker/__init__.py

@@ -1,11 +1,22 @@
 """The Fressnapf Tracker integration."""
 
-from fressnapftracker import AuthClient, FressnapfTrackerAuthenticationError
+import logging
+
+from fressnapftracker import (
+    ApiClient,
+    AuthClient,
+    Device,
+    FressnapfTrackerAuthenticationError,
+    FressnapfTrackerError,
+    FressnapfTrackerInvalidTrackerResponseError,
+    Tracker,
+)
 
 from homeassistant.const import CONF_ACCESS_TOKEN, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers.httpx_client import get_async_client
+from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
 
 from .const import CONF_USER_ID, DOMAIN
 from .coordinator import (
@@ -21,6 +32,43 @@ PLATFORMS: list[Platform] = [
     Platform.SWITCH,
 ]
 
+_LOGGER = logging.getLogger(__name__)
+
+
+async def _get_valid_tracker(hass: HomeAssistant, device: Device) -> Tracker | None:
+    """Test if the tracker returns valid data and return it.
+
+    Malformed data might indicate the tracker is broken or hasn't been properly registered with the app.
+    """
+    client = ApiClient(
+        serial_number=device.serialnumber,
+        device_token=device.token,
+        client=get_async_client(hass),
+    )
+    try:
+        return await client.get_tracker()
+    except FressnapfTrackerInvalidTrackerResponseError:
+        _LOGGER.warning(
+            "Tracker with serialnumber %s is invalid. Consider removing it via the App",
+            device.serialnumber,
+        )
+        async_create_issue(
+            hass,
+            DOMAIN,
+            f"invalid_fressnapf_tracker_{device.serialnumber}",
+            issue_domain=DOMAIN,
+            learn_more_url="https://www.home-assistant.io/integrations/fressnapf_tracker/",
+            is_fixable=False,
+            severity=IssueSeverity.WARNING,
+            translation_key="invalid_fressnapf_tracker",
+            translation_placeholders={
+                "tracker_id": device.serialnumber,
+            },
+        )
+        return None
+    except FressnapfTrackerError as err:
+        raise ConfigEntryNotReady(err) from err
+
 
 async def async_setup_entry(
     hass: HomeAssistant, entry: FressnapfTrackerConfigEntry
@@ -40,12 +88,15 @@ async def async_setup_entry(
 
     coordinators: list[FressnapfTrackerDataUpdateCoordinator] = []
     for device in devices:
+        tracker = await _get_valid_tracker(hass, device)
+        if tracker is None:
+            continue
         coordinator = FressnapfTrackerDataUpdateCoordinator(
             hass,
             entry,
             device,
+            initial_data=tracker,
         )
-        await coordinator.async_config_entry_first_refresh()
         coordinators.append(coordinator)
 
     entry.runtime_data = coordinators

homeassistant/components/fressnapf_tracker/coordinator.py

@@ -34,6 +34,7 @@ class FressnapfTrackerDataUpdateCoordinator(DataUpdateCoordinator[Tracker]):
         hass: HomeAssistant,
         config_entry: FressnapfTrackerConfigEntry,
         device: Device,
+        initial_data: Tracker,
     ) -> None:
         """Initialize."""
         super().__init__(
@@ -49,6 +50,7 @@ class FressnapfTrackerDataUpdateCoordinator(DataUpdateCoordinator[Tracker]):
             device_token=device.token,
             client=get_async_client(hass),
         )
+        self.data = initial_data
 
     async def _async_update_data(self) -> Tracker:
         try:

homeassistant/components/fressnapf_tracker/strings.json

@@ -92,5 +92,11 @@
     "not_seen_recently": {
       "message": "The flashlight cannot be activated when the tracker has not moved recently."
     }
+  },
+  "issues": {
+    "invalid_fressnapf_tracker": {
+      "description": "The Fressnapf GPS tracker with the serial number `{tracker_id}` is sending invalid data. This most likely indicates the tracker is broken or hasn't been properly registered with the app. Please remove the tracker via the Fressnapf app. You can then close this issue.",
+      "title": "Invalid Fressnapf GPS tracker detected"
+    }
   }
 }

homeassistant/components/frontend/__init__.py

@@ -7,6 +7,7 @@ from functools import lru_cache, partial
 import logging
 import os
 import pathlib
+import shutil
 from typing import Any, TypedDict
 
 from aiohttp import hdrs, web, web_urldispatcher
@@ -36,6 +37,7 @@ from homeassistant.helpers.typing import ConfigType
 from homeassistant.loader import async_get_integration, bind_hass
 from homeassistant.util.hass_dict import HassKey
 
+from .pr_download import download_pr_artifact
 from .storage import (
     async_setup_frontend_storage,
     async_system_store as async_system_store,
@@ -55,6 +57,10 @@ CONF_EXTRA_MODULE_URL = "extra_module_url"
 CONF_EXTRA_JS_URL_ES5 = "extra_js_url_es5"
 CONF_FRONTEND_REPO = "development_repo"
 CONF_JS_VERSION = "javascript_version"
+CONF_DEVELOPMENT_PR = "development_pr"
+CONF_GITHUB_TOKEN = "github_token"
+
+DEV_ARTIFACTS_DIR = "development_artifacts"
 
 DEFAULT_THEME_COLOR = "#2980b9"
 
@@ -133,6 +139,8 @@ CONFIG_SCHEMA = vol.Schema(
         DOMAIN: vol.Schema(
             {
                 vol.Optional(CONF_FRONTEND_REPO): cv.isdir,
+                vol.Inclusive(CONF_DEVELOPMENT_PR, "development_pr"): cv.positive_int,
+                vol.Inclusive(CONF_GITHUB_TOKEN, "development_pr"): cv.string,
                 vol.Optional(CONF_THEMES): vol.All(dict, _validate_themes),
                 vol.Optional(CONF_EXTRA_MODULE_URL): vol.All(
                     cv.ensure_list, [cv.string]
@@ -425,6 +433,49 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
             )
 
     repo_path = conf.get(CONF_FRONTEND_REPO)
+    dev_pr_number = conf.get(CONF_DEVELOPMENT_PR)
+
+    pr_cache_dir = pathlib.Path(hass.config.cache_path(DOMAIN, DEV_ARTIFACTS_DIR))
+    if not dev_pr_number and pr_cache_dir.exists():
+        try:
+            await hass.async_add_executor_job(shutil.rmtree, pr_cache_dir)
+            _LOGGER.debug("Cleaned up frontend development artifacts")
+        except OSError as err:
+            _LOGGER.warning(
+                "Could not clean up frontend development artifacts: %s", err
+            )
+
+    # Priority: development_repo > development_pr > integrated
+    if repo_path and dev_pr_number:
+        _LOGGER.warning(
+            "Both development_repo and development_pr are specified for frontend. "
+            "Using development_repo, remove development_repo to use "
+            "automatic PR download"
+        )
+        dev_pr_number = None
+
+    if dev_pr_number:
+        github_token: str = conf[CONF_GITHUB_TOKEN]
+
+        try:
+            dev_pr_dir = await download_pr_artifact(
+                hass, dev_pr_number, github_token, pr_cache_dir
+            )
+            repo_path = str(dev_pr_dir)
+            _LOGGER.info("Using frontend from PR #%s", dev_pr_number)
+        except HomeAssistantError as err:
+            _LOGGER.error(
+                "Failed to download PR #%s: %s, falling back to the integrated frontend",
+                dev_pr_number,
+                err,
+            )
+        except Exception:  # pylint: disable=broad-exception-caught
+            _LOGGER.exception(
+                "Unexpected error downloading PR #%s, "
+                "falling back to the integrated frontend",
+                dev_pr_number,
+            )
+
     is_dev = repo_path is not None
     root_path = _frontend_root(repo_path)
 

homeassistant/components/frontend/manifest.json

@@ -21,5 +21,5 @@
   "integration_type": "system",
   "preview_features": { "winter_mode": {} },
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20260128.3"]
+  "requirements": ["home-assistant-frontend==20260128.6"]
 }

homeassistant/components/frontend/pr_download.py

@@ -0,0 +1,242 @@
+"""GitHub PR artifact download functionality for frontend development."""
+
+from __future__ import annotations
+
+import io
+import logging
+import pathlib
+import shutil
+import zipfile
+
+from aiogithubapi import (
+    GitHubAPI,
+    GitHubAuthenticationException,
+    GitHubException,
+    GitHubNotFoundException,
+    GitHubPermissionException,
+    GitHubRatelimitException,
+)
+from aiohttp import ClientError, ClientResponseError, ClientTimeout
+
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+_LOGGER = logging.getLogger(__name__)
+
+GITHUB_REPO = "home-assistant/frontend"
+ARTIFACT_NAME = "frontend-build"
+
+# Zip bomb protection limits (10x typical frontend build size)
+# Typical frontend build: ~4500 files, ~135MB uncompressed
+MAX_ZIP_FILES = 50000
+MAX_ZIP_SIZE = 1500 * 1024 * 1024  # 1.5GB
+
+ERROR_INVALID_TOKEN = (
+    "GitHub token is invalid or expired. "
+    "Please check your github_token in the frontend configuration. "
+    "Generate a new token at https://github.com/settings/tokens"
+)
+ERROR_RATE_LIMIT = (
+    "GitHub API rate limit exceeded or token lacks permissions. "
+    "Ensure your token has 'repo' or 'public_repo' scope"
+)
+
+
+async def _get_pr_head_sha(client: GitHubAPI, pr_number: int) -> str:
+    """Get the head SHA for the PR."""
+    try:
+        response = await client.generic(
+            endpoint=f"/repos/home-assistant/frontend/pulls/{pr_number}",
+        )
+        return str(response.data["head"]["sha"])
+    except GitHubAuthenticationException as err:
+        raise HomeAssistantError(ERROR_INVALID_TOKEN) from err
+    except (GitHubRatelimitException, GitHubPermissionException) as err:
+        raise HomeAssistantError(ERROR_RATE_LIMIT) from err
+    except GitHubNotFoundException as err:
+        raise HomeAssistantError(
+            f"PR #{pr_number} does not exist in repository {GITHUB_REPO}"
+        ) from err
+    except GitHubException as err:
+        raise HomeAssistantError(f"GitHub API error: {err}") from err
+
+
+async def _find_pr_artifact(client: GitHubAPI, pr_number: int, head_sha: str) -> str:
+    """Find the build artifact for the given PR and commit SHA.
+
+    Returns the artifact download URL.
+    """
+    try:
+        response = await client.generic(
+            endpoint="/repos/home-assistant/frontend/actions/workflows/ci.yaml/runs",
+            params={"head_sha": head_sha, "per_page": 10},
+        )
+
+        for run in response.data.get("workflow_runs", []):
+            if run["status"] == "completed" and run["conclusion"] == "success":
+                artifacts_response = await client.generic(
+                    endpoint=f"/repos/home-assistant/frontend/actions/runs/{run['id']}/artifacts",
+                )
+
+                for artifact in artifacts_response.data.get("artifacts", []):
+                    if artifact["name"] == ARTIFACT_NAME:
+                        _LOGGER.info(
+                            "Found artifact '%s' from CI run #%s",
+                            ARTIFACT_NAME,
+                            run["id"],
+                        )
+                        return str(artifact["archive_download_url"])
+
+        raise HomeAssistantError(
+            f"No '{ARTIFACT_NAME}' artifact found for PR #{pr_number}. "
+            "Possible reasons: CI has not run yet or is running, "
+            "or the build failed, or the PR artifact expired. "
+            f"Check https://github.com/{GITHUB_REPO}/pull/{pr_number}/checks"
+        )
+    except GitHubAuthenticationException as err:
+        raise HomeAssistantError(ERROR_INVALID_TOKEN) from err
+    except (GitHubRatelimitException, GitHubPermissionException) as err:
+        raise HomeAssistantError(ERROR_RATE_LIMIT) from err
+    except GitHubException as err:
+        raise HomeAssistantError(f"GitHub API error: {err}") from err
+
+
+async def _download_artifact_data(
+    hass: HomeAssistant, artifact_url: str, github_token: str
+) -> bytes:
+    """Download artifact data from GitHub."""
+    session = async_get_clientsession(hass)
+    headers = {
+        "Authorization": f"token {github_token}",
+        "Accept": "application/vnd.github+json",
+    }
+
+    try:
+        response = await session.get(
+            artifact_url, headers=headers, timeout=ClientTimeout(total=60)
+        )
+        response.raise_for_status()
+        return await response.read()
+    except ClientResponseError as err:
+        if err.status == 401:
+            raise HomeAssistantError(ERROR_INVALID_TOKEN) from err
+        if err.status == 403:
+            raise HomeAssistantError(ERROR_RATE_LIMIT) from err
+        raise HomeAssistantError(
+            f"Failed to download artifact: HTTP {err.status}"
+        ) from err
+    except TimeoutError as err:
+        raise HomeAssistantError(
+            "Timeout downloading artifact (>60s). Check your network connection"
+        ) from err
+    except ClientError as err:
+        raise HomeAssistantError(f"Network error downloading artifact: {err}") from err
+
+
+def _extract_artifact(
+    artifact_data: bytes,
+    cache_dir: pathlib.Path,
+    head_sha: str,
+) -> None:
+    """Extract artifact and save SHA (runs in executor)."""
+    frontend_dir = cache_dir / "hass_frontend"
+
+    if cache_dir.exists():
+        shutil.rmtree(cache_dir)
+    frontend_dir.mkdir(parents=True, exist_ok=True)
+
+    with zipfile.ZipFile(io.BytesIO(artifact_data)) as zip_file:
+        # Validate zip contents to protect against zip bombs
+        # See: https://github.com/python/cpython/issues/80643
+        total_size = 0
+        for file_count, info in enumerate(zip_file.infolist(), start=1):
+            total_size += info.file_size
+            if file_count > MAX_ZIP_FILES:
+                raise ValueError(
+                    f"Zip contains too many files (>{MAX_ZIP_FILES}), possible zip bomb"
+                )
+            if total_size > MAX_ZIP_SIZE:
+                raise ValueError(
+                    f"Zip uncompressed size too large (>{MAX_ZIP_SIZE} bytes), "
+                    "possible zip bomb"
+                )
+        zip_file.extractall(str(frontend_dir))
+
+    # Save the commit SHA for cache validation
+    sha_file = cache_dir / ".sha"
+    sha_file.write_text(head_sha)
+
+
+async def download_pr_artifact(
+    hass: HomeAssistant,
+    pr_number: int,
+    github_token: str,
+    tmp_dir: pathlib.Path,
+) -> pathlib.Path:
+    """Download and extract frontend PR artifact from GitHub.
+
+    Returns the path to the tmp directory containing hass_frontend/.
+    Raises HomeAssistantError on failure.
+    """
+    try:
+        session = async_get_clientsession(hass)
+    except Exception as err:
+        raise HomeAssistantError(f"Failed to get HTTP client session: {err}") from err
+
+    client = GitHubAPI(token=github_token, session=session)
+
+    head_sha = await _get_pr_head_sha(client, pr_number)
+
+    frontend_dir = tmp_dir / "hass_frontend"
+    sha_file = tmp_dir / ".sha"
+
+    if frontend_dir.exists() and sha_file.exists():
+        try:
+            cached_sha = await hass.async_add_executor_job(sha_file.read_text)
+            if cached_sha.strip() == head_sha:
+                _LOGGER.info(
+                    "Using cached PR #%s (commit %s) from %s",
+                    pr_number,
+                    head_sha[:8],
+                    tmp_dir,
+                )
+                return tmp_dir
+            _LOGGER.info(
+                "PR #%s has new commits (cached: %s, current: %s), re-downloading",
+                pr_number,
+                cached_sha[:8],
+                head_sha[:8],
+            )
+        except OSError as err:
+            _LOGGER.debug("Failed to read cache SHA file: %s", err)
+
+    artifact_url = await _find_pr_artifact(client, pr_number, head_sha)
+
+    _LOGGER.info("Downloading frontend PR #%s artifact", pr_number)
+    artifact_data = await _download_artifact_data(hass, artifact_url, github_token)
+
+    try:
+        await hass.async_add_executor_job(
+            _extract_artifact, artifact_data, tmp_dir, head_sha
+        )
+    except zipfile.BadZipFile as err:
+        raise HomeAssistantError(
+            f"Downloaded artifact for PR #{pr_number} is corrupted or invalid"
+        ) from err
+    except ValueError as err:
+        raise HomeAssistantError(
+            f"Downloaded artifact for PR #{pr_number} failed validation: {err}"
+        ) from err
+    except OSError as err:
+        raise HomeAssistantError(
+            f"Failed to extract artifact for PR #{pr_number}: {err}"
+        ) from err
+
+    _LOGGER.info(
+        "Successfully downloaded and extracted PR #%s (commit %s) to %s",
+        pr_number,
+        head_sha[:8],
+        tmp_dir,
+    )
+    return tmp_dir

homeassistant/components/gpslogger/device_tracker.py

@@ -86,7 +86,7 @@ class GPSLoggerEntity(TrackerEntity, RestoreEntity):
         )
 
     @property
-    def battery_level(self):
+    def battery_level(self) -> int | None:
         """Return battery value of the device."""
         return self._battery
 

homeassistant/components/growatt_server/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["growattServer"],
-  "requirements": ["growattServer==1.7.1"]
+  "requirements": ["growattServer==1.9.0"]
 }

homeassistant/components/hikvision/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "local_push",
   "loggers": ["pyhik"],
   "quality_scale": "legacy",
-  "requirements": ["pyHik==0.4.1"]
+  "requirements": ["pyHik==0.4.2"]
 }

homeassistant/components/home_connect/sensor.py

@@ -115,7 +115,6 @@ SENSORS = (
         entity_category=EntityCategory.DIAGNOSTIC,
         native_unit_of_measurement=UnitOfVolume.MILLILITERS,
         device_class=SensorDeviceClass.VOLUME,
-        state_class=SensorStateClass.TOTAL_INCREASING,
         translation_key="hot_water_counter",
     ),
     HomeConnectSensorEntityDescription(

homeassistant/components/homeassistant_hardware/helpers.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from collections.abc import AsyncIterator, Awaitable, Callable
+from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Callable
 from contextlib import asynccontextmanager
 import logging
 from typing import TYPE_CHECKING, Protocol, TypedDict
@@ -281,7 +281,7 @@ def async_is_firmware_update_in_progress(hass: HomeAssistant, device: str) -> bo
 @asynccontextmanager
 async def async_firmware_update_context(
     hass: HomeAssistant, device: str, source_domain: str
-) -> AsyncIterator[None]:
+) -> AsyncGenerator[None]:
     """Register a device as having its firmware being actively updated."""
     async_register_firmware_update_in_progress(hass, device, source_domain)
 

homeassistant/components/homeassistant_hardware/util.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import asyncio
 from collections import defaultdict
-from collections.abc import AsyncIterator, Callable, Sequence
+from collections.abc import AsyncGenerator, Callable, Sequence
 from contextlib import AsyncExitStack, asynccontextmanager
 from dataclasses import dataclass
 from enum import StrEnum
@@ -125,7 +125,7 @@ class OwningAddon:
             return addon_info.state == AddonState.RUNNING
 
     @asynccontextmanager
-    async def temporarily_stop(self, hass: HomeAssistant) -> AsyncIterator[None]:
+    async def temporarily_stop(self, hass: HomeAssistant) -> AsyncGenerator[None]:
         """Temporarily stop the add-on, restarting it after completion."""
         addon_manager = self._get_addon_manager(hass)
 
@@ -165,7 +165,7 @@ class OwningIntegration:
         )
 
     @asynccontextmanager
-    async def temporarily_stop(self, hass: HomeAssistant) -> AsyncIterator[None]:
+    async def temporarily_stop(self, hass: HomeAssistant) -> AsyncGenerator[None]:
         """Temporarily stop the integration, restarting it after completion."""
         if (entry := hass.config_entries.async_get_entry(self.config_entry_id)) is None:
             yield
@@ -368,7 +368,7 @@ async def probe_silabs_firmware_type(
 @asynccontextmanager
 async def async_firmware_flashing_context(
     hass: HomeAssistant, device: str, source_domain: str
-) -> AsyncIterator[None]:
+) -> AsyncGenerator[None]:
     """Register a device as having its firmware being actively interacted with."""
     async with async_firmware_update_context(hass, device, source_domain):
         firmware_info = await guess_firmware_info(hass, device)

homeassistant/components/husqvarna_automower/__init__.py

@@ -1,21 +1,25 @@
 """The Husqvarna Automower integration."""
 
-import logging
-
 from aioautomower.session import AutomowerSession
 from aiohttp import ClientResponseError
 
 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
+from homeassistant.helpers import (
+    aiohttp_client,
+    config_entry_oauth2_flow,
+    config_validation as cv,
+)
+from homeassistant.helpers.typing import ConfigType
 from homeassistant.util import dt as dt_util
 
 from . import api
+from .const import DOMAIN
 from .coordinator import AutomowerConfigEntry, AutomowerDataUpdateCoordinator
+from .services import async_setup_services
 
-_LOGGER = logging.getLogger(__name__)
-
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 PLATFORMS: list[Platform] = [
     Platform.BINARY_SENSOR,
     Platform.BUTTON,
@@ -30,6 +34,12 @@ PLATFORMS: list[Platform] = [
 ]
 
 
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the component."""
+    async_setup_services(hass)
+    return True
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: AutomowerConfigEntry) -> bool:
     """Set up this integration using UI."""
     implementation = (

homeassistant/components/husqvarna_automower/const.py

@@ -142,3 +142,6 @@ ERROR_KEYS = [
     "wrong_pin_code",
     "zone_generator_problem",
 ]
+
+MOW = "mow"
+PARK = "park"

homeassistant/components/husqvarna_automower/lawn_mower.py

@@ -1,11 +1,9 @@
 """Husqvarna Automower lawn mower entity."""
 
 from datetime import timedelta
-import logging
 from typing import TYPE_CHECKING
 
 from aioautomower.model import MowerActivities, MowerStates, WorkArea
-import voluptuous as vol
 
 from homeassistant.components.lawn_mower import (
     LawnMowerActivity,
@@ -14,16 +12,13 @@ from homeassistant.components.lawn_mower import (
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ServiceValidationError
-from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import AutomowerConfigEntry
-from .const import DOMAIN, ERROR_STATES
+from .const import DOMAIN, ERROR_STATES, MOW, PARK
 from .coordinator import AutomowerDataUpdateCoordinator
 from .entity import AutomowerBaseEntity, handle_sending_exception
 
-_LOGGER = logging.getLogger(__name__)
-
 PARALLEL_UPDATES = 1
 
 DOCKED_ACTIVITIES = (MowerActivities.PARKED_IN_CS, MowerActivities.CHARGING)
@@ -41,9 +36,6 @@ SUPPORT_STATE_SERVICES = (
     | LawnMowerEntityFeature.PAUSE
     | LawnMowerEntityFeature.START_MOWING
 )
-MOW = "mow"
-PARK = "park"
-OVERRIDE_MODES = [MOW, PARK]
 
 
 async def async_setup_entry(
@@ -62,31 +54,6 @@ async def async_setup_entry(
     _async_add_new_devices(set(coordinator.data))
 
     coordinator.new_devices_callbacks.append(_async_add_new_devices)
-    platform = entity_platform.async_get_current_platform()
-    platform.async_register_entity_service(
-        "override_schedule",
-        {
-            vol.Required("override_mode"): vol.In(OVERRIDE_MODES),
-            vol.Required("duration"): vol.All(
-                cv.time_period,
-                cv.positive_timedelta,
-                vol.Range(min=timedelta(minutes=1), max=timedelta(days=42)),
-            ),
-        },
-        "async_override_schedule",
-    )
-    platform.async_register_entity_service(
-        "override_schedule_work_area",
-        {
-            vol.Required("work_area_id"): vol.Coerce(int),
-            vol.Required("duration"): vol.All(
-                cv.time_period,
-                cv.positive_timedelta,
-                vol.Range(min=timedelta(minutes=1), max=timedelta(days=42)),
-            ),
-        },
-        "async_override_schedule_work_area",
-    )
 
 
 class AutomowerLawnMowerEntity(AutomowerBaseEntity, LawnMowerEntity):

homeassistant/components/husqvarna_automower/services.py

@@ -0,0 +1,49 @@
+"""Husqvarna Automower services."""
+
+from datetime import timedelta
+
+import voluptuous as vol
+
+from homeassistant.components.lawn_mower import DOMAIN as LAWN_MOWER_DOMAIN
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import config_validation as cv, service
+
+from .const import DOMAIN, MOW, PARK
+
+OVERRIDE_MODES = [MOW, PARK]
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Set up services."""
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        "override_schedule",
+        entity_domain=LAWN_MOWER_DOMAIN,
+        schema={
+            vol.Required("override_mode"): vol.In(OVERRIDE_MODES),
+            vol.Required("duration"): vol.All(
+                cv.time_period,
+                cv.positive_timedelta,
+                vol.Range(min=timedelta(minutes=1), max=timedelta(days=42)),
+            ),
+        },
+        func="async_override_schedule",
+    )
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        "override_schedule_work_area",
+        entity_domain=LAWN_MOWER_DOMAIN,
+        schema={
+            vol.Required("work_area_id"): vol.Coerce(int),
+            vol.Required("duration"): vol.All(
+                cv.time_period,
+                cv.positive_timedelta,
+                vol.Range(min=timedelta(minutes=1), max=timedelta(days=42)),
+            ),
+        },
+        func="async_override_schedule_work_area",
+    )

homeassistant/components/huum/const.py

@@ -4,7 +4,13 @@ from homeassistant.const import Platform
 
 DOMAIN = "huum"
 
-PLATFORMS = [Platform.BINARY_SENSOR, Platform.CLIMATE, Platform.LIGHT, Platform.NUMBER]
+PLATFORMS = [
+    Platform.BINARY_SENSOR,
+    Platform.CLIMATE,
+    Platform.LIGHT,
+    Platform.NUMBER,
+    Platform.SENSOR,
+]
 
 CONFIG_STEAMER = 1
 CONFIG_LIGHT = 2

homeassistant/components/huum/sensor.py

@@ -0,0 +1,42 @@
+"""Sensor platform for Huum sauna integration."""
+
+from __future__ import annotations
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorStateClass,
+)
+from homeassistant.const import UnitOfTemperature
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import HuumConfigEntry, HuumDataUpdateCoordinator
+from .entity import HuumBaseEntity
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: HuumConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Huum sensors from a config entry."""
+    async_add_entities([HuumTemperatureSensor(config_entry.runtime_data)])
+
+
+class HuumTemperatureSensor(HuumBaseEntity, SensorEntity):
+    """Representation of a Huum temperature sensor."""
+
+    _attr_device_class = SensorDeviceClass.TEMPERATURE
+    _attr_native_unit_of_measurement = UnitOfTemperature.CELSIUS
+    _attr_state_class = SensorStateClass.MEASUREMENT
+
+    def __init__(self, coordinator: HuumDataUpdateCoordinator) -> None:
+        """Initialize the temperature sensor."""
+        super().__init__(coordinator)
+        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_temperature"
+
+    @property
+    def native_value(self) -> int | None:
+        """Return the current temperature."""
+        return self.coordinator.data.temperature

homeassistant/components/improv_ble/config_flow.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import AsyncIterator, Callable, Coroutine
+from collections.abc import AsyncGenerator, Callable, Coroutine
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
 import logging
@@ -297,7 +297,7 @@ class ImprovBLEConfigFlow(ConfigFlow, domain=DOMAIN):
     @asynccontextmanager
     async def _async_provision_context(
         self, ble_mac: str
-    ) -> AsyncIterator[asyncio.Future[str]]:
+    ) -> AsyncGenerator[asyncio.Future[str]]:
         """Context manager to register and cleanup provisioning future."""
         future = self.hass.loop.create_future()
         provisioning_futures = async_get_provisioning_futures(self.hass)

homeassistant/components/jellyfin/media_player.py

@@ -150,7 +150,9 @@ class JellyfinMediaPlayer(JellyfinClientEntity, MediaPlayerEntity):
 
         self._attr_state = state
         self._attr_is_volume_muted = volume_muted
-        self._attr_volume_level = volume_level
+        # Only update volume_level if the API provides it, otherwise preserve current value
+        if volume_level is not None:
+            self._attr_volume_level = volume_level
         self._attr_media_content_type = media_content_type
         self._attr_media_content_id = media_content_id
         self._attr_media_title = media_title
@@ -190,7 +192,9 @@ class JellyfinMediaPlayer(JellyfinClientEntity, MediaPlayerEntity):
         )
         features = MediaPlayerEntityFeature(0)
 
-        if "PlayMediaSource" in commands:
+        if "PlayMediaSource" in commands or self.capabilities.get(
+            "SupportsMediaControl", False
+        ):
             features |= (
                 MediaPlayerEntityFeature.BROWSE_MEDIA
                 | MediaPlayerEntityFeature.PLAY_MEDIA
@@ -201,10 +205,10 @@ class JellyfinMediaPlayer(JellyfinClientEntity, MediaPlayerEntity):
                 | MediaPlayerEntityFeature.SEARCH_MEDIA
             )
 
-            if "Mute" in commands:
+            if "Mute" in commands and "Unmute" in commands:
                 features |= MediaPlayerEntityFeature.VOLUME_MUTE
 
-            if "VolumeSet" in commands:
+            if "VolumeSet" in commands or "SetVolume" in commands:
                 features |= MediaPlayerEntityFeature.VOLUME_SET
 
         return features
@@ -219,11 +223,13 @@ class JellyfinMediaPlayer(JellyfinClientEntity, MediaPlayerEntity):
         """Send pause command."""
         self.coordinator.api_client.jellyfin.remote_pause(self.session_id)
         self._attr_state = MediaPlayerState.PAUSED
+        self.schedule_update_ha_state()
 
     def media_play(self) -> None:
         """Send play command."""
         self.coordinator.api_client.jellyfin.remote_unpause(self.session_id)
         self._attr_state = MediaPlayerState.PLAYING
+        self.schedule_update_ha_state()
 
     def media_play_pause(self) -> None:
         """Send the PlayPause command to the session."""
@@ -233,6 +239,7 @@ class JellyfinMediaPlayer(JellyfinClientEntity, MediaPlayerEntity):
         """Send stop command."""
         self.coordinator.api_client.jellyfin.remote_stop(self.session_id)
         self._attr_state = MediaPlayerState.IDLE
+        self.schedule_update_ha_state()
 
     def play_media(
         self, media_type: MediaType | str, media_id: str, **kwargs: Any
@@ -247,6 +254,8 @@ class JellyfinMediaPlayer(JellyfinClientEntity, MediaPlayerEntity):
         self.coordinator.api_client.jellyfin.remote_set_volume(
             self.session_id, int(volume * 100)
         )
+        self._attr_volume_level = volume
+        self.schedule_update_ha_state()
 
     def mute_volume(self, mute: bool) -> None:
         """Mute the volume."""
@@ -254,6 +263,8 @@ class JellyfinMediaPlayer(JellyfinClientEntity, MediaPlayerEntity):
             self.coordinator.api_client.jellyfin.remote_mute(self.session_id)
         else:
             self.coordinator.api_client.jellyfin.remote_unmute(self.session_id)
+        self._attr_is_volume_muted = mute
+        self.schedule_update_ha_state()
 
     async def async_browse_media(
         self,

homeassistant/components/kodi/__init__.py

@@ -17,11 +17,16 @@ from homeassistant.const import (
     Platform,
 )
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.typing import ConfigType
 
-from .const import CONF_WS_PORT
+from .const import CONF_WS_PORT, DOMAIN
+from .services import async_setup_services
 
 _LOGGER = logging.getLogger(__name__)
+
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 PLATFORMS = [Platform.MEDIA_PLAYER]
 
 type KodiConfigEntry = ConfigEntry[KodiRuntimeData]
@@ -35,6 +40,12 @@ class KodiRuntimeData:
     kodi: Kodi
 
 
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the component."""
+    async_setup_services(hass)
+    return True
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: KodiConfigEntry) -> bool:
     """Set up Kodi from a config entry."""
     conn = get_kodi_connection(

homeassistant/components/kodi/media_player.py

@@ -11,7 +11,6 @@ from typing import Any, Concatenate
 
 from jsonrpc_base.jsonrpc import ProtocolError, TransportError
 from pykodi import CannotConnectError
-import voluptuous as vol
 
 from homeassistant.components import media_source
 from homeassistant.components.media_player import (
@@ -31,16 +30,11 @@ from homeassistant.const import (
     EVENT_HOMEASSISTANT_STARTED,
 )
 from homeassistant.core import CoreState, HomeAssistant, callback
-from homeassistant.helpers import (
-    config_validation as cv,
-    device_registry as dr,
-    entity_platform,
-)
+from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.event import async_track_time_interval
 from homeassistant.helpers.network import is_internal_request
-from homeassistant.helpers.typing import VolDictType
 from homeassistant.util import dt as dt_util
 
 from . import KodiConfigEntry
@@ -85,42 +79,12 @@ MAP_KODI_MEDIA_TYPES: dict[MediaType | str, str] = {
 }
 
 
-SERVICE_ADD_MEDIA = "add_to_playlist"
-SERVICE_CALL_METHOD = "call_method"
-
-ATTR_MEDIA_TYPE = "media_type"
-ATTR_MEDIA_NAME = "media_name"
-ATTR_MEDIA_ARTIST_NAME = "artist_name"
-ATTR_MEDIA_ID = "media_id"
-ATTR_METHOD = "method"
-
-
-KODI_ADD_MEDIA_SCHEMA: VolDictType = {
-    vol.Required(ATTR_MEDIA_TYPE): cv.string,
-    vol.Optional(ATTR_MEDIA_ID): cv.string,
-    vol.Optional(ATTR_MEDIA_NAME): cv.string,
-    vol.Optional(ATTR_MEDIA_ARTIST_NAME): cv.string,
-}
-
-KODI_CALL_METHOD_SCHEMA = cv.make_entity_service_schema(
-    {vol.Required(ATTR_METHOD): cv.string}, extra=vol.ALLOW_EXTRA
-)
-
-
 async def async_setup_entry(
     hass: HomeAssistant,
     config_entry: KodiConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the Kodi media player platform."""
-    platform = entity_platform.async_get_current_platform()
-    platform.async_register_entity_service(
-        SERVICE_ADD_MEDIA, KODI_ADD_MEDIA_SCHEMA, "async_add_media_to_playlist"
-    )
-    platform.async_register_entity_service(
-        SERVICE_CALL_METHOD, KODI_CALL_METHOD_SCHEMA, "async_call_method"
-    )
-
     data = config_entry.runtime_data
     name = config_entry.data[CONF_NAME]
     if (uid := config_entry.unique_id) is None:

homeassistant/components/kodi/services.py

@@ -0,0 +1,54 @@
+"""Support for interfacing with the XBMC/Kodi JSON-RPC API."""
+
+from __future__ import annotations
+
+import voluptuous as vol
+
+from homeassistant.components.media_player import DOMAIN as MEDIA_PLAYER_DOMAIN
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import config_validation as cv, service
+from homeassistant.helpers.typing import VolDictType
+
+from .const import DOMAIN
+
+SERVICE_ADD_MEDIA = "add_to_playlist"
+SERVICE_CALL_METHOD = "call_method"
+
+ATTR_MEDIA_TYPE = "media_type"
+ATTR_MEDIA_NAME = "media_name"
+ATTR_MEDIA_ARTIST_NAME = "artist_name"
+ATTR_MEDIA_ID = "media_id"
+ATTR_METHOD = "method"
+
+
+KODI_ADD_MEDIA_SCHEMA: VolDictType = {
+    vol.Required(ATTR_MEDIA_TYPE): cv.string,
+    vol.Optional(ATTR_MEDIA_ID): cv.string,
+    vol.Optional(ATTR_MEDIA_NAME): cv.string,
+    vol.Optional(ATTR_MEDIA_ARTIST_NAME): cv.string,
+}
+
+KODI_CALL_METHOD_SCHEMA = cv.make_entity_service_schema(
+    {vol.Required(ATTR_METHOD): cv.string}, extra=vol.ALLOW_EXTRA
+)
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Set up services."""
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_ADD_MEDIA,
+        entity_domain=MEDIA_PLAYER_DOMAIN,
+        schema=KODI_ADD_MEDIA_SCHEMA,
+        func="async_add_media_to_playlist",
+    )
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_CALL_METHOD,
+        entity_domain=MEDIA_PLAYER_DOMAIN,
+        schema=KODI_CALL_METHOD_SCHEMA,
+        func="async_call_method",
+    )

homeassistant/components/liebherr/__init__.py

@@ -17,7 +17,7 @@ from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
 from .coordinator import LiebherrConfigEntry, LiebherrCoordinator
 
-PLATFORMS: list[Platform] = [Platform.SENSOR]
+PLATFORMS: list[Platform] = [Platform.NUMBER, Platform.SENSOR]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: LiebherrConfigEntry) -> bool:

homeassistant/components/liebherr/number.py

@@ -0,0 +1,164 @@
+"""Number platform for Liebherr integration."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from pyliebherrhomeapi import (
+    LiebherrConnectionError,
+    LiebherrTimeoutError,
+    TemperatureControl,
+    TemperatureUnit,
+)
+
+from homeassistant.components.number import (
+    DEFAULT_MAX_VALUE,
+    DEFAULT_MIN_VALUE,
+    NumberDeviceClass,
+    NumberEntity,
+    NumberEntityDescription,
+)
+from homeassistant.const import UnitOfTemperature
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .const import DOMAIN
+from .coordinator import LiebherrConfigEntry, LiebherrCoordinator
+from .entity import LiebherrZoneEntity
+
+PARALLEL_UPDATES = 1
+
+
+@dataclass(frozen=True, kw_only=True)
+class LiebherrNumberEntityDescription(NumberEntityDescription):
+    """Describes Liebherr number entity."""
+
+    value_fn: Callable[[TemperatureControl], float | None]
+    min_fn: Callable[[TemperatureControl], float | None]
+    max_fn: Callable[[TemperatureControl], float | None]
+    unit_fn: Callable[[TemperatureControl], str]
+
+
+NUMBER_TYPES: tuple[LiebherrNumberEntityDescription, ...] = (
+    LiebherrNumberEntityDescription(
+        key="setpoint_temperature",
+        translation_key="setpoint_temperature",
+        device_class=NumberDeviceClass.TEMPERATURE,
+        native_step=1,
+        value_fn=lambda control: control.target,
+        min_fn=lambda control: control.min,
+        max_fn=lambda control: control.max,
+        unit_fn=lambda control: (
+            UnitOfTemperature.FAHRENHEIT
+            if control.unit == TemperatureUnit.FAHRENHEIT
+            else UnitOfTemperature.CELSIUS
+        ),
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: LiebherrConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Liebherr number entities."""
+    coordinators = entry.runtime_data
+    async_add_entities(
+        LiebherrNumber(
+            coordinator=coordinator,
+            zone_id=temp_control.zone_id,
+            description=description,
+        )
+        for coordinator in coordinators.values()
+        for temp_control in coordinator.data.get_temperature_controls().values()
+        for description in NUMBER_TYPES
+    )
+
+
+class LiebherrNumber(LiebherrZoneEntity, NumberEntity):
+    """Representation of a Liebherr number entity."""
+
+    entity_description: LiebherrNumberEntityDescription
+
+    def __init__(
+        self,
+        coordinator: LiebherrCoordinator,
+        zone_id: int,
+        description: LiebherrNumberEntityDescription,
+    ) -> None:
+        """Initialize the number entity."""
+        super().__init__(coordinator, zone_id)
+        self.entity_description = description
+        self._attr_unique_id = f"{coordinator.device_id}_{description.key}_{zone_id}"
+
+        # If device has only one zone, use translation key without zone suffix
+        temp_controls = coordinator.data.get_temperature_controls()
+        if len(temp_controls) > 1 and (zone_key := self._get_zone_translation_key()):
+            self._attr_translation_key = f"{description.translation_key}_{zone_key}"
+
+    @property
+    def native_unit_of_measurement(self) -> str | None:
+        """Return the unit of measurement."""
+        if (temp_control := self.temperature_control) is None:
+            return None
+        return self.entity_description.unit_fn(temp_control)
+
+    @property
+    def native_value(self) -> float | None:
+        """Return the current value."""
+        # temperature_control is guaranteed to exist when entity is available
+        return self.entity_description.value_fn(
+            self.temperature_control  # type: ignore[arg-type]
+        )
+
+    @property
+    def native_min_value(self) -> float:
+        """Return the minimum value."""
+        if (temp_control := self.temperature_control) is None:
+            return DEFAULT_MIN_VALUE
+        if (min_val := self.entity_description.min_fn(temp_control)) is None:
+            return DEFAULT_MIN_VALUE
+        return min_val
+
+    @property
+    def native_max_value(self) -> float:
+        """Return the maximum value."""
+        if (temp_control := self.temperature_control) is None:
+            return DEFAULT_MAX_VALUE
+        if (max_val := self.entity_description.max_fn(temp_control)) is None:
+            return DEFAULT_MAX_VALUE
+        return max_val
+
+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        return super().available and self.temperature_control is not None
+
+    async def async_set_native_value(self, value: float) -> None:
+        """Set new value."""
+        # temperature_control is guaranteed to exist when entity is available
+        temp_control = self.temperature_control
+
+        unit = (
+            TemperatureUnit.FAHRENHEIT
+            if temp_control.unit == TemperatureUnit.FAHRENHEIT  # type: ignore[union-attr]
+            else TemperatureUnit.CELSIUS
+        )
+
+        try:
+            await self.coordinator.client.set_temperature(
+                device_id=self.coordinator.device_id,
+                zone_id=self._zone_id,
+                target=int(value),
+                unit=unit,
+            )
+        except (LiebherrConnectionError, LiebherrTimeoutError) as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="set_temperature_failed",
+            ) from err
+
+        await self.coordinator.async_request_refresh()

homeassistant/components/liebherr/sensor.py

@@ -55,23 +55,16 @@ async def async_setup_entry(
 ) -> None:
     """Set up Liebherr sensor entities."""
     coordinators = entry.runtime_data
-    entities: list[LiebherrSensor] = []
-
-    for coordinator in coordinators.values():
-        # Get all temperature controls for this device
-        temp_controls = coordinator.data.get_temperature_controls()
-
-        for temp_control in temp_controls.values():
-            entities.extend(
-                LiebherrSensor(
-                    coordinator=coordinator,
-                    zone_id=temp_control.zone_id,
-                    description=description,
-                )
-                for description in SENSOR_TYPES
-            )
-
-    async_add_entities(entities)
+    async_add_entities(
+        LiebherrSensor(
+            coordinator=coordinator,
+            zone_id=temp_control.zone_id,
+            description=description,
+        )
+        for coordinator in coordinators.values()
+        for temp_control in coordinator.data.get_temperature_controls().values()
+        for description in SENSOR_TYPES
+    )
 
 
 class LiebherrSensor(LiebherrZoneEntity, SensorEntity):
@@ -108,9 +101,9 @@ class LiebherrSensor(LiebherrZoneEntity, SensorEntity):
     @property
     def native_value(self) -> StateType:
         """Return the current value."""
-        if (temp_control := self.temperature_control) is None:
-            return None
-        return self.entity_description.value_fn(temp_control)
+        # temperature_control is guaranteed to exist when entity is available
+        assert self.temperature_control is not None
+        return self.entity_description.value_fn(self.temperature_control)
 
     @property
     def available(self) -> bool:

homeassistant/components/liebherr/strings.json

@@ -33,6 +33,20 @@
     }
   },
   "entity": {
+    "number": {
+      "setpoint_temperature": {
+        "name": "Setpoint"
+      },
+      "setpoint_temperature_bottom_zone": {
+        "name": "Bottom zone setpoint"
+      },
+      "setpoint_temperature_middle_zone": {
+        "name": "Middle zone setpoint"
+      },
+      "setpoint_temperature_top_zone": {
+        "name": "Top zone setpoint"
+      }
+    },
     "sensor": {
       "bottom_zone": {
         "name": "Bottom zone"
@@ -44,5 +58,10 @@
         "name": "Top zone"
       }
     }
+  },
+  "exceptions": {
+    "set_temperature_failed": {
+      "message": "Failed to set temperature"
+    }
   }
 }

homeassistant/components/light/__init__.py

@@ -82,26 +82,6 @@ ATTR_COLOR_MODE = "color_mode"
 # List of color modes supported by the light
 ATTR_SUPPORTED_COLOR_MODES = "supported_color_modes"
 
-# These COLOR_MODE_* constants are deprecated as of Home Assistant 2022.5.
-# Please use the LightEntityFeature enum instead.
-_DEPRECATED_COLOR_MODE_UNKNOWN: Final = DeprecatedConstantEnum(
-    ColorMode.UNKNOWN, "2026.1"
-)
-_DEPRECATED_COLOR_MODE_ONOFF: Final = DeprecatedConstantEnum(ColorMode.ONOFF, "2026.1")
-_DEPRECATED_COLOR_MODE_BRIGHTNESS: Final = DeprecatedConstantEnum(
-    ColorMode.BRIGHTNESS, "2026.1"
-)
-_DEPRECATED_COLOR_MODE_COLOR_TEMP: Final = DeprecatedConstantEnum(
-    ColorMode.COLOR_TEMP, "2026.1"
-)
-_DEPRECATED_COLOR_MODE_HS: Final = DeprecatedConstantEnum(ColorMode.HS, "2026.1")
-_DEPRECATED_COLOR_MODE_XY: Final = DeprecatedConstantEnum(ColorMode.XY, "2026.1")
-_DEPRECATED_COLOR_MODE_RGB: Final = DeprecatedConstantEnum(ColorMode.RGB, "2026.1")
-_DEPRECATED_COLOR_MODE_RGBW: Final = DeprecatedConstantEnum(ColorMode.RGBW, "2026.1")
-_DEPRECATED_COLOR_MODE_RGBWW: Final = DeprecatedConstantEnum(ColorMode.RGBWW, "2026.1")
-_DEPRECATED_COLOR_MODE_WHITE: Final = DeprecatedConstantEnum(ColorMode.WHITE, "2026.1")
-
-
 # mypy: disallow-any-generics
 
 
@@ -192,20 +172,6 @@ ATTR_MAX_COLOR_TEMP_KELVIN = "max_color_temp_kelvin"
 ATTR_COLOR_NAME = "color_name"
 ATTR_WHITE = "white"
 
-# Deprecated in HA Core 2022.11
-_DEPRECATED_ATTR_COLOR_TEMP: Final = DeprecatedConstant(
-    "color_temp", "kelvin equivalent (ATTR_COLOR_TEMP_KELVIN)", "2026.1"
-)
-_DEPRECATED_ATTR_KELVIN: Final = DeprecatedConstant(
-    "kelvin", "ATTR_COLOR_TEMP_KELVIN", "2026.1"
-)
-_DEPRECATED_ATTR_MIN_MIREDS: Final = DeprecatedConstant(
-    "min_mireds", "kelvin equivalent (ATTR_MAX_COLOR_TEMP_KELVIN)", "2026.1"
-)
-_DEPRECATED_ATTR_MAX_MIREDS: Final = DeprecatedConstant(
-    "max_mireds", "kelvin equivalent (ATTR_MIN_COLOR_TEMP_KELVIN)", "2026.1"
-)
-
 # Brightness of the light, 0..255 or percentage
 ATTR_BRIGHTNESS = "brightness"
 ATTR_BRIGHTNESS_PCT = "brightness_pct"
@@ -250,11 +216,7 @@ LIGHT_TURN_ON_SCHEMA: VolDictType = {
     vol.Exclusive(ATTR_BRIGHTNESS_STEP, ATTR_BRIGHTNESS): VALID_BRIGHTNESS_STEP,
     vol.Exclusive(ATTR_BRIGHTNESS_STEP_PCT, ATTR_BRIGHTNESS): VALID_BRIGHTNESS_STEP_PCT,
     vol.Exclusive(ATTR_COLOR_NAME, COLOR_GROUP): cv.string,
-    vol.Exclusive(_DEPRECATED_ATTR_COLOR_TEMP.value, COLOR_GROUP): vol.All(
-        vol.Coerce(int), vol.Range(min=1)
-    ),
     vol.Exclusive(ATTR_COLOR_TEMP_KELVIN, COLOR_GROUP): cv.positive_int,
-    vol.Exclusive(_DEPRECATED_ATTR_KELVIN.value, COLOR_GROUP): cv.positive_int,
     vol.Exclusive(ATTR_HS_COLOR, COLOR_GROUP): vol.All(
         vol.Coerce(tuple),
         vol.ExactSequence(
@@ -317,31 +279,6 @@ def preprocess_turn_on_alternatives(
             _LOGGER.warning("Got unknown color %s, falling back to white", color_name)
             params[ATTR_RGB_COLOR] = (255, 255, 255)
 
-    if (mired := params.pop(_DEPRECATED_ATTR_COLOR_TEMP.value, None)) is not None:
-        _LOGGER.warning(
-            "Got `color_temp` argument in `turn_on` service, which is deprecated "
-            "and will break in Home Assistant 2026.1, please use "
-            "`color_temp_kelvin` argument"
-        )
-        kelvin = color_util.color_temperature_mired_to_kelvin(mired)
-        params[_DEPRECATED_ATTR_COLOR_TEMP.value] = int(mired)
-        params[ATTR_COLOR_TEMP_KELVIN] = int(kelvin)
-
-    if (kelvin := params.pop(_DEPRECATED_ATTR_KELVIN.value, None)) is not None:
-        _LOGGER.warning(
-            "Got `kelvin` argument in `turn_on` service, which is deprecated "
-            "and will break in Home Assistant 2026.1, please use "
-            "`color_temp_kelvin` argument"
-        )
-        mired = color_util.color_temperature_kelvin_to_mired(kelvin)
-        params[_DEPRECATED_ATTR_COLOR_TEMP.value] = int(mired)
-        params[ATTR_COLOR_TEMP_KELVIN] = int(kelvin)
-
-    if (kelvin := params.pop(ATTR_COLOR_TEMP_KELVIN, None)) is not None:
-        mired = color_util.color_temperature_kelvin_to_mired(kelvin)
-        params[_DEPRECATED_ATTR_COLOR_TEMP.value] = int(mired)
-        params[ATTR_COLOR_TEMP_KELVIN] = int(kelvin)
-
     brightness_pct = params.pop(ATTR_BRIGHTNESS_PCT, None)
     if brightness_pct is not None:
         params[ATTR_BRIGHTNESS] = round(255 * brightness_pct / 100)
@@ -381,7 +318,6 @@ def filter_turn_on_params(light: LightEntity, params: dict[str, Any]) -> dict[st
     if not brightness_supported(supported_color_modes):
         params.pop(ATTR_BRIGHTNESS, None)
     if ColorMode.COLOR_TEMP not in supported_color_modes:
-        params.pop(_DEPRECATED_ATTR_COLOR_TEMP.value, None)
         params.pop(ATTR_COLOR_TEMP_KELVIN, None)
     if ColorMode.HS not in supported_color_modes:
         params.pop(ATTR_HS_COLOR, None)
@@ -466,7 +402,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
                 and ColorMode.COLOR_TEMP not in supported_color_modes
                 and ColorMode.RGBWW in supported_color_modes
             ):
-                params.pop(_DEPRECATED_ATTR_COLOR_TEMP.value)
                 color_temp = params.pop(ATTR_COLOR_TEMP_KELVIN)
                 brightness = cast(int, params.get(ATTR_BRIGHTNESS, light.brightness))
                 params[ATTR_RGBWW_COLOR] = color_util.color_temperature_to_rgbww(
@@ -476,7 +411,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
                     light.max_color_temp_kelvin,
                 )
             elif ColorMode.COLOR_TEMP not in legacy_supported_color_modes:
-                params.pop(_DEPRECATED_ATTR_COLOR_TEMP.value)
                 color_temp = params.pop(ATTR_COLOR_TEMP_KELVIN)
                 if color_supported(legacy_supported_color_modes):
                     params[ATTR_HS_COLOR] = color_util.color_temperature_to_hs(
@@ -523,11 +457,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
                 params[ATTR_COLOR_TEMP_KELVIN] = color_util.color_xy_to_temperature(
                     *xy_color
                 )
-                params[_DEPRECATED_ATTR_COLOR_TEMP.value] = (
-                    color_util.color_temperature_kelvin_to_mired(
-                        params[ATTR_COLOR_TEMP_KELVIN]
-                    )
-                )
         elif ATTR_RGB_COLOR in params and ColorMode.RGB not in supported_color_modes:
             rgb_color = params.pop(ATTR_RGB_COLOR)
             assert rgb_color is not None
@@ -550,11 +479,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
                 params[ATTR_COLOR_TEMP_KELVIN] = color_util.color_xy_to_temperature(
                     *xy_color
                 )
-                params[_DEPRECATED_ATTR_COLOR_TEMP.value] = (
-                    color_util.color_temperature_kelvin_to_mired(
-                        params[ATTR_COLOR_TEMP_KELVIN]
-                    )
-                )
         elif ATTR_XY_COLOR in params and ColorMode.XY not in supported_color_modes:
             xy_color = params.pop(ATTR_XY_COLOR)
             if ColorMode.HS in supported_color_modes:
@@ -573,11 +497,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
                 params[ATTR_COLOR_TEMP_KELVIN] = color_util.color_xy_to_temperature(
                     *xy_color
                 )
-                params[_DEPRECATED_ATTR_COLOR_TEMP.value] = (
-                    color_util.color_temperature_kelvin_to_mired(
-                        params[ATTR_COLOR_TEMP_KELVIN]
-                    )
-                )
         elif ATTR_RGBW_COLOR in params and ColorMode.RGBW not in supported_color_modes:
             rgbw_color = params.pop(ATTR_RGBW_COLOR)
             rgb_color = color_util.color_rgbw_to_rgb(*rgbw_color)
@@ -596,11 +515,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
                 params[ATTR_COLOR_TEMP_KELVIN] = color_util.color_xy_to_temperature(
                     *xy_color
                 )
-                params[_DEPRECATED_ATTR_COLOR_TEMP.value] = (
-                    color_util.color_temperature_kelvin_to_mired(
-                        params[ATTR_COLOR_TEMP_KELVIN]
-                    )
-                )
         elif (
             ATTR_RGBWW_COLOR in params and ColorMode.RGBWW not in supported_color_modes
         ):
@@ -624,11 +538,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
                 params[ATTR_COLOR_TEMP_KELVIN] = color_util.color_xy_to_temperature(
                     *xy_color
                 )
-                params[_DEPRECATED_ATTR_COLOR_TEMP.value] = (
-                    color_util.color_temperature_kelvin_to_mired(
-                        params[ATTR_COLOR_TEMP_KELVIN]
-                    )
-                )
 
         # If white is set to True, set it to the light's brightness
         # Add a warning in Home Assistant Core 2024.3 if the brightness is set to an
@@ -835,7 +744,7 @@ class Profiles:
 
         color_attributes = (
             ATTR_COLOR_NAME,
-            _DEPRECATED_ATTR_COLOR_TEMP.value,
+            ATTR_COLOR_TEMP_KELVIN,
             ATTR_HS_COLOR,
             ATTR_RGB_COLOR,
             ATTR_RGBW_COLOR,
@@ -866,9 +775,9 @@ CACHED_PROPERTIES_WITH_ATTR_ = {
     "rgb_color",
     "rgbw_color",
     "rgbww_color",
-    "color_temp",
-    "min_mireds",
-    "max_mireds",
+    "color_temp_kelvin",
+    "min_color_temp_kelvin",
+    "max_color_temp_kelvin",
     "effect_list",
     "effect",
     "supported_color_modes",
@@ -883,13 +792,10 @@ class LightEntity(ToggleEntity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
         {
             ATTR_SUPPORTED_COLOR_MODES,
             ATTR_EFFECT_LIST,
-            _DEPRECATED_ATTR_MIN_MIREDS.value,
-            _DEPRECATED_ATTR_MAX_MIREDS.value,
             ATTR_MIN_COLOR_TEMP_KELVIN,
             ATTR_MAX_COLOR_TEMP_KELVIN,
             ATTR_BRIGHTNESS,
             ATTR_COLOR_MODE,
-            _DEPRECATED_ATTR_COLOR_TEMP.value,
             ATTR_COLOR_TEMP_KELVIN,
             ATTR_EFFECT,
             ATTR_HS_COLOR,
@@ -907,11 +813,8 @@ class LightEntity(ToggleEntity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
     _attr_effect_list: list[str] | None = None
     _attr_effect: str | None = None
     _attr_hs_color: tuple[float, float] | None = None
-    # We cannot set defaults without causing breaking changes until mireds
-    # are fully removed. Until then, developers can explicitly
-    # use DEFAULT_MIN_KELVIN and DEFAULT_MAX_KELVIN
-    _attr_max_color_temp_kelvin: int | None = None
-    _attr_min_color_temp_kelvin: int | None = None
+    _attr_max_color_temp_kelvin: int = DEFAULT_MAX_KELVIN
+    _attr_min_color_temp_kelvin: int = DEFAULT_MIN_KELVIN
     _attr_rgb_color: tuple[int, int, int] | None = None
     _attr_rgbw_color: tuple[int, int, int, int] | None = None
     _attr_rgbww_color: tuple[int, int, int, int, int] | None = None
@@ -919,11 +822,6 @@ class LightEntity(ToggleEntity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
     _attr_supported_features: LightEntityFeature = LightEntityFeature(0)
     _attr_xy_color: tuple[float, float] | None = None
 
-    # Deprecated, see https://github.com/home-assistant/core/pull/79591
-    _attr_color_temp: Final[int | None] = None
-    _attr_max_mireds: Final[int] = 500  # = 2000 K
-    _attr_min_mireds: Final[int] = 153  # = 6535.94 K (~ 6500 K)
-
     __color_mode_reported = False
 
     @cached_property
@@ -999,91 +897,49 @@ class LightEntity(ToggleEntity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
         """Return the rgbww color value [int, int, int, int, int]."""
         return self._attr_rgbww_color
 
-    @final
-    @cached_property
-    def color_temp(self) -> int | None:
-        """Return the CT color value in mireds.
-
-        Deprecated, see https://github.com/home-assistant/core/pull/79591
-        """
-        return self._attr_color_temp
-
     @property
     def color_temp_kelvin(self) -> int | None:
         """Return the CT color value in Kelvin."""
-        if self._attr_color_temp_kelvin is None and (color_temp := self.color_temp):
-            report_usage(
-                "is using mireds for current light color temperature, when "
-                "it should be adjusted to use the kelvin attribute "
-                "`_attr_color_temp_kelvin` or override the kelvin property "
-                "`color_temp_kelvin` (see "
-                "https://github.com/home-assistant/core/pull/79591)",
-                breaks_in_ha_version="2026.1",
-                core_behavior=ReportBehavior.LOG,
-                integration_domain=self.platform.platform_name
-                if self.platform
-                else None,
-                exclude_integrations={DOMAIN},
-            )
-            return color_util.color_temperature_mired_to_kelvin(color_temp)
         return self._attr_color_temp_kelvin
 
-    @final
-    @cached_property
-    def min_mireds(self) -> int:
-        """Return the coldest color_temp that this light supports.
-
-        Deprecated, see https://github.com/home-assistant/core/pull/79591
-        """
-        return self._attr_min_mireds
-
-    @final
-    @cached_property
-    def max_mireds(self) -> int:
-        """Return the warmest color_temp that this light supports.
-
-        Deprecated, see https://github.com/home-assistant/core/pull/79591
-        """
-        return self._attr_max_mireds
-
     @property
     def min_color_temp_kelvin(self) -> int:
         """Return the warmest color_temp_kelvin that this light supports."""
         if self._attr_min_color_temp_kelvin is None:
-            report_usage(
-                "is using mireds for warmest light color temperature, when "
-                "it should be adjusted to use the kelvin attribute "
-                "`_attr_min_color_temp_kelvin` or override the kelvin property "
-                "`min_color_temp_kelvin`, possibly with default DEFAULT_MIN_KELVIN "
-                "(see https://github.com/home-assistant/core/pull/79591)",
-                breaks_in_ha_version="2026.1",
+            # For historical reason when both Mired and Kelvin were supported,
+            # integrations may have set this explicitly to None.
+            # Fallback to DEFAULT to ensure compatibility.
+            report_usage(  # type: ignore[unreachable]
+                "is explicitly setting `_attr_min_color_temp_kelvin` to `None`, when "
+                "it should be setting a valid integer, possibly DEFAULT_MIN_KELVIN ",
+                breaks_in_ha_version="2026.8",
                 core_behavior=ReportBehavior.LOG,
                 integration_domain=self.platform.platform_name
                 if self.platform
                 else None,
                 exclude_integrations={DOMAIN},
             )
-            return color_util.color_temperature_mired_to_kelvin(self.max_mireds)
+            return DEFAULT_MIN_KELVIN
         return self._attr_min_color_temp_kelvin
 
     @property
     def max_color_temp_kelvin(self) -> int:
         """Return the coldest color_temp_kelvin that this light supports."""
         if self._attr_max_color_temp_kelvin is None:
-            report_usage(
-                "is using mireds for coldest light color temperature, when "
-                "it should be adjusted to use the kelvin attribute "
-                "`_attr_max_color_temp_kelvin` or override the kelvin property "
-                "`max_color_temp_kelvin`, possibly with default DEFAULT_MAX_KELVIN "
-                "(see https://github.com/home-assistant/core/pull/79591)",
-                breaks_in_ha_version="2026.1",
+            # For historical reason when both Mired and Kelvin were supported,
+            # integrations may have set this explicitly to None.
+            # Fallback to DEFAULT to ensure compatibility.
+            report_usage(  # type: ignore[unreachable]
+                "is explicitly setting `_attr_max_color_temp_kelvin` to `None`, when "
+                "it should be setting a valid integer, possibly DEFAULT_MAX_KELVIN ",
+                breaks_in_ha_version="2026.8",
                 core_behavior=ReportBehavior.LOG,
                 integration_domain=self.platform.platform_name
                 if self.platform
                 else None,
                 exclude_integrations={DOMAIN},
             )
-            return color_util.color_temperature_mired_to_kelvin(self.min_mireds)
+            return DEFAULT_MAX_KELVIN
         return self._attr_max_color_temp_kelvin
 
     @cached_property
@@ -1108,18 +964,6 @@ class LightEntity(ToggleEntity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
             max_color_temp_kelvin = self.max_color_temp_kelvin
             data[ATTR_MIN_COLOR_TEMP_KELVIN] = min_color_temp_kelvin
             data[ATTR_MAX_COLOR_TEMP_KELVIN] = max_color_temp_kelvin
-            if not max_color_temp_kelvin:
-                data[_DEPRECATED_ATTR_MIN_MIREDS.value] = None
-            else:
-                data[_DEPRECATED_ATTR_MIN_MIREDS.value] = (
-                    color_util.color_temperature_kelvin_to_mired(max_color_temp_kelvin)
-                )
-            if not min_color_temp_kelvin:
-                data[_DEPRECATED_ATTR_MAX_MIREDS.value] = None
-            else:
-                data[_DEPRECATED_ATTR_MAX_MIREDS.value] = (
-                    color_util.color_temperature_kelvin_to_mired(min_color_temp_kelvin)
-                )
         if LightEntityFeature.EFFECT in supported_features:
             data[ATTR_EFFECT_LIST] = self.effect_list
 
@@ -1296,32 +1140,16 @@ class LightEntity(ToggleEntity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
 
         if color_temp_supported(supported_color_modes):
             if color_mode == ColorMode.COLOR_TEMP:
-                color_temp_kelvin = self.color_temp_kelvin
-                data[ATTR_COLOR_TEMP_KELVIN] = color_temp_kelvin
-                if color_temp_kelvin:
-                    data[_DEPRECATED_ATTR_COLOR_TEMP.value] = (
-                        color_util.color_temperature_kelvin_to_mired(color_temp_kelvin)
-                    )
-                else:
-                    data[_DEPRECATED_ATTR_COLOR_TEMP.value] = None
+                data[ATTR_COLOR_TEMP_KELVIN] = self.color_temp_kelvin
             else:
                 data[ATTR_COLOR_TEMP_KELVIN] = None
-                data[_DEPRECATED_ATTR_COLOR_TEMP.value] = None
         elif supported_features_value & _DEPRECATED_SUPPORT_COLOR_TEMP.value:
             # Backwards compatibility
             # Warning is printed by supported_features_compat, remove in 2025.1
             if _is_on:
-                color_temp_kelvin = self.color_temp_kelvin
-                data[ATTR_COLOR_TEMP_KELVIN] = color_temp_kelvin
-                if color_temp_kelvin:
-                    data[_DEPRECATED_ATTR_COLOR_TEMP.value] = (
-                        color_util.color_temperature_kelvin_to_mired(color_temp_kelvin)
-                    )
-                else:
-                    data[_DEPRECATED_ATTR_COLOR_TEMP.value] = None
+                data[ATTR_COLOR_TEMP_KELVIN] = self.color_temp_kelvin
             else:
                 data[ATTR_COLOR_TEMP_KELVIN] = None
-                data[_DEPRECATED_ATTR_COLOR_TEMP.value] = None
 
         if color_supported(legacy_supported_color_modes) or color_temp_supported(
             legacy_supported_color_modes

homeassistant/components/light/reproduce_state.py

@@ -15,10 +15,8 @@ from homeassistant.const import (
     STATE_ON,
 )
 from homeassistant.core import Context, HomeAssistant, State
-from homeassistant.util import color as color_util
 
 from . import (
-    _DEPRECATED_ATTR_COLOR_TEMP,
     ATTR_BRIGHTNESS,
     ATTR_COLOR_MODE,
     ATTR_COLOR_TEMP_KELVIN,
@@ -41,7 +39,6 @@ ATTR_GROUP = [ATTR_BRIGHTNESS, ATTR_EFFECT]
 
 COLOR_GROUP = [
     ATTR_HS_COLOR,
-    _DEPRECATED_ATTR_COLOR_TEMP.value,
     ATTR_COLOR_TEMP_KELVIN,
     ATTR_RGB_COLOR,
     ATTR_RGBW_COLOR,
@@ -127,30 +124,13 @@ async def _async_reproduce_state(
             color_mode = state.attributes[ATTR_COLOR_MODE]
             if cm_attr := COLOR_MODE_TO_ATTRIBUTE.get(color_mode):
                 if (cm_attr_state := state.attributes.get(cm_attr.state_attr)) is None:
-                    if (
-                        color_mode != ColorMode.COLOR_TEMP
-                        or (
-                            mireds := state.attributes.get(
-                                _DEPRECATED_ATTR_COLOR_TEMP.value
-                            )
-                        )
-                        is None
-                    ):
-                        _LOGGER.warning(
-                            "Color mode %s specified but attribute %s missing for: %s",
-                            color_mode,
-                            cm_attr.state_attr,
-                            state.entity_id,
-                        )
-                        return
                     _LOGGER.warning(
-                        "Color mode %s specified but attribute %s missing for: %s, "
-                        "using color_temp (mireds) as fallback",
+                        "Color mode %s specified but attribute %s missing for: %s",
                         color_mode,
                         cm_attr.state_attr,
                         state.entity_id,
                     )
-                    cm_attr_state = color_util.color_temperature_mired_to_kelvin(mireds)
+                    return
                 service_data[cm_attr.parameter] = cm_attr_state
         else:
             # Fall back to Choosing the first color that is specified

homeassistant/components/light/services.yaml

@@ -255,13 +255,6 @@ turn_on:
           example: "[0.52, 0.43]"
           selector:
             object:
-        color_temp: &color_temp
-          filter: *color_temp_support
-          selector:
-            color_temp:
-              unit: "mired"
-              min: 153
-              max: 500
         brightness: &brightness
           filter: *brightness_support
           selector:
@@ -327,7 +320,6 @@ toggle:
         color_name: *color_name
         hs_color: *hs_color
         xy_color: *xy_color
-        color_temp: *color_temp
         brightness: *brightness
         white: *white
         profile: *profile

homeassistant/components/light/strings.json

@@ -12,10 +12,8 @@
     "field_brightness_step_pct_name": "Brightness step",
     "field_color_name_description": "A human-readable color name.",
     "field_color_name_name": "Color name",
-    "field_color_temp_description": "Color temperature in mireds.",
     "field_color_temp_kelvin_description": "Color temperature in Kelvin.",
     "field_color_temp_kelvin_name": "Color temperature",
-    "field_color_temp_name": "Color temperature",
     "field_effect_description": "Light effect.",
     "field_effect_name": "Effect",
     "field_flash_description": "Tell light to flash, can be either value short or long.",
@@ -112,9 +110,6 @@
             "xy": "XY"
           }
         },
-        "color_temp": {
-          "name": "Color temperature (mireds)"
-        },
         "color_temp_kelvin": {
           "name": "Color temperature (Kelvin)"
         },
@@ -130,15 +125,9 @@
         "max_color_temp_kelvin": {
           "name": "Maximum color temperature (Kelvin)"
         },
-        "max_mireds": {
-          "name": "Maximum color temperature (mireds)"
-        },
         "min_color_temp_kelvin": {
           "name": "Minimum color temperature (Kelvin)"
         },
-        "min_mireds": {
-          "name": "Minimum color temperature (mireds)"
-        },
         "supported_color_modes": {
           "name": "Available color modes",
           "state": {
@@ -366,10 +355,6 @@
           "description": "[%key:component::light::common::field_color_name_description%]",
           "name": "[%key:component::light::common::field_color_name_name%]"
         },
-        "color_temp": {
-          "description": "[%key:component::light::common::field_color_temp_description%]",
-          "name": "[%key:component::light::common::field_color_temp_name%]"
-        },
         "color_temp_kelvin": {
           "description": "[%key:component::light::common::field_color_temp_kelvin_description%]",
           "name": "[%key:component::light::common::field_color_temp_kelvin_name%]"
@@ -464,10 +449,6 @@
           "description": "[%key:component::light::common::field_color_name_description%]",
           "name": "[%key:component::light::common::field_color_name_name%]"
         },
-        "color_temp": {
-          "description": "[%key:component::light::common::field_color_temp_description%]",
-          "name": "[%key:component::light::common::field_color_temp_name%]"
-        },
         "color_temp_kelvin": {
           "description": "[%key:component::light::common::field_color_temp_kelvin_description%]",
           "name": "[%key:component::light::common::field_color_temp_kelvin_name%]"

homeassistant/components/linkplay/__init__.py

@@ -12,10 +12,15 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.typing import ConfigType
 
 from .const import DOMAIN, PLATFORMS, SHARED_DATA, LinkPlaySharedData
+from .services import async_setup_services
 from .utils import async_get_client_session
 
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+
 
 @dataclass
 class LinkPlayData:
@@ -27,6 +32,12 @@ class LinkPlayData:
 type LinkPlayConfigEntry = ConfigEntry[LinkPlayData]
 
 
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the component."""
+    async_setup_services(hass)
+    return True
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: LinkPlayConfigEntry) -> bool:
     """Async setup hass config entry. Called when an entry has been setup."""
 

homeassistant/components/linkplay/media_player.py

@@ -10,7 +10,6 @@ from linkplay.bridge import LinkPlayBridge
 from linkplay.consts import EqualizerMode, LoopMode, PlayingMode, PlayingStatus
 from linkplay.controller import LinkPlayController, LinkPlayMultiroom
 from linkplay.exceptions import LinkPlayRequestException
-import voluptuous as vol
 
 from homeassistant.components import media_source
 from homeassistant.components.media_player import (
@@ -25,7 +24,6 @@ from homeassistant.components.media_player import (
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
-from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util.dt import utcnow
 
@@ -106,15 +104,6 @@ SEEKABLE_FEATURES: MediaPlayerEntityFeature = (
     | MediaPlayerEntityFeature.SEEK
 )
 
-SERVICE_PLAY_PRESET = "play_preset"
-ATTR_PRESET_NUMBER = "preset_number"
-
-SERVICE_PLAY_PRESET_SCHEMA = cv.make_entity_service_schema(
-    {
-        vol.Required(ATTR_PRESET_NUMBER): cv.positive_int,
-    }
-)
-
 RETRY_POLL_MAXIMUM = 3
 SCAN_INTERVAL = timedelta(seconds=5)
 PARALLEL_UPDATES = 1
@@ -126,14 +115,6 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up a media player from a config entry."""
-
-    # register services
-    platform = entity_platform.async_get_current_platform()
-    platform.async_register_entity_service(
-        SERVICE_PLAY_PRESET, SERVICE_PLAY_PRESET_SCHEMA, "async_play_preset"
-    )
-
-    # add entities
     async_add_entities([LinkPlayMediaPlayerEntity(entry.runtime_data.bridge)])
 
 

homeassistant/components/linkplay/services.py

@@ -0,0 +1,33 @@
+"""Support for LinkPlay media players."""
+
+from __future__ import annotations
+
+import voluptuous as vol
+
+from homeassistant.components.media_player import DOMAIN as MEDIA_PLAYER_DOMAIN
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import config_validation as cv, service
+
+from .const import DOMAIN
+
+SERVICE_PLAY_PRESET = "play_preset"
+ATTR_PRESET_NUMBER = "preset_number"
+
+SERVICE_PLAY_PRESET_SCHEMA = cv.make_entity_service_schema(
+    {
+        vol.Required(ATTR_PRESET_NUMBER): cv.positive_int,
+    }
+)
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Set up services."""
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_PLAY_PRESET,
+        entity_domain=MEDIA_PLAYER_DOMAIN,
+        schema=SERVICE_PLAY_PRESET_SCHEMA,
+        func="async_play_preset",
+    )

homeassistant/components/litterrobot/__init__.py

@@ -6,11 +6,15 @@ import itertools
 
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.device_registry import DeviceEntry
+from homeassistant.helpers.typing import ConfigType
 
 from .const import DOMAIN
 from .coordinator import LitterRobotConfigEntry, LitterRobotDataUpdateCoordinator
+from .services import async_setup_services
 
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 PLATFORMS = [
     Platform.BINARY_SENSOR,
     Platform.BUTTON,
@@ -23,6 +27,12 @@ PLATFORMS = [
 ]
 
 
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the component."""
+    async_setup_services(hass)
+    return True
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: LitterRobotConfigEntry) -> bool:
     """Set up Litter-Robot from a config entry."""
     coordinator = LitterRobotDataUpdateCoordinator(hass, entry)

homeassistant/components/litterrobot/services.py

@@ -0,0 +1,30 @@
+"""Litter-Robot services."""
+
+from __future__ import annotations
+
+import voluptuous as vol
+
+from homeassistant.components.vacuum import DOMAIN as VACUUM_DOMAIN
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import config_validation as cv, service
+
+from .const import DOMAIN
+
+SERVICE_SET_SLEEP_MODE = "set_sleep_mode"
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Set up services."""
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_SET_SLEEP_MODE,
+        entity_domain=VACUUM_DOMAIN,
+        schema={
+            vol.Required("enabled"): cv.boolean,
+            vol.Optional("start_time"): cv.time,
+        },
+        func="async_set_sleep_mode",
+    )

homeassistant/components/litterrobot/vacuum.py

@@ -7,7 +7,6 @@ from typing import Any
 
 from pylitterbot import LitterRobot
 from pylitterbot.enums import LitterBoxStatus
-import voluptuous as vol
 
 from homeassistant.components.vacuum import (
     StateVacuumEntity,
@@ -16,15 +15,12 @@ from homeassistant.components.vacuum import (
     VacuumEntityFeature,
 )
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import dt as dt_util
 
 from .coordinator import LitterRobotConfigEntry
 from .entity import LitterRobotEntity
 
-SERVICE_SET_SLEEP_MODE = "set_sleep_mode"
-
 LITTER_BOX_STATUS_STATE_MAP = {
     LitterBoxStatus.CLEAN_CYCLE: VacuumActivity.CLEANING,
     LitterBoxStatus.EMPTY_CYCLE: VacuumActivity.CLEANING,
@@ -57,16 +53,6 @@ async def async_setup_entry(
         for robot in coordinator.litter_robots()
     )
 
-    platform = entity_platform.async_get_current_platform()
-    platform.async_register_entity_service(
-        SERVICE_SET_SLEEP_MODE,
-        {
-            vol.Required("enabled"): cv.boolean,
-            vol.Optional("start_time"): cv.time,
-        },
-        "async_set_sleep_mode",
-    )
-
 
 class LitterRobotCleaner(LitterRobotEntity[LitterRobot], StateVacuumEntity):
     """Litter-Robot "Vacuum" Cleaner."""

homeassistant/components/lovelace/strings.json

@@ -6,8 +6,8 @@
   },
   "issues": {
     "yaml_mode_deprecated": {
-      "description": "The `mode` option in `lovelace:` configuration is deprecated and will be removed in Home Assistant 2026.8.\n\nTo migrate:\n\n1. Remove `mode: yaml` from `lovelace:` in your `configuration.yaml`\n2. If you have `resources:` declared in your lovelace configuration, add `resource_mode: yaml` to keep loading resources from YAML\n3. Add a dashboard entry in your `configuration.yaml`:\n\n   ```yaml\n   lovelace:\n     resource_mode: yaml  # Add this if you have resources declared\n     dashboards:\n       lovelace:\n         mode: yaml\n         filename: {config_file}\n         title: Overview\n         icon: mdi:view-dashboard\n         show_in_sidebar: true\n   ```\n\n4. Restart Home Assistant",
-      "title": "Lovelace YAML mode deprecated"
+      "description": "Your YAML dashboard configuration uses the legacy `mode: yaml` option, which will be removed in Home Assistant 2026.8. Your YAML dashboards will continue to work, you just need to update how they are defined.\n\nTo update your configuration:\n\n1. Remove `mode: yaml` from `lovelace:` in your `configuration.yaml`\n2. Add a dashboard entry instead:\n\n   ```yaml\n   lovelace:\n     resource_mode: yaml\n     dashboards:\n       lovelace:\n         mode: yaml\n         filename: {config_file}\n         title: Overview\n         icon: mdi:view-dashboard\n         show_in_sidebar: true\n   ```\n\n3. Restart Home Assistant\n\nNote: `resource_mode: yaml` keeps loading resources from YAML. If you want to manage resources through the UI instead, you can remove this line and move your resources to Settings > Dashboards > Resources.",
+      "title": "Lovelace YAML configuration needs update"
     }
   },
   "services": {

homeassistant/components/marytts/tts.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from typing import Any
+
 from speak2mary import MaryTTS
 import voluptuous as vol
 
@@ -9,6 +11,7 @@ from homeassistant.components.tts import (
     CONF_LANG,
     PLATFORM_SCHEMA as TTS_PLATFORM_SCHEMA,
     Provider,
+    TtsAudioType,
 )
 from homeassistant.const import CONF_EFFECT, CONF_HOST, CONF_PORT
 from homeassistant.helpers import config_validation as cv
@@ -66,26 +69,28 @@ class MaryTTSProvider(Provider):
         self.name = "MaryTTS"
 
     @property
-    def default_language(self):
+    def default_language(self) -> str:
         """Return the default language."""
         return self._mary.locale
 
     @property
-    def supported_languages(self):
+    def supported_languages(self) -> list[str]:
         """Return list of supported languages."""
         return SUPPORT_LANGUAGES
 
     @property
-    def default_options(self):
+    def default_options(self) -> dict[str, Any]:
         """Return dict include default options."""
         return {CONF_EFFECT: self._effects}
 
     @property
-    def supported_options(self):
+    def supported_options(self) -> list[str]:
         """Return a list of supported options."""
         return SUPPORT_OPTIONS
 
-    def get_tts_audio(self, message, language, options):
+    def get_tts_audio(
+        self, message: str, language: str, options: dict[str, Any]
+    ) -> TtsAudioType:
         """Load TTS from MaryTTS."""
         effects = options[CONF_EFFECT]
 

homeassistant/components/media_extractor/manifest.json

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

homeassistant/components/media_player/strings.json

@@ -266,7 +266,7 @@
       "name": "Browse media"
     },
     "clear_playlist": {
-      "description": "Removes all items from the playlist.",
+      "description": "Removes all items from a media player's playlist.",
       "name": "Clear playlist"
     },
     "join": {
@@ -284,15 +284,15 @@
       "name": "Next"
     },
     "media_pause": {
-      "description": "Pauses.",
+      "description": "Pauses playback on a media player.",
       "name": "[%key:common::action::pause%]"
     },
     "media_play": {
-      "description": "Starts playing.",
+      "description": "Starts playback on a media player.",
       "name": "Play"
     },
     "media_play_pause": {
-      "description": "Toggles play/pause.",
+      "description": "Toggles play/pause on a media player.",
       "name": "Play/Pause"
     },
     "media_previous_track": {
@@ -310,7 +310,7 @@
       "name": "Seek"
     },
     "media_stop": {
-      "description": "Stops playing.",
+      "description": "Stops playback on a media player.",
       "name": "[%key:common::action::stop%]"
     },
     "play_media": {
@@ -374,7 +374,7 @@
       "name": "Select sound mode"
     },
     "select_source": {
-      "description": "Sends the media player the command to change input source.",
+      "description": "Sends a media player the command to change the input source.",
       "fields": {
         "source": {
           "description": "Name of the source to switch to. Platform dependent.",
@@ -398,23 +398,23 @@
       "name": "[%key:common::action::toggle%]"
     },
     "turn_off": {
-      "description": "Turns off the power of the media player.",
+      "description": "Turns off the power of a media player.",
       "name": "[%key:common::action::turn_off%]"
     },
     "turn_on": {
-      "description": "Turns on the power of the media player.",
+      "description": "Turns on the power of a media player.",
       "name": "[%key:common::action::turn_on%]"
     },
     "unjoin": {
-      "description": "Removes the player from a group. Only works on platforms which support player groups.",
+      "description": "Removes a media player from a group. Only works on platforms which support player groups.",
       "name": "Unjoin"
     },
     "volume_down": {
-      "description": "Turns down the volume.",
+      "description": "Turns down the volume of a media player.",
       "name": "Turn down volume"
     },
     "volume_mute": {
-      "description": "Mutes or unmutes the media player.",
+      "description": "Mutes or unmutes a media player.",
       "fields": {
         "is_volume_muted": {
           "description": "Defines whether or not it is muted.",
@@ -424,7 +424,7 @@
       "name": "Mute/unmute volume"
     },
     "volume_set": {
-      "description": "Sets the volume level.",
+      "description": "Sets the volume level of a media player.",
       "fields": {
         "volume_level": {
           "description": "The volume. 0 is inaudible, 1 is the maximum volume.",
@@ -434,7 +434,7 @@
       "name": "Set volume"
     },
     "volume_up": {
-      "description": "Turns up the volume.",
+      "description": "Turns up the volume of a media player.",
       "name": "Turn up volume"
     }
   },

homeassistant/components/microsoft/tts.py

@@ -1,6 +1,7 @@
 """Support for the Microsoft Cognitive Services text-to-speech service."""
 
 import logging
+from typing import Any
 
 from pycsspeechtts import pycsspeechtts
 from requests.exceptions import HTTPError
@@ -10,6 +11,7 @@ from homeassistant.components.tts import (
     CONF_LANG,
     PLATFORM_SCHEMA as TTS_PLATFORM_SCHEMA,
     Provider,
+    TtsAudioType,
 )
 from homeassistant.const import CONF_API_KEY, CONF_REGION, CONF_TYPE, PERCENTAGE
 from homeassistant.generated.microsoft_tts import SUPPORTED_LANGUAGES
@@ -89,26 +91,28 @@ class MicrosoftProvider(Provider):
         self.name = "Microsoft"
 
     @property
-    def default_language(self):
+    def default_language(self) -> str:
         """Return the default language."""
         return self._lang
 
     @property
-    def supported_languages(self):
+    def supported_languages(self) -> list[str]:
         """Return list of supported languages."""
-        return SUPPORTED_LANGUAGES
+        return list(SUPPORTED_LANGUAGES)
 
     @property
-    def supported_options(self):
+    def supported_options(self) -> list[str]:
         """Return list of supported options like voice, emotion."""
         return [CONF_GENDER, CONF_TYPE]
 
     @property
-    def default_options(self):
+    def default_options(self) -> dict[str, Any]:
         """Return a dict include default options."""
         return {CONF_GENDER: self._gender, CONF_TYPE: self._type}
 
-    def get_tts_audio(self, message, language, options):
+    def get_tts_audio(
+        self, message: str, language: str, options: dict[str, Any]
+    ) -> TtsAudioType:
         """Load TTS from Microsoft."""
         if language is None:
             language = self._lang

homeassistant/components/miele/const.py

@@ -806,6 +806,8 @@ class CoffeeSystemProgramId(MieleEnum, missing_to_none=True):
         24813,  # add profile
     )
     appliance_rinse = 24750, 24759, 24773, 24787, 24788
+    intermediate_rinsing = 24758
+    automatic_maintenance = 24778
     descaling = 24751
     brewing_unit_degrease = 24753
     milk_pipework_rinse = 24754