Merge branch 'edenhaus-builder-action' into edenhaus-test

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

@@ -0,0 +1,129 @@
+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}"
+      env:
+        INPUTS_COSIGN_BASE_IDENTITY: ${{ inputs.cosign-base-identity }}
+        INPUTS_BASE_IMAGE: ${{ 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"
+      env:
+        INPUTS_ARCH: ${{ inputs.arch }}
+
+    - 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"
+      env:
+        INPUTS_ARCH: ${{ inputs.arch }}
+        INPUTS_VERSION: ${{ inputs.version }}
+        INPUTS_ADDITIONAL_LABELS: ${{ inputs.additional-labels }}
+
+    - name: Build base image
+      id: build
+      uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
+      with:
+        context: .
+        file: ${{ inputs.dockerfile }}
+        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}"
+      env:
+        STEPS_BUILD_OUTPUTS_DIGEST: ${{ steps.build.outputs.digest }}
+        INPUTS_TAGS: ${{ inputs.tags }}

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

@@ -0,0 +1,73 @@
+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"
+      env:
+        INPUTS_ARCH: ${{ inputs.arch }}
+        INPUTS_VERSION: ${{ inputs.version }}
+        INPUTS_MACHINE: ${{ inputs.machine }}
+
+    - 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

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

.github/workflows/wheels.yml

@@ -110,7 +110,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        abi: ["cp314"]
+        abi: ["cp313", "cp314"]
         arch: ["amd64", "aarch64"]
         include:
           - arch: amd64
@@ -161,7 +161,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        abi: ["cp314"]
+        abi: ["cp313", "cp314"]
         arch: ["amd64", "aarch64"]
         include:
           - arch: amd64
@@ -209,4 +209,4 @@ jobs:
           skip-binary: aiohttp;charset-normalizer;grpcio;multidict;SQLAlchemy;propcache;protobuf;pymicro-vad;yarl
           constraints: "homeassistant/package_constraints.txt"
           requirements-diff: "requirements_diff.txt"
-          requirements: "requirements_all_wheels_${{ matrix.arch }}.txt"
+          requirements: "requirements_all.txt"

CODEOWNERS

@@ -242,8 +242,6 @@ build.json @home-assistant/supervisor
 /tests/components/bosch_alarm/ @mag1024 @sanjay900
 /homeassistant/components/bosch_shc/ @tschamm
 /tests/components/bosch_shc/ @tschamm
-/homeassistant/components/brands/ @home-assistant/core
-/tests/components/brands/ @home-assistant/core
 /homeassistant/components/braviatv/ @bieniu @Drafteed
 /tests/components/braviatv/ @bieniu @Drafteed
 /homeassistant/components/bring/ @miaucl @tr4nt0r
@@ -719,8 +717,8 @@ build.json @home-assistant/supervisor
 /tests/components/homematic/ @pvizeli
 /homeassistant/components/homematicip_cloud/ @hahn-th @lackas
 /tests/components/homematicip_cloud/ @hahn-th @lackas
-/homeassistant/components/homevolt/ @danielhiversen @liudger
-/tests/components/homevolt/ @danielhiversen @liudger
+/homeassistant/components/homevolt/ @danielhiversen
+/tests/components/homevolt/ @danielhiversen
 /homeassistant/components/homewizard/ @DCSBL
 /tests/components/homewizard/ @DCSBL
 /homeassistant/components/honeywell/ @rdfurman @mkmer

Dockerfile

@@ -30,7 +30,7 @@ RUN \
     # Verify go2rtc can be executed
     go2rtc --version \
     # Install uv
-    && pip3 install uv==0.10.6
+    && pip3 install uv==0.9.26
 
 WORKDIR /usr/src
 

homeassistant/bootstrap.py

@@ -70,7 +70,7 @@ from .const import (
     SIGNAL_BOOTSTRAP_INTEGRATIONS,
 )
 from .core_config import async_process_ha_core_config
-from .exceptions import HomeAssistantError, UnsupportedStorageVersionError
+from .exceptions import HomeAssistantError
 from .helpers import (
     area_registry,
     category_registry,
@@ -210,7 +210,6 @@ DEFAULT_INTEGRATIONS = {
     "analytics",  # Needed for onboarding
     "application_credentials",
     "backup",
-    "brands",
     "frontend",
     "hardware",
     "labs",
@@ -239,8 +238,6 @@ DEFAULT_INTEGRATIONS = {
 }
 DEFAULT_INTEGRATIONS_RECOVERY_MODE = {
     # These integrations are set up if recovery mode is activated.
-    "backup",
-    "cloud",
     "frontend",
 }
 DEFAULT_INTEGRATIONS_SUPERVISOR = {
@@ -435,56 +432,32 @@ def _init_blocking_io_modules_in_executor() -> None:
     is_docker_env()
 
 
-async def async_load_base_functionality(hass: core.HomeAssistant) -> bool:
-    """Load the registries and modules that will do blocking I/O.
-
-    Return whether loading succeeded.
-    """
+async def async_load_base_functionality(hass: core.HomeAssistant) -> None:
+    """Load the registries and modules that will do blocking I/O."""
     if DATA_REGISTRIES_LOADED in hass.data:
-        return True
-
+        return
     hass.data[DATA_REGISTRIES_LOADED] = None
     entity.async_setup(hass)
     frame.async_setup(hass)
     template.async_setup(hass)
     translation.async_setup(hass)
-
-    recovery = hass.config.recovery_mode
-    try:
-        await asyncio.gather(
-            create_eager_task(get_internal_store_manager(hass).async_initialize()),
-            create_eager_task(area_registry.async_load(hass, load_empty=recovery)),
-            create_eager_task(category_registry.async_load(hass, load_empty=recovery)),
-            create_eager_task(device_registry.async_load(hass, load_empty=recovery)),
-            create_eager_task(entity_registry.async_load(hass, load_empty=recovery)),
-            create_eager_task(floor_registry.async_load(hass, load_empty=recovery)),
-            create_eager_task(issue_registry.async_load(hass, load_empty=recovery)),
-            create_eager_task(label_registry.async_load(hass, load_empty=recovery)),
-            hass.async_add_executor_job(_init_blocking_io_modules_in_executor),
-            create_eager_task(template.async_load_custom_templates(hass)),
-            create_eager_task(restore_state.async_load(hass, load_empty=recovery)),
-            create_eager_task(hass.config_entries.async_initialize()),
-            create_eager_task(async_get_system_info(hass)),
-            create_eager_task(condition.async_setup(hass)),
-            create_eager_task(trigger.async_setup(hass)),
-        )
-    except UnsupportedStorageVersionError as err:
-        # If we're already in recovery mode, we don't want to handle the exception
-        # and activate recovery mode again, as that would lead to an infinite loop.
-        if recovery:
-            raise
-
-        _LOGGER.error(
-            "Storage file %s was created by a newer version of Home Assistant"
-            " (storage version %s > %s); activating recovery mode; on-disk data"
-            " is preserved; upgrade Home Assistant or restore from a backup",
-            err.storage_key,
-            err.found_version,
-            err.max_supported_version,
-        )
-        return False
-
-    return True
+    await asyncio.gather(
+        create_eager_task(get_internal_store_manager(hass).async_initialize()),
+        create_eager_task(area_registry.async_load(hass)),
+        create_eager_task(category_registry.async_load(hass)),
+        create_eager_task(device_registry.async_load(hass)),
+        create_eager_task(entity_registry.async_load(hass)),
+        create_eager_task(floor_registry.async_load(hass)),
+        create_eager_task(issue_registry.async_load(hass)),
+        create_eager_task(label_registry.async_load(hass)),
+        hass.async_add_executor_job(_init_blocking_io_modules_in_executor),
+        create_eager_task(template.async_load_custom_templates(hass)),
+        create_eager_task(restore_state.async_load(hass)),
+        create_eager_task(hass.config_entries.async_initialize()),
+        create_eager_task(async_get_system_info(hass)),
+        create_eager_task(condition.async_setup(hass)),
+        create_eager_task(trigger.async_setup(hass)),
+    )
 
 
 async def async_from_config_dict(
@@ -501,9 +474,7 @@ async def async_from_config_dict(
     # Prime custom component cache early so we know if registry entries are tied
     # to a custom integration
     await loader.async_get_custom_components(hass)
-
-    if not await async_load_base_functionality(hass):
-        return None
+    await async_load_base_functionality(hass)
 
     # Set up core.
     _LOGGER.debug("Setting up %s", CORE_INTEGRATIONS)

homeassistant/brands/ubisys.json

@@ -1,5 +0,0 @@
-{
-  "domain": "ubisys",
-  "name": "Ubisys",
-  "iot_standards": ["zigbee"]
-}

homeassistant/components/accuweather/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["accuweather"],
-  "requirements": ["accuweather==5.1.0"]
+  "requirements": ["accuweather==5.0.0"]
 }

homeassistant/components/accuweather/system_health.py

@@ -30,8 +30,6 @@ async def system_health_info(hass: HomeAssistant) -> dict[str, Any]:
     )
 
     return {
-        "can_reach_server": system_health.async_check_can_reach_url(
-            hass, str(ENDPOINT)
-        ),
+        "can_reach_server": system_health.async_check_can_reach_url(hass, ENDPOINT),
         "remaining_requests": remaining_requests,
     }

homeassistant/components/accuweather/weather.py

@@ -191,7 +191,7 @@ class AccuWeatherEntity(
             {
                 ATTR_FORECAST_TIME: utc_from_timestamp(item["EpochDate"]).isoformat(),
                 ATTR_FORECAST_CLOUD_COVERAGE: item["CloudCoverDay"],
-                ATTR_FORECAST_HUMIDITY: item["RelativeHumidityDay"].get("Average"),
+                ATTR_FORECAST_HUMIDITY: item["RelativeHumidityDay"]["Average"],
                 ATTR_FORECAST_NATIVE_TEMP: item["TemperatureMax"][ATTR_VALUE],
                 ATTR_FORECAST_NATIVE_TEMP_LOW: item["TemperatureMin"][ATTR_VALUE],
                 ATTR_FORECAST_NATIVE_APPARENT_TEMP: item["RealFeelTemperatureMax"][

homeassistant/components/airobot/number.py

@@ -93,6 +93,7 @@ class AirobotNumber(AirobotEntity, NumberEntity):
             raise ServiceValidationError(
                 translation_domain=DOMAIN,
                 translation_key="set_value_failed",
+                translation_placeholders={"error": str(err)},
             ) from err
         else:
             await self.coordinator.async_request_refresh()

homeassistant/components/airobot/strings.json

@@ -112,7 +112,7 @@
       "message": "Failed to set temperature to {temperature}."
     },
     "set_value_failed": {
-      "message": "Failed to set value."
+      "message": "Failed to set value: {error}"
     },
     "switch_turn_off_failed": {
       "message": "Failed to turn off {switch}."

homeassistant/components/airos/binary_sensor.py

@@ -89,10 +89,11 @@ async def async_setup_entry(
     """Set up the AirOS binary sensors from a config entry."""
     coordinator = config_entry.runtime_data
 
-    entities = [
+    entities: list[BinarySensorEntity] = []
+    entities.extend(
         AirOSBinarySensor(coordinator, description)
         for description in COMMON_BINARY_SENSORS
-    ]
+    )
 
     if coordinator.device_data["fw_major"] == 8:
         entities.extend(

homeassistant/components/airos/sensor.py

@@ -182,15 +182,15 @@ async def async_setup_entry(
     """Set up the AirOS sensors from a config entry."""
     coordinator = config_entry.runtime_data
 
-    entities = [AirOSSensor(coordinator, description) for description in COMMON_SENSORS]
+    async_add_entities(
+        AirOSSensor(coordinator, description) for description in COMMON_SENSORS
+    )
 
     if coordinator.device_data["fw_major"] == 8:
-        entities.extend(
+        async_add_entities(
             AirOSSensor(coordinator, description) for description in AIROS8_SENSORS
         )
 
-    async_add_entities(entities)
-
 
 class AirOSSensor(AirOSEntity, SensorEntity):
     """Representation of a Sensor."""

homeassistant/components/aladdin_connect/coordinator.py

@@ -5,13 +5,12 @@ from __future__ import annotations
 from datetime import timedelta
 import logging
 
-import aiohttp
 from genie_partner_sdk.client import AladdinConnectClient
 from genie_partner_sdk.model import GarageDoor
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 type AladdinConnectConfigEntry = ConfigEntry[dict[str, AladdinConnectCoordinator]]
@@ -41,10 +40,7 @@ class AladdinConnectCoordinator(DataUpdateCoordinator[GarageDoor]):
 
     async def _async_update_data(self) -> GarageDoor:
         """Fetch data from the Aladdin Connect API."""
-        try:
-            await self.client.update_door(self.data.device_id, self.data.door_number)
-        except aiohttp.ClientError as err:
-            raise UpdateFailed(f"Error communicating with API: {err}") from err
+        await self.client.update_door(self.data.device_id, self.data.door_number)
         self.data.status = self.client.get_door_status(
             self.data.device_id, self.data.door_number
         )

homeassistant/components/aladdin_connect/cover.py

@@ -4,19 +4,14 @@ from __future__ import annotations
 
 from typing import Any
 
-import aiohttp
-
 from homeassistant.components.cover import CoverDeviceClass, CoverEntity
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN, SUPPORTED_FEATURES
+from .const import SUPPORTED_FEATURES
 from .coordinator import AladdinConnectConfigEntry, AladdinConnectCoordinator
 from .entity import AladdinConnectEntity
 
-PARALLEL_UPDATES = 1
-
 
 async def async_setup_entry(
     hass: HomeAssistant,
@@ -45,23 +40,11 @@ class AladdinCoverEntity(AladdinConnectEntity, CoverEntity):
 
     async def async_open_cover(self, **kwargs: Any) -> None:
         """Issue open command to cover."""
-        try:
-            await self.client.open_door(self._device_id, self._number)
-        except aiohttp.ClientError as err:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="open_door_failed",
-            ) from err
+        await self.client.open_door(self._device_id, self._number)
 
     async def async_close_cover(self, **kwargs: Any) -> None:
         """Issue close command to cover."""
-        try:
-            await self.client.close_door(self._device_id, self._number)
-        except aiohttp.ClientError as err:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="close_door_failed",
-            ) from err
+        await self.client.close_door(self._device_id, self._number)
 
     @property
     def is_closed(self) -> bool | None:

homeassistant/components/aladdin_connect/quality_scale.yaml

@@ -26,22 +26,20 @@ rules:
   unique-config-entry: done
 
   # Silver
-  action-exceptions: done
+  action-exceptions: todo
   config-entry-unloading: done
   docs-configuration-parameters:
     status: exempt
     comment: Integration does not have an options flow.
   docs-installation-parameters: done
-  entity-unavailable:
-    status: done
-    comment: Handled by the coordinator.
+  entity-unavailable: todo
   integration-owner: done
-  log-when-unavailable:
-    status: done
-    comment: Handled by the coordinator.
-  parallel-updates: done
+  log-when-unavailable: todo
+  parallel-updates: todo
   reauthentication-flow: done
-  test-coverage: done
+  test-coverage:
+    status: todo
+    comment: Platform tests for cover and sensor need to be implemented to reach 95% coverage.
 
   # Gold
   devices: done

homeassistant/components/aladdin_connect/sensor.py

@@ -20,8 +20,6 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from .coordinator import AladdinConnectConfigEntry, AladdinConnectCoordinator
 from .entity import AladdinConnectEntity
 
-PARALLEL_UPDATES = 0
-
 
 @dataclass(frozen=True, kw_only=True)
 class AladdinConnectSensorEntityDescription(SensorEntityDescription):

homeassistant/components/aladdin_connect/strings.json

@@ -32,13 +32,5 @@
         "title": "[%key:common::config_flow::title::reauth%]"
       }
     }
-  },
-  "exceptions": {
-    "close_door_failed": {
-      "message": "Failed to close the garage door"
-    },
-    "open_door_failed": {
-      "message": "Failed to open the garage door"
-    }
   }
 }

homeassistant/components/alexa_devices/entity.py

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

homeassistant/components/alexa_devices/manifest.json

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

homeassistant/components/anthropic/ai_task.py

@@ -46,7 +46,6 @@ class AnthropicTaskEntity(
         ai_task.AITaskEntityFeature.GENERATE_DATA
         | ai_task.AITaskEntityFeature.SUPPORT_ATTACHMENTS
     )
-    _attr_translation_key = "ai_task_data"
 
     async def _async_generate_data(
         self,

homeassistant/components/anthropic/config_flow.py

@@ -43,9 +43,7 @@ from homeassistant.helpers.selector import (
 from homeassistant.helpers.typing import VolDictType
 
 from .const import (
-    CODE_EXECUTION_UNSUPPORTED_MODELS,
     CONF_CHAT_MODEL,
-    CONF_CODE_EXECUTION,
     CONF_MAX_TOKENS,
     CONF_PROMPT,
     CONF_RECOMMENDED,
@@ -417,16 +415,6 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
         else:
             self.options.pop(CONF_THINKING_EFFORT, None)
 
-        if not model.startswith(tuple(CODE_EXECUTION_UNSUPPORTED_MODELS)):
-            step_schema[
-                vol.Optional(
-                    CONF_CODE_EXECUTION,
-                    default=DEFAULT[CONF_CODE_EXECUTION],
-                )
-            ] = bool
-        else:
-            self.options.pop(CONF_CODE_EXECUTION, None)
-
         if not model.startswith(tuple(WEB_SEARCH_UNSUPPORTED_MODELS)):
             step_schema.update(
                 {

homeassistant/components/anthropic/const.py

@@ -11,7 +11,6 @@ DEFAULT_AI_TASK_NAME = "Claude AI Task"
 CONF_RECOMMENDED = "recommended"
 CONF_PROMPT = "prompt"
 CONF_CHAT_MODEL = "chat_model"
-CONF_CODE_EXECUTION = "code_execution"
 CONF_MAX_TOKENS = "max_tokens"
 CONF_TEMPERATURE = "temperature"
 CONF_THINKING_BUDGET = "thinking_budget"
@@ -26,7 +25,6 @@ CONF_WEB_SEARCH_TIMEZONE = "timezone"
 
 DEFAULT = {
     CONF_CHAT_MODEL: "claude-haiku-4-5",
-    CONF_CODE_EXECUTION: False,
     CONF_MAX_TOKENS: 3000,
     CONF_TEMPERATURE: 1.0,
     CONF_THINKING_BUDGET: 0,
@@ -67,10 +65,6 @@ WEB_SEARCH_UNSUPPORTED_MODELS = [
     "claude-3-haiku",
 ]
 
-CODE_EXECUTION_UNSUPPORTED_MODELS = [
-    "claude-3-haiku",
-]
-
 DEPRECATED_MODELS = [
     "claude-3",
 ]

homeassistant/components/anthropic/conversation.py

@@ -37,7 +37,6 @@ class AnthropicConversationEntity(
     """Anthropic conversation agent."""
 
     _attr_supports_streaming = True
-    _attr_translation_key = "conversation"
 
     def __init__(self, entry: AnthropicConfigEntry, subentry: ConfigSubentry) -> None:
         """Initialize the agent."""

homeassistant/components/anthropic/entity.py

@@ -3,23 +3,19 @@
 import base64
 from collections.abc import AsyncGenerator, Callable, Iterable
 from dataclasses import dataclass, field
-from datetime import UTC, datetime
 import json
 from mimetypes import guess_file_type
 from pathlib import Path
-from typing import Any, Literal, cast
+from typing import Any
 
 import anthropic
 from anthropic import AsyncStream
 from anthropic.types import (
     Base64ImageSourceParam,
     Base64PDFSourceParam,
-    BashCodeExecutionToolResultBlock,
     CitationsDelta,
     CitationsWebSearchResultLocation,
     CitationWebSearchResultLocationParam,
-    CodeExecutionTool20250825Param,
-    Container,
     ContentBlockParam,
     DocumentBlockParam,
     ImageBlockParam,
@@ -45,7 +41,6 @@ from anthropic.types import (
     TextCitation,
     TextCitationParam,
     TextDelta,
-    TextEditorCodeExecutionToolResultBlock,
     ThinkingBlock,
     ThinkingBlockParam,
     ThinkingConfigAdaptiveParam,
@@ -56,21 +51,18 @@ from anthropic.types import (
     ToolChoiceAutoParam,
     ToolChoiceToolParam,
     ToolParam,
+    ToolResultBlockParam,
     ToolUnionParam,
     ToolUseBlock,
     ToolUseBlockParam,
     Usage,
     WebSearchTool20250305Param,
+    WebSearchToolRequestErrorParam,
     WebSearchToolResultBlock,
-    WebSearchToolResultBlockParamContentParam,
-)
-from anthropic.types.bash_code_execution_tool_result_block_param import (
-    Content as BashCodeExecutionToolResultContentParam,
+    WebSearchToolResultBlockParam,
+    WebSearchToolResultError,
 )
 from anthropic.types.message_create_params import MessageCreateParamsStreaming
-from anthropic.types.text_editor_code_execution_tool_result_block_param import (
-    Content as TextEditorCodeExecutionToolResultContentParam,
-)
 import voluptuous as vol
 from voluptuous_openapi import convert
 
@@ -82,12 +74,10 @@ from homeassistant.helpers import device_registry as dr, llm
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.json import json_dumps
 from homeassistant.util import slugify
-from homeassistant.util.json import JsonObjectType
 
 from . import AnthropicConfigEntry
 from .const import (
     CONF_CHAT_MODEL,
-    CONF_CODE_EXECUTION,
     CONF_MAX_TOKENS,
     CONF_TEMPERATURE,
     CONF_THINKING_BUDGET,
@@ -144,7 +134,6 @@ class ContentDetails:
     citation_details: list[CitationDetails] = field(default_factory=list)
     thinking_signature: str | None = None
     redacted_thinking: str | None = None
-    container: Container | None = None
 
     def has_content(self) -> bool:
         """Check if there is any text content."""
@@ -155,7 +144,6 @@ class ContentDetails:
         return (
             self.thinking_signature is not None
             or self.redacted_thinking is not None
-            or self.container is not None
             or self.has_citations()
         )
 
@@ -200,53 +188,30 @@ class ContentDetails:
 
 def _convert_content(
     chat_content: Iterable[conversation.Content],
-) -> tuple[list[MessageParam], str | None]:
+) -> list[MessageParam]:
     """Transform HA chat_log content into Anthropic API format."""
     messages: list[MessageParam] = []
-    container_id: str | None = None
 
     for content in chat_content:
         if isinstance(content, conversation.ToolResultContent):
-            external_tool = True
             if content.tool_name == "web_search":
-                tool_result_block: ContentBlockParam = {
-                    "type": "web_search_tool_result",
-                    "tool_use_id": content.tool_call_id,
-                    "content": cast(
-                        WebSearchToolResultBlockParamContentParam,
-                        content.tool_result["content"]
-                        if "content" in content.tool_result
-                        else {
-                            "type": "web_search_tool_result_error",
-                            "error_code": content.tool_result.get(
-                                "error_code", "unavailable"
-                            ),
-                        },
+                tool_result_block: ContentBlockParam = WebSearchToolResultBlockParam(
+                    type="web_search_tool_result",
+                    tool_use_id=content.tool_call_id,
+                    content=content.tool_result["content"]
+                    if "content" in content.tool_result
+                    else WebSearchToolRequestErrorParam(
+                        type="web_search_tool_result_error",
+                        error_code=content.tool_result.get("error_code", "unavailable"),  # type: ignore[typeddict-item]
                     ),
-                }
-            elif content.tool_name == "bash_code_execution":
-                tool_result_block = {
-                    "type": "bash_code_execution_tool_result",
-                    "tool_use_id": content.tool_call_id,
-                    "content": cast(
-                        BashCodeExecutionToolResultContentParam, content.tool_result
-                    ),
-                }
-            elif content.tool_name == "text_editor_code_execution":
-                tool_result_block = {
-                    "type": "text_editor_code_execution_tool_result",
-                    "tool_use_id": content.tool_call_id,
-                    "content": cast(
-                        TextEditorCodeExecutionToolResultContentParam,
-                        content.tool_result,
-                    ),
-                }
+                )
+                external_tool = True
             else:
-                tool_result_block = {
-                    "type": "tool_result",
-                    "tool_use_id": content.tool_call_id,
-                    "content": json_dumps(content.tool_result),
-                }
+                tool_result_block = ToolResultBlockParam(
+                    type="tool_result",
+                    tool_use_id=content.tool_call_id,
+                    content=json_dumps(content.tool_result),
+                )
                 external_tool = False
             if not messages or messages[-1]["role"] != (
                 "assistant" if external_tool else "user"
@@ -312,11 +277,6 @@ def _convert_content(
                             data=content.native.redacted_thinking,
                         )
                     )
-                if (
-                    content.native.container is not None
-                    and content.native.container.expires_at > datetime.now(UTC)
-                ):
-                    container_id = content.native.container.id
 
             if content.content:
                 current_index = 0
@@ -365,23 +325,10 @@ def _convert_content(
                         ServerToolUseBlockParam(
                             type="server_tool_use",
                             id=tool_call.id,
-                            name=cast(
-                                Literal[
-                                    "web_search",
-                                    "bash_code_execution",
-                                    "text_editor_code_execution",
-                                ],
-                                tool_call.tool_name,
-                            ),
+                            name="web_search",
                             input=tool_call.tool_args,
                         )
-                        if tool_call.external
-                        and tool_call.tool_name
-                        in [
-                            "web_search",
-                            "bash_code_execution",
-                            "text_editor_code_execution",
-                        ]
+                        if tool_call.external and tool_call.tool_name == "web_search"
                         else ToolUseBlockParam(
                             type="tool_use",
                             id=tool_call.id,
@@ -403,7 +350,7 @@ def _convert_content(
             # Note: We don't pass SystemContent here as its passed to the API as the prompt
             raise TypeError(f"Unexpected content type: {type(content)}")
 
-    return messages, container_id
+    return messages
 
 
 async def _transform_stream(  # noqa: C901 - This is complex, but better to have it in one place
@@ -531,14 +478,7 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                     input={},
                 )
                 current_tool_args = ""
-            elif isinstance(
-                response.content_block,
-                (
-                    WebSearchToolResultBlock,
-                    BashCodeExecutionToolResultBlock,
-                    TextEditorCodeExecutionToolResultBlock,
-                ),
-            ):
+            elif isinstance(response.content_block, WebSearchToolResultBlock):
                 if content_details:
                     content_details.delete_empty()
                     yield {"native": content_details}
@@ -547,16 +487,26 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
                 yield {
                     "role": "tool_result",
                     "tool_call_id": response.content_block.tool_use_id,
-                    "tool_name": response.content_block.type.removesuffix(
-                        "_tool_result"
-                    ),
+                    "tool_name": "web_search",
                     "tool_result": {
-                        "content": cast(
-                            JsonObjectType, response.content_block.to_dict()["content"]
-                        )
+                        "type": "web_search_tool_result_error",
+                        "error_code": response.content_block.content.error_code,
                     }
-                    if isinstance(response.content_block.content, list)
-                    else cast(JsonObjectType, response.content_block.content.to_dict()),
+                    if isinstance(
+                        response.content_block.content, WebSearchToolResultError
+                    )
+                    else {
+                        "content": [
+                            {
+                                "type": "web_search_result",
+                                "encrypted_content": block.encrypted_content,
+                                "page_age": block.page_age,
+                                "title": block.title,
+                                "url": block.url,
+                            }
+                            for block in response.content_block.content
+                        ]
+                    },
                 }
                 first_block = True
         elif isinstance(response, RawContentBlockDeltaEvent):
@@ -605,7 +555,6 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
         elif isinstance(response, RawMessageDeltaEvent):
             if (usage := response.usage) is not None:
                 chat_log.async_trace(_create_token_stats(input_usage, usage))
-            content_details.container = response.delta.container
             if response.delta.stop_reason == "refusal":
                 raise HomeAssistantError("Potential policy violation detected")
         elif isinstance(response, RawMessageStopEvent):
@@ -677,7 +626,7 @@ class AnthropicBaseLLMEntity(Entity):
             )
         ]
 
-        messages, container_id = _convert_content(chat_log.content[1:])
+        messages = _convert_content(chat_log.content[1:])
 
         model = options.get(CONF_CHAT_MODEL, DEFAULT[CONF_CHAT_MODEL])
 
@@ -687,7 +636,6 @@ class AnthropicBaseLLMEntity(Entity):
             max_tokens=options.get(CONF_MAX_TOKENS, DEFAULT[CONF_MAX_TOKENS]),
             system=system_prompt,
             stream=True,
-            container=container_id,
         )
 
         if not model.startswith(tuple(NON_ADAPTIVE_THINKING_MODELS)):
@@ -726,14 +674,6 @@ class AnthropicBaseLLMEntity(Entity):
                 for tool in chat_log.llm_api.tools
             ]
 
-        if options.get(CONF_CODE_EXECUTION):
-            tools.append(
-                CodeExecutionTool20250825Param(
-                    name="code_execution",
-                    type="code_execution_20250825",
-                ),
-            )
-
         if options.get(CONF_WEB_SEARCH):
             web_search = WebSearchTool20250305Param(
                 name="web_search",
@@ -844,25 +784,21 @@ class AnthropicBaseLLMEntity(Entity):
             try:
                 stream = await client.messages.create(**model_args)
 
-                new_messages, model_args["container"] = _convert_content(
-                    [
-                        content
-                        async for content in chat_log.async_add_delta_content_stream(
-                            self.entity_id,
-                            _transform_stream(
-                                chat_log,
-                                stream,
-                                output_tool=structure_name or None,
-                            ),
-                        )
-                    ]
+                messages.extend(
+                    _convert_content(
+                        [
+                            content
+                            async for content in chat_log.async_add_delta_content_stream(
+                                self.entity_id,
+                                _transform_stream(
+                                    chat_log,
+                                    stream,
+                                    output_tool=structure_name or None,
+                                ),
+                            )
+                        ]
+                    )
                 )
-                messages.extend(new_messages)
-            except anthropic.AuthenticationError as err:
-                self.entry.async_start_reauth(self.hass)
-                raise HomeAssistantError(
-                    "Authentication error with Anthropic API, reauthentication required"
-                ) from err
             except anthropic.AnthropicError as err:
                 raise HomeAssistantError(
                     f"Sorry, I had a problem talking to Anthropic: {err}"

homeassistant/components/anthropic/icons.json

@@ -1,14 +0,0 @@
-{
-  "entity": {
-    "ai_task": {
-      "ai_task_data": {
-        "default": "mdi:asterisk"
-      }
-    },
-    "conversation": {
-      "conversation": {
-        "default": "mdi:asterisk"
-      }
-    }
-  }
-}

homeassistant/components/anthropic/manifest.json

@@ -1,6 +1,6 @@
 {
   "domain": "anthropic",
-  "name": "Anthropic",
+  "name": "Anthropic Conversation",
   "after_dependencies": ["assist_pipeline", "intent"],
   "codeowners": ["@Shulyaka"],
   "config_flow": true,

homeassistant/components/anthropic/quality_scale.yaml

@@ -92,7 +92,7 @@ rules:
       No entities disabled by default.
   entity-translations: todo
   exception-translations: todo
-  icon-translations: done
+  icon-translations: todo
   reconfiguration-flow: done
   repair-issues: done
   stale-devices:

homeassistant/components/anthropic/strings.json

@@ -69,7 +69,6 @@
         },
         "model": {
           "data": {
-            "code_execution": "[%key:component::anthropic::config_subentries::conversation::step::model::data::code_execution%]",
             "thinking_budget": "[%key:component::anthropic::config_subentries::conversation::step::model::data::thinking_budget%]",
             "thinking_effort": "[%key:component::anthropic::config_subentries::conversation::step::model::data::thinking_effort%]",
             "user_location": "[%key:component::anthropic::config_subentries::conversation::step::model::data::user_location%]",
@@ -77,7 +76,6 @@
             "web_search_max_uses": "[%key:component::anthropic::config_subentries::conversation::step::model::data::web_search_max_uses%]"
           },
           "data_description": {
-            "code_execution": "[%key:component::anthropic::config_subentries::conversation::step::model::data_description::code_execution%]",
             "thinking_budget": "[%key:component::anthropic::config_subentries::conversation::step::model::data_description::thinking_budget%]",
             "thinking_effort": "[%key:component::anthropic::config_subentries::conversation::step::model::data_description::thinking_effort%]",
             "user_location": "[%key:component::anthropic::config_subentries::conversation::step::model::data_description::user_location%]",
@@ -129,7 +127,6 @@
         },
         "model": {
           "data": {
-            "code_execution": "Code execution",
             "thinking_budget": "Thinking budget",
             "thinking_effort": "Thinking effort",
             "user_location": "Include home location",
@@ -137,7 +134,6 @@
             "web_search_max_uses": "Maximum web searches"
           },
           "data_description": {
-            "code_execution": "Allow the model to execute code in a secure sandbox environment, enabling it to analyze data and perform complex calculations.",
             "thinking_budget": "The number of tokens the model can use to think about the response out of the total maximum number of tokens. Set to 1024 or greater to enable extended thinking.",
             "thinking_effort": "Control how many tokens Claude uses when responding, trading off between response thoroughness and token efficiency",
             "user_location": "Localize search results based on home location",

homeassistant/components/august/manifest.json

@@ -30,5 +30,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["pubnub", "yalexs"],
-  "requirements": ["yalexs==9.2.0", "yalexs-ble==3.2.7"]
+  "requirements": ["yalexs==9.2.0", "yalexs-ble==3.2.4"]
 }

homeassistant/components/aws_s3/config_flow.py

@@ -60,8 +60,9 @@ class S3ConfigFlow(ConfigFlow, domain=DOMAIN):
                 }
             )
 
-            hostname = urlparse(user_input[CONF_ENDPOINT_URL]).hostname
-            if not hostname or not hostname.endswith(AWS_DOMAIN):
+            if not urlparse(user_input[CONF_ENDPOINT_URL]).hostname.endswith(
+                AWS_DOMAIN
+            ):
                 errors[CONF_ENDPOINT_URL] = "invalid_endpoint_url"
             else:
                 try:

homeassistant/components/aws_s3/diagnostics.py

@@ -1,55 +0,0 @@
-"""Diagnostics support for AWS S3."""
-
-from __future__ import annotations
-
-import dataclasses
-from typing import Any
-
-from homeassistant.components.backup import (
-    DATA_MANAGER as BACKUP_DATA_MANAGER,
-    BackupManager,
-)
-from homeassistant.components.diagnostics import async_redact_data
-from homeassistant.core import HomeAssistant
-
-from .const import (
-    CONF_ACCESS_KEY_ID,
-    CONF_BUCKET,
-    CONF_PREFIX,
-    CONF_SECRET_ACCESS_KEY,
-    DOMAIN,
-)
-from .coordinator import S3ConfigEntry
-from .helpers import async_list_backups_from_s3
-
-TO_REDACT = (CONF_ACCESS_KEY_ID, CONF_SECRET_ACCESS_KEY)
-
-
-async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant,
-    entry: S3ConfigEntry,
-) -> dict[str, Any]:
-    """Return diagnostics for a config entry."""
-    coordinator = entry.runtime_data
-    backup_manager: BackupManager = hass.data[BACKUP_DATA_MANAGER]
-    backups = await async_list_backups_from_s3(
-        coordinator.client,
-        bucket=entry.data[CONF_BUCKET],
-        prefix=entry.data.get(CONF_PREFIX, ""),
-    )
-
-    data = {
-        "coordinator_data": dataclasses.asdict(coordinator.data),
-        "config": {
-            **entry.data,
-            **entry.options,
-        },
-        "backup_agents": [
-            {"name": agent.name}
-            for agent in backup_manager.backup_agents.values()
-            if agent.domain == DOMAIN
-        ],
-        "backup": [backup.as_dict() for backup in backups],
-    }
-
-    return async_redact_data(data, TO_REDACT)

homeassistant/components/aws_s3/quality_scale.yaml

@@ -43,7 +43,7 @@ rules:
 
   # Gold
   devices: done
-  diagnostics: done
+  diagnostics: todo
   discovery-update-info:
     status: exempt
     comment: S3 is a cloud service that is not discovered on the network.

homeassistant/components/backup/store.py

@@ -29,17 +29,12 @@ class StoredBackupData(TypedDict):
 class _BackupStore(Store[StoredBackupData]):
     """Class to help storing backup data."""
 
-    # Maximum version we support reading for forward compatibility.
-    # This allows reading data written by a newer HA version after downgrade.
-    _MAX_READABLE_VERSION = 2
-
     def __init__(self, hass: HomeAssistant) -> None:
         """Initialize storage class."""
         super().__init__(
             hass,
             STORAGE_VERSION,
             STORAGE_KEY,
-            max_readable_version=self._MAX_READABLE_VERSION,
             minor_version=STORAGE_VERSION_MINOR,
         )
 
@@ -91,8 +86,8 @@ class _BackupStore(Store[StoredBackupData]):
         # data["config"]["schedule"]["state"] will be removed. The bump to 2 is
         # planned to happen after a 6 month quiet period with no minor version
         # changes.
-        # Reject if major version is higher than _MAX_READABLE_VERSION.
-        if old_major_version > self._MAX_READABLE_VERSION:
+        # Reject if major version is higher than 2.
+        if old_major_version > 2:
             raise NotImplementedError
         return data
 

homeassistant/components/backup/strings.json

@@ -43,11 +43,11 @@
       "title": "The backup location {agent_id} is unavailable"
     },
     "automatic_backup_failed_addons": {
-      "description": "Apps {failed_addons} could not be included in automatic backup. Please check the Supervisor logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured.",
-      "title": "Not all apps could be included in automatic backup"
+      "description": "Add-ons {failed_addons} could not be included in automatic backup. Please check the Supervisor logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured.",
+      "title": "Not all add-ons could be included in automatic backup"
     },
     "automatic_backup_failed_agents_addons_folders": {
-      "description": "The automatic backup was created with errors:\n* Locations which the backup could not be uploaded to: {failed_agents}\n* Apps which could not be backed up: {failed_addons}\n* Folders which could not be backed up: {failed_folders}\n\nPlease check the Core and Supervisor logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured.",
+      "description": "The automatic backup was created with errors:\n* Locations which the backup could not be uploaded to: {failed_agents}\n* Add-ons which could not be backed up: {failed_addons}\n* Folders which could not be backed up: {failed_folders}\n\nPlease check the Core and Supervisor logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured.",
       "title": "Automatic backup was created with errors"
     },
     "automatic_backup_failed_create": {

homeassistant/components/brands/__init__.py

@@ -1,291 +0,0 @@
-"""The Brands integration."""
-
-from __future__ import annotations
-
-from collections import deque
-from http import HTTPStatus
-import logging
-from pathlib import Path
-from random import SystemRandom
-import time
-from typing import Any, Final
-
-from aiohttp import ClientError, hdrs, web
-import voluptuous as vol
-
-from homeassistant.components import websocket_api
-from homeassistant.components.http import KEY_AUTHENTICATED, HomeAssistantView
-from homeassistant.core import HomeAssistant, callback, valid_domain
-from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.event import async_track_time_interval
-from homeassistant.helpers.typing import ConfigType
-from homeassistant.loader import async_get_custom_components
-
-from .const import (
-    ALLOWED_IMAGES,
-    BRANDS_CDN_URL,
-    CACHE_TTL,
-    CATEGORY_RE,
-    CDN_TIMEOUT,
-    DOMAIN,
-    HARDWARE_IMAGE_RE,
-    IMAGE_FALLBACKS,
-    PLACEHOLDER,
-    TOKEN_CHANGE_INTERVAL,
-)
-
-_LOGGER = logging.getLogger(__name__)
-_RND: Final = SystemRandom()
-
-CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
-
-
-async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up the Brands integration."""
-    access_tokens: deque[str] = deque([], 2)
-    access_tokens.append(hex(_RND.getrandbits(256))[2:])
-    hass.data[DOMAIN] = access_tokens
-
-    @callback
-    def _rotate_token(_now: Any) -> None:
-        """Rotate the access token."""
-        access_tokens.append(hex(_RND.getrandbits(256))[2:])
-
-    async_track_time_interval(hass, _rotate_token, TOKEN_CHANGE_INTERVAL)
-
-    hass.http.register_view(BrandsIntegrationView(hass))
-    hass.http.register_view(BrandsHardwareView(hass))
-    websocket_api.async_register_command(hass, ws_access_token)
-    return True
-
-
-@callback
-@websocket_api.websocket_command({vol.Required("type"): "brands/access_token"})
-def ws_access_token(
-    hass: HomeAssistant,
-    connection: websocket_api.ActiveConnection,
-    msg: dict[str, Any],
-) -> None:
-    """Return the current brands access token."""
-    access_tokens: deque[str] = hass.data[DOMAIN]
-    connection.send_result(msg["id"], {"token": access_tokens[-1]})
-
-
-def _read_cached_file_with_marker(
-    cache_path: Path,
-) -> tuple[bytes | None, float] | None:
-    """Read a cached file, distinguishing between content and 404 markers.
-
-    Returns (content, mtime) where content is None for 404 markers (empty files).
-    Returns None if the file does not exist at all.
-    """
-    if not cache_path.is_file():
-        return None
-    mtime = cache_path.stat().st_mtime
-    data = cache_path.read_bytes()
-    if not data:
-        # Empty file is a 404 marker
-        return (None, mtime)
-    return (data, mtime)
-
-
-def _write_cache_file(cache_path: Path, data: bytes) -> None:
-    """Write data to cache file, creating directories as needed."""
-    cache_path.parent.mkdir(parents=True, exist_ok=True)
-    cache_path.write_bytes(data)
-
-
-def _read_brand_file(brand_dir: Path, image: str) -> bytes | None:
-    """Read a brand image, trying fallbacks in a single I/O pass."""
-    for candidate in (image, *IMAGE_FALLBACKS.get(image, ())):
-        file_path = brand_dir / candidate
-        if file_path.is_file():
-            return file_path.read_bytes()
-    return None
-
-
-class _BrandsBaseView(HomeAssistantView):
-    """Base view for serving brand images."""
-
-    requires_auth = False
-
-    def __init__(self, hass: HomeAssistant) -> None:
-        """Initialize the view."""
-        self._hass = hass
-        self._cache_dir = Path(hass.config.cache_path(DOMAIN))
-
-    def _authenticate(self, request: web.Request) -> None:
-        """Authenticate the request using Bearer token or query token."""
-        access_tokens: deque[str] = self._hass.data[DOMAIN]
-        authenticated = (
-            request[KEY_AUTHENTICATED] or request.query.get("token") in access_tokens
-        )
-        if not authenticated:
-            if hdrs.AUTHORIZATION in request.headers:
-                raise web.HTTPUnauthorized
-            raise web.HTTPForbidden
-
-    async def _serve_from_custom_integration(
-        self,
-        domain: str,
-        image: str,
-    ) -> web.Response | None:
-        """Try to serve a brand image from a custom integration."""
-        custom_components = await async_get_custom_components(self._hass)
-        if (integration := custom_components.get(domain)) is None:
-            return None
-        if not integration.has_branding:
-            return None
-
-        brand_dir = Path(integration.file_path) / "brand"
-
-        data = await self._hass.async_add_executor_job(
-            _read_brand_file, brand_dir, image
-        )
-        if data is not None:
-            return self._build_response(data)
-
-        return None
-
-    async def _serve_from_cache_or_cdn(
-        self,
-        cdn_path: str,
-        cache_subpath: str,
-        *,
-        fallback_placeholder: bool = True,
-    ) -> web.Response:
-        """Serve from disk cache, fetching from CDN if needed."""
-        cache_path = self._cache_dir / cache_subpath
-        now = time.time()
-
-        # Try disk cache
-        result = await self._hass.async_add_executor_job(
-            _read_cached_file_with_marker, cache_path
-        )
-        if result is not None:
-            data, mtime = result
-            # Schedule background refresh if stale
-            if now - mtime > CACHE_TTL:
-                self._hass.async_create_background_task(
-                    self._fetch_and_cache(cdn_path, cache_path),
-                    f"brands_refresh_{cache_subpath}",
-                )
-        else:
-            # Cache miss - fetch from CDN
-            data = await self._fetch_and_cache(cdn_path, cache_path)
-
-        if data is None:
-            if fallback_placeholder:
-                return await self._serve_placeholder(
-                    image=cache_subpath.rsplit("/", 1)[-1]
-                )
-            return web.Response(status=HTTPStatus.NOT_FOUND)
-        return self._build_response(data)
-
-    async def _fetch_and_cache(
-        self,
-        cdn_path: str,
-        cache_path: Path,
-    ) -> bytes | None:
-        """Fetch from CDN and write to cache. Returns data or None on 404."""
-        url = f"{BRANDS_CDN_URL}/{cdn_path}"
-        session = async_get_clientsession(self._hass)
-        try:
-            resp = await session.get(url, timeout=CDN_TIMEOUT)
-        except ClientError, TimeoutError:
-            _LOGGER.debug("Failed to fetch brand from CDN: %s", cdn_path)
-            return None
-
-        if resp.status == HTTPStatus.NOT_FOUND:
-            # Cache the 404 as empty file
-            await self._hass.async_add_executor_job(_write_cache_file, cache_path, b"")
-            return None
-
-        if resp.status != HTTPStatus.OK:
-            _LOGGER.debug("Unexpected CDN response %s for %s", resp.status, cdn_path)
-            return None
-
-        data = await resp.read()
-        await self._hass.async_add_executor_job(_write_cache_file, cache_path, data)
-        return data
-
-    async def _serve_placeholder(self, image: str) -> web.Response:
-        """Serve a placeholder image."""
-        return await self._serve_from_cache_or_cdn(
-            cdn_path=f"_/{PLACEHOLDER}/{image}",
-            cache_subpath=f"integrations/{PLACEHOLDER}/{image}",
-            fallback_placeholder=False,
-        )
-
-    @staticmethod
-    def _build_response(data: bytes) -> web.Response:
-        """Build a response with proper headers."""
-        return web.Response(
-            body=data,
-            content_type="image/png",
-        )
-
-
-class BrandsIntegrationView(_BrandsBaseView):
-    """Serve integration brand images."""
-
-    name = "api:brands:integration"
-    url = "/api/brands/integration/{domain}/{image}"
-
-    async def get(
-        self,
-        request: web.Request,
-        domain: str,
-        image: str,
-    ) -> web.Response:
-        """Handle GET request for an integration brand image."""
-        self._authenticate(request)
-
-        if not valid_domain(domain) or image not in ALLOWED_IMAGES:
-            return web.Response(status=HTTPStatus.NOT_FOUND)
-
-        use_placeholder = request.query.get("placeholder") != "no"
-
-        # 1. Try custom integration local files
-        if (
-            response := await self._serve_from_custom_integration(domain, image)
-        ) is not None:
-            return response
-
-        # 2. Try cache / CDN (always use direct path for proper 404 caching)
-        return await self._serve_from_cache_or_cdn(
-            cdn_path=f"brands/{domain}/{image}",
-            cache_subpath=f"integrations/{domain}/{image}",
-            fallback_placeholder=use_placeholder,
-        )
-
-
-class BrandsHardwareView(_BrandsBaseView):
-    """Serve hardware brand images."""
-
-    name = "api:brands:hardware"
-    url = "/api/brands/hardware/{category}/{image:.+}"
-
-    async def get(
-        self,
-        request: web.Request,
-        category: str,
-        image: str,
-    ) -> web.Response:
-        """Handle GET request for a hardware brand image."""
-        self._authenticate(request)
-
-        if not CATEGORY_RE.match(category):
-            return web.Response(status=HTTPStatus.NOT_FOUND)
-        # Hardware images have dynamic names like "manufacturer_model.png"
-        # Validate it ends with .png and contains only safe characters
-        if not HARDWARE_IMAGE_RE.match(image):
-            return web.Response(status=HTTPStatus.NOT_FOUND)
-
-        cache_subpath = f"hardware/{category}/{image}"
-
-        return await self._serve_from_cache_or_cdn(
-            cdn_path=cache_subpath,
-            cache_subpath=cache_subpath,
-        )

homeassistant/components/brands/const.py

@@ -1,57 +0,0 @@
-"""Constants for the Brands integration."""
-
-from __future__ import annotations
-
-from datetime import timedelta
-import re
-from typing import Final
-
-from aiohttp import ClientTimeout
-
-DOMAIN: Final = "brands"
-
-# CDN
-BRANDS_CDN_URL: Final = "https://brands.home-assistant.io"
-CDN_TIMEOUT: Final = ClientTimeout(total=10)
-PLACEHOLDER: Final = "_placeholder"
-
-# Caching
-CACHE_TTL: Final = 30 * 24 * 60 * 60  # 30 days in seconds
-
-# Access token
-TOKEN_CHANGE_INTERVAL: Final = timedelta(minutes=30)
-
-# Validation
-CATEGORY_RE: Final = re.compile(r"^[a-z0-9_]+$")
-HARDWARE_IMAGE_RE: Final = re.compile(r"^[a-z0-9_-]+\.png$")
-
-# Images and fallback chains
-ALLOWED_IMAGES: Final = frozenset(
-    {
-        "icon.png",
-        "logo.png",
-        "icon@2x.png",
-        "logo@2x.png",
-        "dark_icon.png",
-        "dark_logo.png",
-        "dark_icon@2x.png",
-        "dark_logo@2x.png",
-    }
-)
-
-# Fallback chains for image resolution, mirroring the brands CDN build logic.
-# When a requested image is not found, we try each fallback in order.
-IMAGE_FALLBACKS: Final[dict[str, list[str]]] = {
-    "logo.png": ["icon.png"],
-    "icon@2x.png": ["icon.png"],
-    "logo@2x.png": ["logo.png", "icon.png"],
-    "dark_icon.png": ["icon.png"],
-    "dark_logo.png": ["dark_icon.png", "logo.png", "icon.png"],
-    "dark_icon@2x.png": ["icon@2x.png", "icon.png"],
-    "dark_logo@2x.png": [
-        "dark_icon@2x.png",
-        "logo@2x.png",
-        "logo.png",
-        "icon.png",
-    ],
-}

homeassistant/components/brands/manifest.json

@@ -1,10 +0,0 @@
-{
-  "domain": "brands",
-  "name": "Brands",
-  "codeowners": ["@home-assistant/core"],
-  "config_flow": false,
-  "dependencies": ["http", "websocket_api"],
-  "documentation": "https://www.home-assistant.io/integrations/brands",
-  "integration_type": "system",
-  "quality_scale": "internal"
-}

homeassistant/components/bsblan/manifest.json

@@ -8,7 +8,7 @@
   "iot_class": "local_polling",
   "loggers": ["bsblan"],
   "quality_scale": "silver",
-  "requirements": ["python-bsblan==5.1.0"],
+  "requirements": ["python-bsblan==5.0.1"],
   "zeroconf": [
     {
       "name": "bsb-lan*",

homeassistant/components/bsblan/sensor.py

@@ -64,8 +64,6 @@ SENSOR_TYPES: tuple[BSBLanSensorEntityDescription, ...] = (
         device_class=SensorDeviceClass.ENERGY,
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        suggested_display_precision=0,
-        entity_registry_enabled_default=False,
         value_fn=lambda data: (
             data.sensor.total_energy.value
             if data.sensor.total_energy is not None

homeassistant/components/cambridge_audio/media_browser.py

@@ -38,7 +38,7 @@ async def _root_payload(
                 media_class=MediaClass.DIRECTORY,
                 media_content_id="",
                 media_content_type="presets",
-                thumbnail="/api/brands/integration/cambridge_audio/logo.png",
+                thumbnail="https://brands.home-assistant.io/_/cambridge_audio/logo.png",
                 can_play=False,
                 can_expand=True,
             )

homeassistant/components/cast/media_player.py

@@ -804,24 +804,9 @@ class CastMediaPlayerEntity(CastDevice, MediaPlayerEntity):
     @property
     def state(self) -> MediaPlayerState | None:
         """Return the state of the player."""
-        if (chromecast := self._chromecast) is None or (
-            cast_status := self.cast_status
-        ) is None:
-            # Not connected to any chromecast, or not yet got any status
-            return None
-
-        if (
-            chromecast.cast_type == pychromecast.const.CAST_TYPE_CHROMECAST
-            and not chromecast.ignore_cec
-            and cast_status.is_active_input is False
-        ):
-            # The display interface for the device has been turned off or switched away
-            return MediaPlayerState.OFF
-
+        # The lovelace app loops media to prevent timing out, don't show that
         if self.app_id == CAST_APP_ID_HOMEASSISTANT_LOVELACE:
-            # The lovelace app loops media to prevent timing out, don't show that
             return MediaPlayerState.PLAYING
-
         if (media_status := self._media_status()[0]) is not None:
             if media_status.player_state == MEDIA_PLAYER_STATE_PLAYING:
                 return MediaPlayerState.PLAYING
@@ -832,16 +817,20 @@ class CastMediaPlayerEntity(CastDevice, MediaPlayerEntity):
             if media_status.player_is_idle:
                 return MediaPlayerState.IDLE
 
+        if self._chromecast is not None and self._chromecast.is_idle:
+            # If library consider us idle, that is our off state
+            # it takes HDMI status into account for cast devices.
+            return MediaPlayerState.OFF
+
         if self.app_id in APP_IDS_UNRELIABLE_MEDIA_INFO:
             # Some apps don't report media status, show the player as playing
             return MediaPlayerState.PLAYING
 
-        if self.app_id in (pychromecast.IDLE_APP_ID, None):
-            # We have no active app or the home screen app. This is
-            # same app as APP_BACKDROP.
-            return MediaPlayerState.OFF
+        if self.app_id is not None:
+            # We have an active app
+            return MediaPlayerState.IDLE
 
-        return MediaPlayerState.IDLE
+        return None
 
     @property
     def media_content_id(self) -> str | None:

homeassistant/components/compit/strings.json

@@ -324,8 +324,8 @@
           "nano_nr_3": "Nano 3",
           "nano_nr_4": "Nano 4",
           "nano_nr_5": "Nano 5",
-          "off": "[%key:common::state::off%]",
-          "on": "[%key:common::state::on%]",
+          "off": "Off",
+          "on": "On",
           "summer": "Summer",
           "winter": "Winter"
         }
@@ -363,8 +363,8 @@
       "pump_status": {
         "name": "Pump status",
         "state": {
-          "off": "[%key:common::state::off%]",
-          "on": "[%key:common::state::on%]"
+          "off": "Off",
+          "on": "On"
         }
       },
       "return_circuit_temperature": {

homeassistant/components/conversation/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/conversation",
   "integration_type": "entity",
   "quality_scale": "internal",
-  "requirements": ["hassil==3.5.0", "home-assistant-intents==2026.3.3"]
+  "requirements": ["hassil==3.5.0", "home-assistant-intents==2026.2.13"]
 }

homeassistant/components/daikin/climate.py

@@ -115,7 +115,7 @@ def _zone_temperature_lists(device: Appliance) -> tuple[list[str], list[str]]:
     try:
         heating = device.represent(DAIKIN_ZONE_TEMP_HEAT)[1]
         cooling = device.represent(DAIKIN_ZONE_TEMP_COOL)[1]
-    except AttributeError, KeyError:
+    except AttributeError:
         return ([], [])
     return (list(heating or []), list(cooling or []))
 

homeassistant/components/dsmr/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_push",
   "loggers": ["dsmr_parser"],
-  "requirements": ["dsmr-parser==1.5.0"]
+  "requirements": ["dsmr-parser==1.4.3"]
 }

homeassistant/components/dunehd/media_player.py

@@ -33,8 +33,6 @@ DUNEHD_PLAYER_SUPPORT: Final[MediaPlayerEntityFeature] = (
     | MediaPlayerEntityFeature.PLAY
     | MediaPlayerEntityFeature.PLAY_MEDIA
     | MediaPlayerEntityFeature.BROWSE_MEDIA
-    | MediaPlayerEntityFeature.VOLUME_STEP
-    | MediaPlayerEntityFeature.VOLUME_MUTE
 )
 
 

homeassistant/components/dwd_weather_warnings/sensor.py

@@ -11,7 +11,6 @@ Wetterwarnungen (Stufe 1)
 
 from __future__ import annotations
 
-from datetime import UTC, datetime
 from typing import Any
 
 from homeassistant.components.sensor import SensorEntity, SensorEntityDescription
@@ -96,25 +95,13 @@ class DwdWeatherWarningsSensor(
             entry_type=DeviceEntryType.SERVICE,
         )
 
-    def _filter_expired_warnings(
-        self, warnings: list[dict[str, Any]] | None
-    ) -> list[dict[str, Any]]:
-        if warnings is None:
-            return []
-
-        now = datetime.now(UTC)
-        return [warning for warning in warnings if warning[API_ATTR_WARNING_END] > now]
-
     @property
     def native_value(self) -> int | None:
         """Return the state of the sensor."""
         if self.entity_description.key == CURRENT_WARNING_SENSOR:
-            warnings = self.coordinator.api.current_warnings
-        else:
-            warnings = self.coordinator.api.expected_warnings
+            return self.coordinator.api.current_warning_level
 
-        warnings = self._filter_expired_warnings(warnings)
-        return max((w.get(API_ATTR_WARNING_LEVEL, 0) for w in warnings), default=0)
+        return self.coordinator.api.expected_warning_level
 
     @property
     def extra_state_attributes(self) -> dict[str, Any]:
@@ -130,7 +117,6 @@ class DwdWeatherWarningsSensor(
         else:
             searched_warnings = self.coordinator.api.expected_warnings
 
-        searched_warnings = self._filter_expired_warnings(searched_warnings)
         data[ATTR_WARNING_COUNT] = len(searched_warnings)
 
         for i, warning in enumerate(searched_warnings, 1):

homeassistant/components/esphome/assist_satellite.py

@@ -524,10 +524,14 @@ class EsphomeAssistSatellite(
         self._active_pipeline_index = 0
 
         maybe_pipeline_index = 0
-        while ww_entity_id := self.get_wake_word_entity(maybe_pipeline_index):
-            if (
-                ww_state := self.hass.states.get(ww_entity_id)
-            ) and ww_state.state == wake_word_phrase:
+        while True:
+            if not (ww_entity_id := self.get_wake_word_entity(maybe_pipeline_index)):
+                break
+
+            if not (ww_state := self.hass.states.get(ww_entity_id)):
+                continue
+
+            if ww_state.state == wake_word_phrase:
                 # First match
                 self._active_pipeline_index = maybe_pipeline_index
                 break

homeassistant/components/fibaro/__init__.py

@@ -275,11 +275,8 @@ class FibaroController:
                 # otherwise add the first visible device in the group
                 # which is a hack, but solves a problem with FGT having
                 # hidden compatibility devices before the real device
-                # Second hack is for quickapps which have parent id 0 and no children
-                if (
-                    last_climate_parent != device.parent_fibaro_id
-                    or (device.has_endpoint_id and last_endpoint != device.endpoint_id)
-                    or device.parent_fibaro_id == 0
+                if last_climate_parent != device.parent_fibaro_id or (
+                    device.has_endpoint_id and last_endpoint != device.endpoint_id
                 ):
                     _LOGGER.debug("Handle separately")
                     self.fibaro_devices[platform].append(device)

homeassistant/components/forked_daapd/browse_media.py

@@ -304,7 +304,7 @@ def base_owntone_library() -> BrowseMedia:
         can_play=False,
         can_expand=True,
         children=children,
-        thumbnail="/api/brands/integration/forked_daapd/logo.png",
+        thumbnail="https://brands.home-assistant.io/_/forked_daapd/logo.png",
     )
 
 
@@ -321,7 +321,7 @@ def library(other: Sequence[BrowseMedia] | None) -> BrowseMedia:
             media_content_type=MediaType.APP,
             can_play=False,
             can_expand=True,
-            thumbnail="/api/brands/integration/forked_daapd/logo.png",
+            thumbnail="https://brands.home-assistant.io/_/forked_daapd/logo.png",
         )
     ]
     if other:

homeassistant/components/frontend/__init__.py

@@ -297,9 +297,6 @@ class Panel:
     # If the panel should only be visible to admins
     require_admin = False
 
-    # If the panel should be shown in the sidebar
-    show_in_sidebar = True
-
     # If the panel is a configuration panel for a integration
     config_panel_domain: str | None = None
 
@@ -313,7 +310,6 @@ class Panel:
         config: dict[str, Any] | None,
         require_admin: bool,
         config_panel_domain: str | None,
-        show_in_sidebar: bool,
     ) -> None:
         """Initialize a built-in panel."""
         self.component_name = component_name
@@ -323,7 +319,6 @@ class Panel:
         self.config = config
         self.require_admin = require_admin
         self.config_panel_domain = config_panel_domain
-        self.show_in_sidebar = show_in_sidebar
         self.sidebar_default_visible = sidebar_default_visible
 
     @callback
@@ -340,17 +335,18 @@ class Panel:
             "url_path": self.frontend_url_path,
             "require_admin": self.require_admin,
             "config_panel_domain": self.config_panel_domain,
-            "show_in_sidebar": self.show_in_sidebar,
         }
         if config_override:
             if "require_admin" in config_override:
                 response["require_admin"] = config_override["require_admin"]
-            if "show_in_sidebar" in config_override:
-                response["show_in_sidebar"] = config_override["show_in_sidebar"]
-            if "icon" in config_override:
-                response["icon"] = config_override["icon"]
-            if "title" in config_override:
-                response["title"] = config_override["title"]
+            if config_override.get("show_in_sidebar") is False:
+                response["title"] = None
+                response["icon"] = None
+            else:
+                if "icon" in config_override:
+                    response["icon"] = config_override["icon"]
+                if "title" in config_override:
+                    response["title"] = config_override["title"]
         return response
 
 
@@ -368,7 +364,6 @@ def async_register_built_in_panel(
     *,
     update: bool = False,
     config_panel_domain: str | None = None,
-    show_in_sidebar: bool = True,
 ) -> None:
     """Register a built-in panel."""
     panel = Panel(
@@ -380,7 +375,6 @@ def async_register_built_in_panel(
         config,
         require_admin,
         config_panel_domain,
-        show_in_sidebar,
     )
 
     panels = hass.data.setdefault(DATA_PANELS, {})
@@ -576,28 +570,28 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
         "light",
         sidebar_icon="mdi:lamps",
         sidebar_title="light",
-        show_in_sidebar=False,
+        sidebar_default_visible=False,
     )
     async_register_built_in_panel(
         hass,
         "security",
         sidebar_icon="mdi:security",
         sidebar_title="security",
-        show_in_sidebar=False,
+        sidebar_default_visible=False,
     )
     async_register_built_in_panel(
         hass,
         "climate",
         sidebar_icon="mdi:home-thermometer",
         sidebar_title="climate",
-        show_in_sidebar=False,
+        sidebar_default_visible=False,
     )
     async_register_built_in_panel(
         hass,
         "home",
         sidebar_icon="mdi:home",
         sidebar_title="home",
-        show_in_sidebar=False,
+        sidebar_default_visible=False,
     )
 
     async_register_built_in_panel(hass, "profile")
@@ -1091,4 +1085,3 @@ class PanelResponse(TypedDict):
     url_path: str
     require_admin: bool
     config_panel_domain: str | None
-    show_in_sidebar: bool

homeassistant/components/frontend/manifest.json

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

homeassistant/components/fully_kiosk/config_flow.py

@@ -19,8 +19,6 @@ from homeassistant.const import (
     CONF_SSL,
     CONF_VERIFY_SSL,
 )
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.device_registry import format_mac
 from homeassistant.helpers.service_info.dhcp import DhcpServiceInfo
@@ -29,34 +27,6 @@ from homeassistant.helpers.service_info.mqtt import MqttServiceInfo
 from .const import DEFAULT_PORT, DOMAIN, LOGGER
 
 
-async def _validate_input(hass: HomeAssistant, data: dict[str, Any]) -> Any:
-    """Validate the user input allows us to connect."""
-    fully = FullyKiosk(
-        async_get_clientsession(hass),
-        data[CONF_HOST],
-        DEFAULT_PORT,
-        data[CONF_PASSWORD],
-        use_ssl=data[CONF_SSL],
-        verify_ssl=data[CONF_VERIFY_SSL],
-    )
-
-    try:
-        async with asyncio.timeout(15):
-            device_info = await fully.getDeviceInfo()
-    except (
-        ClientConnectorError,
-        FullyKioskError,
-        TimeoutError,
-    ) as error:
-        LOGGER.debug(error.args, exc_info=True)
-        raise CannotConnect from error
-    except Exception as error:  # pylint: disable=broad-except
-        LOGGER.exception("Unexpected exception")
-        raise UnknownError from error
-
-    return device_info
-
-
 class FullyKioskConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Fully Kiosk Browser."""
 
@@ -73,42 +43,58 @@ class FullyKioskConfigFlow(ConfigFlow, domain=DOMAIN):
         host: str,
         user_input: dict[str, Any],
         errors: dict[str, str],
+        description_placeholders: dict[str, str] | Any = None,
     ) -> ConfigFlowResult | None:
-        """Create a config entry."""
-        self._async_abort_entries_match({CONF_HOST: host})
+        fully = FullyKiosk(
+            async_get_clientsession(self.hass),
+            host,
+            DEFAULT_PORT,
+            user_input[CONF_PASSWORD],
+            use_ssl=user_input[CONF_SSL],
+            verify_ssl=user_input[CONF_VERIFY_SSL],
+        )
+
         try:
-            device_info = await _validate_input(
-                self.hass, {**user_input, CONF_HOST: host}
-            )
-        except CannotConnect:
+            async with asyncio.timeout(15):
+                device_info = await fully.getDeviceInfo()
+        except (
+            ClientConnectorError,
+            FullyKioskError,
+            TimeoutError,
+        ) as error:
+            LOGGER.debug(error.args, exc_info=True)
             errors["base"] = "cannot_connect"
+            description_placeholders["error_detail"] = str(error.args)
             return None
-        except UnknownError:
+        except Exception as error:  # noqa: BLE001
+            LOGGER.exception("Unexpected exception: %s", error)
             errors["base"] = "unknown"
+            description_placeholders["error_detail"] = str(error.args)
             return None
-        else:
-            await self.async_set_unique_id(
-                device_info["deviceID"], raise_on_progress=False
-            )
-            self._abort_if_unique_id_configured(updates=user_input)
-            return self.async_create_entry(
-                title=device_info["deviceName"],
-                data={
-                    CONF_HOST: host,
-                    CONF_PASSWORD: user_input[CONF_PASSWORD],
-                    CONF_MAC: format_mac(device_info["Mac"]),
-                    CONF_SSL: user_input[CONF_SSL],
-                    CONF_VERIFY_SSL: user_input[CONF_VERIFY_SSL],
-                },
-            )
+
+        await self.async_set_unique_id(device_info["deviceID"], raise_on_progress=False)
+        self._abort_if_unique_id_configured(updates=user_input)
+        return self.async_create_entry(
+            title=device_info["deviceName"],
+            data={
+                CONF_HOST: host,
+                CONF_PASSWORD: user_input[CONF_PASSWORD],
+                CONF_MAC: format_mac(device_info["Mac"]),
+                CONF_SSL: user_input[CONF_SSL],
+                CONF_VERIFY_SSL: user_input[CONF_VERIFY_SSL],
+            },
+        )
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle the initial step."""
         errors: dict[str, str] = {}
+        placeholders: dict[str, str] = {}
         if user_input is not None:
-            result = await self._create_entry(user_input[CONF_HOST], user_input, errors)
+            result = await self._create_entry(
+                user_input[CONF_HOST], user_input, errors, placeholders
+            )
             if result:
                 return result
 
@@ -122,6 +108,7 @@ class FullyKioskConfigFlow(ConfigFlow, domain=DOMAIN):
                     vol.Optional(CONF_VERIFY_SSL, default=False): bool,
                 }
             ),
+            description_placeholders=placeholders,
             errors=errors,
         )
 
@@ -184,66 +171,3 @@ class FullyKioskConfigFlow(ConfigFlow, domain=DOMAIN):
         self.host = device_info["hostname4"]
         self._discovered_device_info = device_info
         return await self.async_step_discovery_confirm()
-
-    async def async_step_reconfigure(
-        self, user_input: dict[str, Any]
-    ) -> ConfigFlowResult:
-        """Handle reconfiguration of an existing config entry."""
-        errors: dict[str, str] = {}
-        reconf_entry = self._get_reconfigure_entry()
-        suggested_values = {
-            CONF_HOST: reconf_entry.data[CONF_HOST],
-            CONF_PASSWORD: reconf_entry.data[CONF_PASSWORD],
-            CONF_SSL: reconf_entry.data[CONF_SSL],
-            CONF_VERIFY_SSL: reconf_entry.data[CONF_VERIFY_SSL],
-        }
-
-        if user_input:
-            try:
-                device_info = await _validate_input(
-                    self.hass,
-                    data={
-                        **reconf_entry.data,
-                        **user_input,
-                    },
-                )
-            except CannotConnect:
-                errors["base"] = "cannot_connect"
-            except UnknownError:
-                errors["base"] = "unknown"
-            else:
-                await self.async_set_unique_id(
-                    device_info["deviceID"], raise_on_progress=False
-                )
-                self._abort_if_unique_id_mismatch()
-                return self.async_update_reload_and_abort(
-                    reconf_entry,
-                    data_updates={
-                        **reconf_entry.data,
-                        **user_input,
-                    },
-                )
-
-        return self.async_show_form(
-            step_id="reconfigure",
-            data_schema=self.add_suggested_values_to_schema(
-                data_schema=vol.Schema(
-                    {
-                        vol.Required(CONF_HOST): str,
-                        vol.Required(CONF_PASSWORD): str,
-                        vol.Optional(CONF_SSL, default=False): bool,
-                        vol.Optional(CONF_VERIFY_SSL, default=False): bool,
-                    }
-                ),
-                suggested_values=user_input or suggested_values,
-            ),
-            errors=errors,
-        )
-
-
-class CannotConnect(HomeAssistantError):
-    """Error to indicate we cannot connect to the Fully Kiosk device."""
-
-
-class UnknownError(HomeAssistantError):
-    """Error to indicate an unknown error occurred."""

homeassistant/components/fully_kiosk/strings.json

@@ -6,13 +6,11 @@
   },
   "config": {
     "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
-      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
-      "unique_id_mismatch": "Please ensure you reconfigure the same device."
+      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]"
     },
     "error": {
-      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "unknown": "[%key:common::config_flow::error::unknown%]"
+      "cannot_connect": "Cannot connect. Details: {error_detail}",
+      "unknown": "Unknown. Details: {error_detail}"
     },
     "step": {
       "discovery_confirm": {
@@ -28,20 +26,6 @@
         },
         "description": "Do you want to set up {name} ({host})?"
       },
-      "reconfigure": {
-        "data": {
-          "host": "[%key:common::config_flow::data::host%]",
-          "password": "[%key:common::config_flow::data::password%]",
-          "ssl": "[%key:common::config_flow::data::ssl%]",
-          "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
-        },
-        "data_description": {
-          "host": "The hostname or IP address of the device running your Fully Kiosk Browser application.",
-          "password": "[%key:component::fully_kiosk::common::data_description_password%]",
-          "ssl": "[%key:component::fully_kiosk::common::data_description_ssl%]",
-          "verify_ssl": "[%key:component::fully_kiosk::common::data_description_verify_ssl%]"
-        }
-      },
       "user": {
         "data": {
           "host": "[%key:common::config_flow::data::host%]",

homeassistant/components/github/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "loggers": ["aiogithubapi"],
-  "requirements": ["aiogithubapi==26.0.0"]
+  "requirements": ["aiogithubapi==24.6.0"]
 }

homeassistant/components/hassio/http.py

@@ -266,8 +266,6 @@ def should_compress(content_type: str, path: str | None = None) -> bool:
     """Return if we should compress a response."""
     if path is not None and NO_COMPRESS.match(path):
         return False
-    if content_type.startswith("text/event-stream"):
-        return False
     if content_type.startswith("image/"):
         return "svg" in content_type
     if content_type.startswith("application/"):

homeassistant/components/hassio/update.py

@@ -207,7 +207,7 @@ class SupervisorOSUpdateEntity(HassioOSEntity, UpdateEntity):
     @property
     def entity_picture(self) -> str | None:
         """Return the icon of the entity."""
-        return "/api/brands/integration/homeassistant/icon.png?placeholder=no"
+        return "https://brands.home-assistant.io/homeassistant/icon.png"
 
     @property
     def release_url(self) -> str | None:
@@ -258,7 +258,7 @@ class SupervisorSupervisorUpdateEntity(HassioSupervisorEntity, UpdateEntity):
     @property
     def entity_picture(self) -> str | None:
         """Return the icon of the entity."""
-        return "/api/brands/integration/hassio/icon.png?placeholder=no"
+        return "https://brands.home-assistant.io/hassio/icon.png"
 
     async def async_install(
         self, version: str | None, backup: bool, **kwargs: Any
@@ -296,7 +296,7 @@ class SupervisorCoreUpdateEntity(HassioCoreEntity, UpdateEntity):
     @property
     def entity_picture(self) -> str | None:
         """Return the icon of the entity."""
-        return "/api/brands/integration/homeassistant/icon.png?placeholder=no"
+        return "https://brands.home-assistant.io/homeassistant/icon.png"
 
     @property
     def release_url(self) -> str | None:

homeassistant/components/hdfury/manifest.json

@@ -7,7 +7,7 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "quality_scale": "platinum",
-  "requirements": ["hdfury==1.6.0"],
+  "requirements": ["hdfury==1.5.0"],
   "zeroconf": [
     { "name": "diva-*", "type": "_http._tcp.local." },
     { "name": "vertex2-*", "type": "_http._tcp.local." },

homeassistant/components/hive/manifest.json

@@ -10,5 +10,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "loggers": ["apyhiveapi"],
-  "requirements": ["pyhive-integration==1.0.8"]
+  "requirements": ["pyhive-integration==1.0.7"]
 }

homeassistant/components/homematicip_cloud/climate.py

@@ -88,17 +88,6 @@ class HomematicipHeatingGroup(HomematicipGenericEntity, ClimateEntity):
         if device.actualTemperature is None:
             self._simple_heating = self._first_radiator_thermostat
 
-    @property
-    def available(self) -> bool:
-        """Heating group available.
-
-        A heating group must be available, and should not be affected by the
-        individual availability of group members.
-        This allows controlling the temperature even when individual group
-        members are not available.
-        """
-        return True
-
     @property
     def device_info(self) -> DeviceInfo:
         """Return device specific attributes."""

homeassistant/components/homematicip_cloud/const.py

@@ -18,7 +18,6 @@ PLATFORMS = [
     Platform.LIGHT,
     Platform.LOCK,
     Platform.SENSOR,
-    Platform.SIREN,
     Platform.SWITCH,
     Platform.VALVE,
     Platform.WEATHER,

homeassistant/components/homematicip_cloud/cover.py

@@ -312,17 +312,6 @@ class HomematicipCoverShutterGroup(HomematicipGenericEntity, CoverEntity):
         device.modelType = f"HmIP-{post}"
         super().__init__(hap, device, post, is_multi_channel=False)
 
-    @property
-    def available(self) -> bool:
-        """Cover shutter group available.
-
-        A cover shutter group must be available, and should not be affected by
-        the individual availability of group members.
-        This allows controlling the shutters even when individual group
-        members are not available.
-        """
-        return True
-
     @property
     def current_cover_position(self) -> int | None:
         """Return current position of cover."""

homeassistant/components/homematicip_cloud/siren.py

@@ -1,86 +0,0 @@
-"""Support for HomematicIP Cloud sirens."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-from homematicip.base.functionalChannels import NotificationMp3SoundChannel
-from homematicip.device import CombinationSignallingDevice
-
-from homeassistant.components.siren import (
-    ATTR_TONE,
-    ATTR_VOLUME_LEVEL,
-    SirenEntity,
-    SirenEntityFeature,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .entity import HomematicipGenericEntity
-from .hap import HomematicIPConfigEntry, HomematicipHAP
-
-_logger = logging.getLogger(__name__)
-
-# Map tone integers to HmIP sound file strings
-_TONE_TO_SOUNDFILE: dict[int, str] = {0: "INTERNAL_SOUNDFILE"}
-_TONE_TO_SOUNDFILE.update({i: f"SOUNDFILE_{i:03d}" for i in range(1, 253)})
-
-# Available tones as dict[int, str] for HA UI
-AVAILABLE_TONES: dict[int, str] = {0: "Internal"}
-AVAILABLE_TONES.update({i: f"Sound {i}" for i in range(1, 253)})
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: HomematicIPConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the HomematicIP Cloud sirens from a config entry."""
-    hap = config_entry.runtime_data
-    async_add_entities(
-        HomematicipMP3Siren(hap, device)
-        for device in hap.home.devices
-        if isinstance(device, CombinationSignallingDevice)
-    )
-
-
-class HomematicipMP3Siren(HomematicipGenericEntity, SirenEntity):
-    """Representation of the HomematicIP MP3 siren (HmIP-MP3P)."""
-
-    _attr_available_tones = AVAILABLE_TONES
-    _attr_supported_features = (
-        SirenEntityFeature.TURN_ON
-        | SirenEntityFeature.TURN_OFF
-        | SirenEntityFeature.TONES
-        | SirenEntityFeature.VOLUME_SET
-    )
-
-    def __init__(
-        self, hap: HomematicipHAP, device: CombinationSignallingDevice
-    ) -> None:
-        """Initialize the siren entity."""
-        super().__init__(hap, device, post="Siren", channel=1, is_multi_channel=False)
-
-    @property
-    def _func_channel(self) -> NotificationMp3SoundChannel:
-        return self._device.functionalChannels[self._channel]
-
-    @property
-    def is_on(self) -> bool:
-        """Return true if siren is playing."""
-        return self._func_channel.playingFileActive
-
-    async def async_turn_on(self, **kwargs: Any) -> None:
-        """Turn the siren on."""
-        tone = kwargs.get(ATTR_TONE, 0)
-        volume_level = kwargs.get(ATTR_VOLUME_LEVEL, 1.0)
-
-        sound_file = _TONE_TO_SOUNDFILE.get(tone, "INTERNAL_SOUNDFILE")
-        await self._func_channel.set_sound_file_volume_level_async(
-            sound_file=sound_file, volume_level=volume_level
-        )
-
-    async def async_turn_off(self, **kwargs: Any) -> None:
-        """Turn the siren off."""
-        await self._func_channel.stop_sound_async()

homeassistant/components/homevolt/manifest.json

@@ -1,7 +1,7 @@
 {
   "domain": "homevolt",
   "name": "Homevolt",
-  "codeowners": ["@danielhiversen", "@liudger"],
+  "codeowners": ["@danielhiversen"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/homevolt",
   "integration_type": "device",

homeassistant/components/indevolt/strings.json

@@ -57,8 +57,8 @@
       "battery_charge_discharge_state": {
         "name": "Battery charge/discharge state",
         "state": {
-          "charging": "[%key:common::state::charging%]",
-          "discharging": "[%key:common::state::discharging%]",
+          "charging": "Charging",
+          "discharging": "Discharging",
           "static": "Static"
         }
       },

homeassistant/components/influxdb/__init__.py

@@ -43,7 +43,6 @@ from homeassistant.const import (
     STATE_UNKNOWN,
 )
 from homeassistant.core import Event, HomeAssistant, State, callback
-from homeassistant.data_entry_flow import FlowResultType
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv, state as state_helper
 from homeassistant.helpers.entity_values import EntityValues
@@ -62,7 +61,6 @@ from .const import (
     CLIENT_ERROR_V2,
     CODE_INVALID_INPUTS,
     COMPONENT_CONFIG_SCHEMA_CONNECTION,
-    COMPONENT_CONFIG_SCHEMA_CONNECTION_VALIDATORS,
     CONF_API_VERSION,
     CONF_BUCKET,
     CONF_COMPONENT_CONFIG,
@@ -81,6 +79,7 @@ from .const import (
     CONF_TAGS_ATTRIBUTES,
     CONNECTION_ERROR,
     DEFAULT_API_VERSION,
+    DEFAULT_HOST,
     DEFAULT_HOST_V2,
     DEFAULT_MEASUREMENT_ATTR,
     DEFAULT_SSL_V2,
@@ -105,7 +104,6 @@ from .const import (
     WRITE_ERROR,
     WROTE_MESSAGE,
 )
-from .issue import async_create_deprecated_yaml_issue
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -139,7 +137,7 @@ def create_influx_url(conf: dict) -> dict:
 
 def validate_version_specific_config(conf: dict) -> dict:
     """Ensure correct config fields are provided based on API version used."""
-    if conf.get(CONF_API_VERSION, DEFAULT_API_VERSION) == API_VERSION_2:
+    if conf[CONF_API_VERSION] == API_VERSION_2:
         if CONF_TOKEN not in conf:
             raise vol.Invalid(
                 f"{CONF_TOKEN} and {CONF_BUCKET} are required when"
@@ -195,13 +193,32 @@ _INFLUX_BASE_SCHEMA = INCLUDE_EXCLUDE_BASE_FILTER_SCHEMA.extend(
     }
 )
 
-INFLUX_SCHEMA = _INFLUX_BASE_SCHEMA.extend(
-    COMPONENT_CONFIG_SCHEMA_CONNECTION_VALIDATORS
+INFLUX_SCHEMA = vol.All(
+    _INFLUX_BASE_SCHEMA.extend(COMPONENT_CONFIG_SCHEMA_CONNECTION),
+    validate_version_specific_config,
+    create_influx_url,
 )
 
 
 CONFIG_SCHEMA = vol.Schema(
-    {DOMAIN: vol.All(INFLUX_SCHEMA, validate_version_specific_config)},
+    {
+        DOMAIN: vol.All(
+            cv.deprecated(CONF_API_VERSION),
+            cv.deprecated(CONF_HOST),
+            cv.deprecated(CONF_PATH),
+            cv.deprecated(CONF_PORT),
+            cv.deprecated(CONF_SSL),
+            cv.deprecated(CONF_VERIFY_SSL),
+            cv.deprecated(CONF_SSL_CA_CERT),
+            cv.deprecated(CONF_USERNAME),
+            cv.deprecated(CONF_PASSWORD),
+            cv.deprecated(CONF_DB_NAME),
+            cv.deprecated(CONF_TOKEN),
+            cv.deprecated(CONF_ORG),
+            cv.deprecated(CONF_BUCKET),
+            INFLUX_SCHEMA,
+        )
+    },
     extra=vol.ALLOW_EXTRA,
 )
 
@@ -482,35 +499,23 @@ def get_influx_connection(  # noqa: C901
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the InfluxDB component."""
-    if DOMAIN not in config:
-        return True
+    conf = config.get(DOMAIN)
 
-    hass.async_create_task(_async_setup(hass, config[DOMAIN]))
+    if conf is not None:
+        if CONF_HOST not in conf and conf[CONF_API_VERSION] == DEFAULT_API_VERSION:
+            conf[CONF_HOST] = DEFAULT_HOST
+
+        hass.async_create_task(
+            hass.config_entries.flow.async_init(
+                DOMAIN,
+                context={"source": SOURCE_IMPORT},
+                data=conf,
+            )
+        )
 
     return True
 
 
-async def _async_setup(hass: HomeAssistant, config: dict[str, Any]) -> None:
-    """Import YAML configuration into a config entry."""
-    result = await hass.config_entries.flow.async_init(
-        DOMAIN,
-        context={"source": SOURCE_IMPORT},
-        data=config,
-    )
-    if (
-        result.get("type") is FlowResultType.ABORT
-        and (reason := result["reason"]) != "single_instance_allowed"
-    ):
-        async_create_deprecated_yaml_issue(hass, error=reason)
-        return
-
-    # If we are here, the entry already exists (single instance allowed)
-    if config.keys() & (
-        {k.schema for k in COMPONENT_CONFIG_SCHEMA_CONNECTION} - {CONF_PRECISION}
-    ):
-        async_create_deprecated_yaml_issue(hass)
-
-
 async def async_setup_entry(hass: HomeAssistant, entry: InfluxDBConfigEntry) -> bool:
     """Set up InfluxDB from a config entry."""
     data = entry.data

homeassistant/components/influxdb/config_flow.py

@@ -31,7 +31,7 @@ from homeassistant.helpers.selector import (
 )
 from homeassistant.helpers.storage import STORAGE_DIR
 
-from . import DOMAIN, create_influx_url, get_influx_connection
+from . import DOMAIN, get_influx_connection
 from .const import (
     API_VERSION_2,
     CONF_API_VERSION,
@@ -40,11 +40,8 @@ from .const import (
     CONF_ORG,
     CONF_SSL_CA_CERT,
     DEFAULT_API_VERSION,
-    DEFAULT_BUCKET,
-    DEFAULT_DATABASE,
     DEFAULT_HOST,
     DEFAULT_PORT,
-    DEFAULT_VERIFY_SSL,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -243,17 +240,14 @@ class InfluxDBConfigFlow(ConfigFlow, domain=DOMAIN):
 
     async def async_step_import(self, import_data: dict[str, Any]) -> ConfigFlowResult:
         """Handle the initial step."""
-        import_data = {**import_data}
-        import_data.setdefault(CONF_API_VERSION, DEFAULT_API_VERSION)
-        import_data.setdefault(CONF_VERIFY_SSL, DEFAULT_VERIFY_SSL)
-        import_data.setdefault(CONF_DB_NAME, DEFAULT_DATABASE)
-        import_data.setdefault(CONF_BUCKET, DEFAULT_BUCKET)
+        host = import_data.get(CONF_HOST)
+        database = import_data.get(CONF_DB_NAME)
+        bucket = import_data.get(CONF_BUCKET)
 
-        api_version = import_data[CONF_API_VERSION]
+        api_version = import_data.get(CONF_API_VERSION)
+        ssl = import_data.get(CONF_SSL)
 
         if api_version == DEFAULT_API_VERSION:
-            host = import_data.get(CONF_HOST, DEFAULT_HOST)
-            database = import_data[CONF_DB_NAME]
             title = f"{database} ({host})"
             data = {
                 CONF_API_VERSION: api_version,
@@ -262,23 +256,21 @@ class InfluxDBConfigFlow(ConfigFlow, domain=DOMAIN):
                 CONF_USERNAME: import_data.get(CONF_USERNAME),
                 CONF_PASSWORD: import_data.get(CONF_PASSWORD),
                 CONF_DB_NAME: database,
-                CONF_SSL: import_data.get(CONF_SSL),
+                CONF_SSL: ssl,
                 CONF_PATH: import_data.get(CONF_PATH),
-                CONF_VERIFY_SSL: import_data[CONF_VERIFY_SSL],
+                CONF_VERIFY_SSL: import_data.get(CONF_VERIFY_SSL),
                 CONF_SSL_CA_CERT: import_data.get(CONF_SSL_CA_CERT),
             }
         else:
-            create_influx_url(import_data)  # Only modifies dict for api_version == 2
-            bucket = import_data[CONF_BUCKET]
             url = import_data.get(CONF_URL)
             title = f"{bucket} ({url})"
             data = {
                 CONF_API_VERSION: api_version,
-                CONF_URL: url,
+                CONF_URL: import_data.get(CONF_URL),
                 CONF_TOKEN: import_data.get(CONF_TOKEN),
                 CONF_ORG: import_data.get(CONF_ORG),
                 CONF_BUCKET: bucket,
-                CONF_VERIFY_SSL: import_data[CONF_VERIFY_SSL],
+                CONF_VERIFY_SSL: import_data.get(CONF_VERIFY_SSL),
                 CONF_SSL_CA_CERT: import_data.get(CONF_SSL_CA_CERT),
             }
 

homeassistant/components/influxdb/const.py

@@ -154,14 +154,3 @@ COMPONENT_CONFIG_SCHEMA_CONNECTION = {
     vol.Inclusive(CONF_ORG, "v2_authentication"): cv.string,
     vol.Optional(CONF_BUCKET, default=DEFAULT_BUCKET): cv.string,
 }
-
-# Same keys without defaults, used in CONFIG_SCHEMA to validate
-# without injecting default values (so we can detect explicit keys).
-COMPONENT_CONFIG_SCHEMA_CONNECTION_VALIDATORS = {
-    (
-        vol.Optional(k.schema)
-        if isinstance(k, vol.Optional) and k.default is not vol.UNDEFINED
-        else k
-    ): v
-    for k, v in COMPONENT_CONFIG_SCHEMA_CONNECTION.items()
-}

homeassistant/components/influxdb/issue.py

@@ -1,34 +0,0 @@
-"""Issues for InfluxDB integration."""
-
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue
-
-from .const import DOMAIN
-
-
-@callback
-def async_create_deprecated_yaml_issue(
-    hass: HomeAssistant, *, error: str | None = None
-) -> None:
-    """Create a repair issue for deprecated YAML connection configuration."""
-    if error is None:
-        issue_id = "deprecated_yaml"
-        severity = IssueSeverity.WARNING
-    else:
-        issue_id = f"deprecated_yaml_import_issue_{error}"
-        severity = IssueSeverity.ERROR
-
-    async_create_issue(
-        hass,
-        DOMAIN,
-        issue_id,
-        is_fixable=False,
-        issue_domain=DOMAIN,
-        breaks_in_ha_version="2026.9.0",
-        severity=severity,
-        translation_key=issue_id,
-        translation_placeholders={
-            "domain": DOMAIN,
-            "url": f"/config/integrations/dashboard/add?domain={DOMAIN}",
-        },
-    )

homeassistant/components/influxdb/manifest.json

@@ -7,6 +7,7 @@
   "documentation": "https://www.home-assistant.io/integrations/influxdb",
   "iot_class": "local_push",
   "loggers": ["influxdb", "influxdb_client"],
+  "quality_scale": "legacy",
   "requirements": ["influxdb==5.3.1", "influxdb-client==1.50.0"],
   "single_config_entry": true
 }

homeassistant/components/influxdb/strings.json

@@ -54,31 +54,5 @@
         "title": "Choose InfluxDB version"
       }
     }
-  },
-  "issues": {
-    "deprecated_yaml": {
-      "description": "Configuring InfluxDB connection settings using YAML is being removed. Your existing YAML connection configuration has been imported into the UI automatically.\n\nRemove the `{domain}` connection and authentication keys from your `configuration.yaml` file and restart Home Assistant to fix this issue. Other options like `include`, `exclude`, and `tags` remain in YAML for now. \n\nThe following keys should be removed:\n- `api_version`\n- `host`\n- `port`\n- `ssl`\n- `verify_ssl`\n- `ssl_ca_cert`\n- `username`\n- `password`\n- `database`\n- `token`\n- `organization`\n- `bucket`\n- `path`",
-      "title": "The InfluxDB YAML configuration is being removed"
-    },
-    "deprecated_yaml_import_issue_cannot_connect": {
-      "description": "Configuring InfluxDB connection settings using YAML is being removed but the import failed because Home Assistant could not connect to the InfluxDB server.\n\nPlease correct your YAML configuration and restart Home Assistant.\n\nAlternatively you can remove the `{domain}` connection and authentication keys from your `configuration.yaml` file and continue to [set up the integration]({url}) manually. \n\nThe following keys should be removed:\n- `api_version`\n- `host`\n- `port`\n- `ssl`\n- `verify_ssl`\n- `ssl_ca_cert`\n- `username`\n- `password`\n- `database`\n- `token`\n- `organization`\n- `bucket`\n- `path`",
-      "title": "Failed to import InfluxDB YAML configuration"
-    },
-    "deprecated_yaml_import_issue_invalid_auth": {
-      "description": "Configuring InfluxDB connection settings using YAML is being removed but the import failed because the provided credentials are invalid.\n\nPlease correct your YAML configuration and restart Home Assistant.\n\nAlternatively you can remove the `{domain}` connection and authentication keys from your `configuration.yaml` file and continue to [set up the integration]({url}) manually. \n\nThe following keys should be removed:\n- `api_version`\n- `host`\n- `port`\n- `ssl`\n- `verify_ssl`\n- `ssl_ca_cert`\n- `username`\n- `password`\n- `database`\n- `token`\n- `organization`\n- `bucket`\n- `path`",
-      "title": "[%key:component::influxdb::issues::deprecated_yaml_import_issue_cannot_connect::title%]"
-    },
-    "deprecated_yaml_import_issue_invalid_database": {
-      "description": "Configuring InfluxDB connection settings using YAML is being removed but the import failed because the specified database was not found.\n\nPlease correct your YAML configuration and restart Home Assistant.\n\nAlternatively you can remove the `{domain}` connection and authentication keys from your `configuration.yaml` file and continue to [set up the integration]({url}) manually. \n\nThe following keys should be removed:\n- `api_version`\n- `host`\n- `port`\n- `ssl`\n- `verify_ssl`\n- `ssl_ca_cert`\n- `username`\n- `password`\n- `database`\n- `token`\n- `organization`\n- `bucket`\n- `path`",
-      "title": "[%key:component::influxdb::issues::deprecated_yaml_import_issue_cannot_connect::title%]"
-    },
-    "deprecated_yaml_import_issue_ssl_error": {
-      "description": "Configuring InfluxDB connection settings using YAML is being removed but the import failed due to an SSL certificate error.\n\nPlease correct your YAML configuration and restart Home Assistant.\n\nAlternatively you can remove the `{domain}` connection and authentication keys from your `configuration.yaml` file and continue to [set up the integration]({url}) manually. \n\nThe following keys should be removed:\n- `api_version`\n- `host`\n- `port`\n- `ssl`\n- `verify_ssl`\n- `ssl_ca_cert`\n- `username`\n- `password`\n- `database`\n- `token`\n- `organization`\n- `bucket`\n- `path`",
-      "title": "[%key:component::influxdb::issues::deprecated_yaml_import_issue_cannot_connect::title%]"
-    },
-    "deprecated_yaml_import_issue_unknown": {
-      "description": "Configuring InfluxDB connection settings using YAML is being removed but the import failed due to an unknown error.\n\nPlease correct your YAML configuration and restart Home Assistant.\n\nAlternatively you can remove the `{domain}` connection and authentication keys from your `configuration.yaml` file and continue to [set up the integration]({url}) manually. \n\nThe following keys should be removed:\n- `api_version`\n- `host`\n- `port`\n- `ssl`\n- `verify_ssl`\n- `ssl_ca_cert`\n- `username`\n- `password`\n- `database`\n- `token`\n- `organization`\n- `bucket`\n- `path`",
-      "title": "[%key:component::influxdb::issues::deprecated_yaml_import_issue_cannot_connect::title%]"
-    }
   }
 }

homeassistant/components/iron_os/update.py

@@ -9,7 +9,6 @@ from homeassistant.components.update import (
     UpdateEntityDescription,
     UpdateEntityFeature,
 )
-from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.restore_state import RestoreEntity
@@ -23,7 +22,6 @@ PARALLEL_UPDATES = 0
 UPDATE_DESCRIPTION = UpdateEntityDescription(
     key="firmware",
     device_class=UpdateDeviceClass.FIRMWARE,
-    entity_category=EntityCategory.DIAGNOSTIC,
 )
 
 

homeassistant/components/knx/manifest.json

@@ -13,7 +13,7 @@
   "requirements": [
     "xknx==3.15.0",
     "xknxproject==3.8.2",
-    "knx-frontend==2026.3.2.183756"
+    "knx-frontend==2026.2.13.222258"
   ],
   "single_config_entry": true
 }

homeassistant/components/kodi/browse_media.py

@@ -219,7 +219,7 @@ async def library_payload(hass):
     )
 
     for child in library_info.children:
-        child.thumbnail = "/api/brands/integration/kodi/logo.png"
+        child.thumbnail = "https://brands.home-assistant.io/_/kodi/logo.png"
 
     with contextlib.suppress(BrowseError):
         item = await media_source.async_browse_media(

homeassistant/components/liebherr/quality_scale.yaml

@@ -47,7 +47,7 @@ rules:
     comment: Cloud API does not require updating entry data from network discovery.
   discovery: done
   docs-data-update: done
-  docs-examples: done
+  docs-examples: todo
   docs-known-limitations: done
   docs-supported-devices: done
   docs-supported-functions: done

homeassistant/components/lovelace/__init__.py

@@ -353,13 +353,14 @@ def _register_panel(
     kwargs = {
         "frontend_url_path": url_path,
         "require_admin": config[CONF_REQUIRE_ADMIN],
-        "show_in_sidebar": config[CONF_SHOW_IN_SIDEBAR],
-        "sidebar_title": config[CONF_TITLE],
-        "sidebar_icon": config.get(CONF_ICON, DEFAULT_ICON),
         "config": {"mode": mode},
         "update": update,
     }
 
+    if config[CONF_SHOW_IN_SIDEBAR]:
+        kwargs["sidebar_title"] = config[CONF_TITLE]
+        kwargs["sidebar_icon"] = config.get(CONF_ICON, DEFAULT_ICON)
+
     frontend.async_register_built_in_panel(hass, DOMAIN, **kwargs)
 
 

homeassistant/components/lovelace/cast.py

@@ -42,7 +42,7 @@ async def async_get_media_browser_root_object(
             media_class=MediaClass.APP,
             media_content_id="",
             media_content_type=DOMAIN,
-            thumbnail="/api/brands/integration/lovelace/logo.png",
+            thumbnail="https://brands.home-assistant.io/_/lovelace/logo.png",
             can_play=False,
             can_expand=True,
         )
@@ -72,7 +72,7 @@ async def async_browse_media(
                 media_class=MediaClass.APP,
                 media_content_id=DEFAULT_DASHBOARD,
                 media_content_type=DOMAIN,
-                thumbnail="/api/brands/integration/lovelace/logo.png",
+                thumbnail="https://brands.home-assistant.io/_/lovelace/logo.png",
                 can_play=True,
                 can_expand=False,
             )
@@ -104,7 +104,7 @@ async def async_browse_media(
                 media_class=MediaClass.APP,
                 media_content_id=f"{info['url_path']}/{view['path']}",
                 media_content_type=DOMAIN,
-                thumbnail="/api/brands/integration/lovelace/logo.png",
+                thumbnail="https://brands.home-assistant.io/_/lovelace/logo.png",
                 can_play=True,
                 can_expand=False,
             )
@@ -213,7 +213,7 @@ def _item_from_info(info: dict) -> BrowseMedia:
         media_class=MediaClass.APP,
         media_content_id=info["url_path"],
         media_content_type=DOMAIN,
-        thumbnail="/api/brands/integration/lovelace/logo.png",
+        thumbnail="https://brands.home-assistant.io/_/lovelace/logo.png",
         can_play=True,
         can_expand=len(info["views"]) > 1,
     )

homeassistant/components/matter/vacuum.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from enum import IntEnum
-import logging
 from typing import TYPE_CHECKING, Any
 
 from chip.clusters import Objects as clusters
@@ -27,8 +26,6 @@ from .entity import MatterEntity, MatterEntityDescription
 from .helpers import get_matter
 from .models import MatterDiscoverySchema
 
-_LOGGER = logging.getLogger(__name__)
-
 
 class OperationalState(IntEnum):
     """Operational State of the vacuum cleaner.
@@ -171,9 +168,8 @@ class MatterVacuum(MatterEntity, StateVacuumEntity):
         segments: dict[str, Segment] = {}
         for area in supported_areas:
             area_name = None
-            location_info = area.areaInfo.locationInfo
-            if location_info not in (None, clusters.NullValue):
-                area_name = location_info.locationName
+            if area.areaInfo and area.areaInfo.locationInfo:
+                area_name = area.areaInfo.locationInfo.locationName
 
             if area_name:
                 segment_id = str(area.areaID)
@@ -210,11 +206,10 @@ class MatterVacuum(MatterEntity, StateVacuumEntity):
 
         if (
             response
-            and response["status"]
-            != clusters.ServiceArea.Enums.SelectAreasStatus.kSuccess
+            and response.status != clusters.ServiceArea.Enums.SelectAreasStatus.kSuccess
         ):
             raise HomeAssistantError(
-                f"Failed to select areas: {response['statusText'] or response['status']}"
+                f"Failed to select areas: {response.statusText or response.status.name}"
             )
 
         await self.send_device_command(
@@ -257,18 +252,9 @@ class MatterVacuum(MatterEntity, StateVacuumEntity):
             VacuumEntityFeature.CLEAN_AREA in self.supported_features
             and self.registry_entry is not None
             and (last_seen_segments := self.last_seen_segments) is not None
-            # Ignore empty segments; some devices transiently
-            # report an empty list before sending the real one.
-            and (current_segments := self._current_segments)
+            and self._current_segments != {s.id: s for s in last_seen_segments}
         ):
-            last_seen_by_id = {s.id: s for s in last_seen_segments}
-            if current_segments != last_seen_by_id:
-                _LOGGER.debug(
-                    "Vacuum segments changed: last_seen=%s, current=%s",
-                    last_seen_by_id,
-                    current_segments,
-                )
-                self.async_create_segments_issue()
+            self.async_create_segments_issue()
 
     @callback
     def _calculate_features(self) -> None:

homeassistant/components/matter/valve.py

@@ -69,37 +69,34 @@ class MatterValve(MatterEntity, ValveEntity):
     def _update_from_device(self) -> None:
         """Update from device."""
         self._calculate_features()
-        self._attr_is_opening = False
-        self._attr_is_closing = False
-
-        current_state: int | None
+        current_state: int
         current_state = self.get_matter_attribute_value(
             ValveConfigurationAndControl.Attributes.CurrentState
         )
-        target_state: int | None
+        target_state: int
         target_state = self.get_matter_attribute_value(
             ValveConfigurationAndControl.Attributes.TargetState
         )
-
-        if current_state is None:
-            self._attr_is_closed = None
-        elif current_state == ValveStateEnum.kTransitioning and (
-            target_state == ValveStateEnum.kOpen
+        if (
+            current_state == ValveStateEnum.kTransitioning
+            and target_state == ValveStateEnum.kOpen
         ):
             self._attr_is_opening = True
-            self._attr_is_closed = None
-        elif current_state == ValveStateEnum.kTransitioning and (
-            target_state == ValveStateEnum.kClosed
+            self._attr_is_closing = False
+        elif (
+            current_state == ValveStateEnum.kTransitioning
+            and target_state == ValveStateEnum.kClosed
         ):
+            self._attr_is_opening = False
             self._attr_is_closing = True
-            self._attr_is_closed = None
         elif current_state == ValveStateEnum.kClosed:
+            self._attr_is_opening = False
+            self._attr_is_closing = False
             self._attr_is_closed = True
-        elif current_state == ValveStateEnum.kOpen:
-            self._attr_is_closed = False
         else:
-            self._attr_is_closed = None
-
+            self._attr_is_opening = False
+            self._attr_is_closing = False
+            self._attr_is_closed = False
         # handle optional position
         if self.supported_features & ValveEntityFeature.SET_POSITION:
             self._attr_current_valve_position = self.get_matter_attribute_value(
@@ -148,7 +145,6 @@ DISCOVERY_SCHEMAS = [
             ValveConfigurationAndControl.Attributes.CurrentState,
             ValveConfigurationAndControl.Attributes.TargetState,
         ),
-        allow_none_value=True,
         optional_attributes=(ValveConfigurationAndControl.Attributes.CurrentLevel,),
         device_type=(device_types.WaterValve,),
     ),

homeassistant/components/media_source/models.py

@@ -83,7 +83,7 @@ class MediaSourceItem:
                         identifier=None,
                         media_class=MediaClass.APP,
                         media_content_type=MediaType.APP,
-                        thumbnail=f"/api/brands/integration/{source.domain}/logo.png",
+                        thumbnail=f"https://brands.home-assistant.io/_/{source.domain}/logo.png",
                         title=source.name,
                         can_play=False,
                         can_expand=True,

homeassistant/components/mobile_app/notify.py

@@ -120,7 +120,6 @@ class MobileAppNotificationService(BaseNotificationService):
 
         local_push_channels = self.hass.data[DOMAIN][DATA_PUSH_CHANNEL]
 
-        failed_targets = []
         for target in targets:
             registration = self.hass.data[DOMAIN][DATA_CONFIG_ENTRIES][target].data
 
@@ -135,16 +134,12 @@ class MobileAppNotificationService(BaseNotificationService):
 
             # Test if local push only.
             if ATTR_PUSH_URL not in registration[ATTR_APP_DATA]:
-                failed_targets.append(target)
-                continue
+                raise HomeAssistantError(
+                    "Device not connected to local push notifications"
+                )
 
             await self._async_send_remote_message_target(target, registration, data)
 
-        if failed_targets:
-            raise HomeAssistantError(
-                f"Device(s) with webhook id(s) {', '.join(failed_targets)} not connected to local push notifications"
-            )
-
     async def _async_send_remote_message_target(self, target, registration, data):
         """Send a message to a target."""
         app_data = registration[ATTR_APP_DATA]

homeassistant/components/nest/__init__.py

@@ -7,7 +7,7 @@ import asyncio
 from http import HTTPStatus
 import logging
 
-from aiohttp import ClientError, web
+from aiohttp import ClientError, ClientResponseError, web
 from google_nest_sdm.camera_traits import CameraClipPreviewTrait
 from google_nest_sdm.device import Device
 from google_nest_sdm.device_manager import DeviceManager
@@ -43,8 +43,6 @@ from homeassistant.exceptions import (
     ConfigEntryAuthFailed,
     ConfigEntryNotReady,
     HomeAssistantError,
-    OAuth2TokenRequestError,
-    OAuth2TokenRequestReauthError,
     Unauthorized,
 )
 from homeassistant.helpers import (
@@ -255,11 +253,11 @@ async def async_setup_entry(hass: HomeAssistant, entry: NestConfigEntry) -> bool
     auth = await api.new_auth(hass, entry)
     try:
         await auth.async_get_access_token()
-    except OAuth2TokenRequestReauthError as err:
-        raise ConfigEntryAuthFailed(
-            translation_domain=DOMAIN, translation_key="reauth_required"
-        ) from err
-    except OAuth2TokenRequestError as err:
+    except ClientResponseError as err:
+        if 400 <= err.status < 500:
+            raise ConfigEntryAuthFailed(
+                translation_domain=DOMAIN, translation_key="reauth_required"
+            ) from err
         raise ConfigEntryNotReady(
             translation_domain=DOMAIN, translation_key="auth_server_error"
         ) from err

homeassistant/components/nintendo_parental_controls/__init__.py

@@ -20,11 +20,11 @@ from .coordinator import NintendoParentalControlsConfigEntry, NintendoUpdateCoor
 from .services import async_setup_services
 
 _PLATFORMS: list[Platform] = [
+    Platform.SENSOR,
+    Platform.TIME,
+    Platform.SWITCH,
     Platform.NUMBER,
     Platform.SELECT,
-    Platform.SENSOR,
-    Platform.SWITCH,
-    Platform.TIME,
 ]
 
 PLATFORM_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)

homeassistant/components/nrgkick/diagnostics.py

@@ -1,30 +0,0 @@
-"""Diagnostics support for NRGkick."""
-
-from __future__ import annotations
-
-from dataclasses import asdict
-from typing import Any
-
-from homeassistant.components.diagnostics import async_redact_data
-from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
-from homeassistant.core import HomeAssistant
-
-from .coordinator import NRGkickConfigEntry
-
-TO_REDACT = {
-    CONF_PASSWORD,
-    CONF_USERNAME,
-}
-
-
-async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, entry: NRGkickConfigEntry
-) -> dict[str, Any]:
-    """Return diagnostics for a config entry."""
-    return async_redact_data(
-        {
-            "entry_data": entry.data,
-            "coordinator_data": asdict(entry.runtime_data.data),
-        },
-        TO_REDACT,
-    )

homeassistant/components/nrgkick/quality_scale.yaml

@@ -48,7 +48,7 @@ rules:
 
   # Gold
   devices: done
-  diagnostics: done
+  diagnostics: todo
   discovery: done
   discovery-update-info: done
   docs-data-update: done

homeassistant/components/ntfy/__init__.py

@@ -11,7 +11,6 @@ from aiontfy.exceptions import (
     NtfyTimeoutError,
     NtfyUnauthorizedAuthenticationError,
 )
-from aiontfy.update import UpdateChecker
 
 from homeassistant.const import CONF_TOKEN, CONF_URL, CONF_VERIFY_SSL, Platform
 from homeassistant.core import HomeAssistant
@@ -19,27 +18,14 @@ from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.typing import ConfigType
-from homeassistant.util.hass_dict import HassKey
 
 from .const import DOMAIN
-from .coordinator import (
-    NtfyConfigEntry,
-    NtfyDataUpdateCoordinator,
-    NtfyLatestReleaseUpdateCoordinator,
-    NtfyRuntimeData,
-    NtfyVersionDataUpdateCoordinator,
-)
+from .coordinator import NtfyConfigEntry, NtfyDataUpdateCoordinator
 from .services import async_setup_services
 
 _LOGGER = logging.getLogger(__name__)
-PLATFORMS: list[Platform] = [
-    Platform.EVENT,
-    Platform.NOTIFY,
-    Platform.SENSOR,
-    Platform.UPDATE,
-]
+PLATFORMS: list[Platform] = [Platform.EVENT, Platform.NOTIFY, Platform.SENSOR]
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
-NTFY_KEY: HassKey[NtfyLatestReleaseUpdateCoordinator] = HassKey(DOMAIN)
 
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
@@ -54,11 +40,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: NtfyConfigEntry) -> bool
 
     session = async_get_clientsession(hass, entry.data.get(CONF_VERIFY_SSL, True))
     ntfy = Ntfy(entry.data[CONF_URL], session, token=entry.data.get(CONF_TOKEN))
-    if NTFY_KEY not in hass.data:
-        update_checker = UpdateChecker(session)
-        update_coordinator = NtfyLatestReleaseUpdateCoordinator(hass, update_checker)
-        await update_coordinator.async_request_refresh()
-        hass.data[NTFY_KEY] = update_coordinator
 
     try:
         await ntfy.account()
@@ -88,11 +69,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: NtfyConfigEntry) -> bool
 
     coordinator = NtfyDataUpdateCoordinator(hass, entry, ntfy)
     await coordinator.async_config_entry_first_refresh()
-
-    version = NtfyVersionDataUpdateCoordinator(hass, entry, ntfy)
-    await version.async_config_entry_first_refresh()
-
-    entry.runtime_data = NtfyRuntimeData(coordinator, version)
+    entry.runtime_data = coordinator
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 

homeassistant/components/ntfy/const.py

@@ -3,7 +3,7 @@
 from typing import Final
 
 DOMAIN = "ntfy"
-DEFAULT_URL: Final = "https://ntfy.sh/"
+DEFAULT_URL: Final = "https://ntfy.sh"
 
 CONF_TOPIC = "topic"
 CONF_PRIORITY = "filter_priority"

homeassistant/components/ntfy/coordinator.py

@@ -2,20 +2,16 @@
 
 from __future__ import annotations
 
-from abc import abstractmethod
-from dataclasses import dataclass
 from datetime import timedelta
 import logging
 
-from aiontfy import Account as NtfyAccount, Ntfy, Version
+from aiontfy import Account as NtfyAccount, Ntfy
 from aiontfy.exceptions import (
     NtfyConnectionError,
     NtfyHTTPError,
-    NtfyNotFoundPageError,
     NtfyTimeoutError,
     NtfyUnauthorizedAuthenticationError,
 )
-from aiontfy.update import LatestRelease, UpdateChecker, UpdateCheckerError
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
@@ -26,22 +22,13 @@ from .const import DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
-type NtfyConfigEntry = ConfigEntry[NtfyRuntimeData]
+type NtfyConfigEntry = ConfigEntry[NtfyDataUpdateCoordinator]
 
 
-@dataclass
-class NtfyRuntimeData:
-    """Holds ntfy runtime data."""
-
-    account: NtfyDataUpdateCoordinator
-    version: NtfyVersionDataUpdateCoordinator
-
-
-class BaseDataUpdateCoordinator[_DataT](DataUpdateCoordinator[_DataT]):
-    """Ntfy base coordinator."""
+class NtfyDataUpdateCoordinator(DataUpdateCoordinator[NtfyAccount]):
+    """Ntfy data update coordinator."""
 
     config_entry: NtfyConfigEntry
-    update_interval: timedelta
 
     def __init__(
         self, hass: HomeAssistant, config_entry: NtfyConfigEntry, ntfy: Ntfy
@@ -52,19 +39,21 @@ class BaseDataUpdateCoordinator[_DataT](DataUpdateCoordinator[_DataT]):
             _LOGGER,
             config_entry=config_entry,
             name=DOMAIN,
-            update_interval=self.update_interval,
+            update_interval=timedelta(minutes=15),
         )
 
         self.ntfy = ntfy
 
-    @abstractmethod
-    async def async_update_data(self) -> _DataT:
-        """Fetch the latest data from the source."""
+    async def _async_update_data(self) -> NtfyAccount:
+        """Fetch account data from ntfy."""
 
-    async def _async_update_data(self) -> _DataT:
-        """Fetch the latest data from the source."""
         try:
-            return await self.async_update_data()
+            return await self.ntfy.account()
+        except NtfyUnauthorizedAuthenticationError as e:
+            raise ConfigEntryAuthFailed(
+                translation_domain=DOMAIN,
+                translation_key="authentication_error",
+            ) from e
         except NtfyHTTPError as e:
             _LOGGER.debug("Error %s: %s [%s]", e.code, e.error, e.link)
             raise UpdateFailed(
@@ -83,62 +72,3 @@ class BaseDataUpdateCoordinator[_DataT](DataUpdateCoordinator[_DataT]):
                 translation_domain=DOMAIN,
                 translation_key="timeout_error",
             ) from e
-
-
-class NtfyDataUpdateCoordinator(BaseDataUpdateCoordinator[NtfyAccount]):
-    """Ntfy data update coordinator."""
-
-    update_interval = timedelta(minutes=15)
-
-    async def async_update_data(self) -> NtfyAccount:
-        """Fetch account data from ntfy."""
-
-        try:
-            return await self.ntfy.account()
-        except NtfyUnauthorizedAuthenticationError as e:
-            raise ConfigEntryAuthFailed(
-                translation_domain=DOMAIN,
-                translation_key="authentication_error",
-            ) from e
-
-
-class NtfyVersionDataUpdateCoordinator(BaseDataUpdateCoordinator[Version | None]):
-    """Ntfy data update coordinator."""
-
-    update_interval = timedelta(hours=3)
-
-    async def async_update_data(self) -> Version | None:
-        """Fetch version data from ntfy."""
-        try:
-            version = await self.ntfy.version()
-        except NtfyUnauthorizedAuthenticationError, NtfyNotFoundPageError:
-            # /v1/version endpoint is only accessible to admins and
-            # available in ntfy since version 2.17.0
-            return None
-        return version
-
-
-class NtfyLatestReleaseUpdateCoordinator(DataUpdateCoordinator[LatestRelease]):
-    """Ntfy latest release update coordinator."""
-
-    def __init__(self, hass: HomeAssistant, update_checker: UpdateChecker) -> None:
-        """Initialize coordinator."""
-        super().__init__(
-            hass,
-            _LOGGER,
-            config_entry=None,
-            name=DOMAIN,
-            update_interval=timedelta(hours=3),
-        )
-        self.update_checker = update_checker
-
-    async def _async_update_data(self) -> LatestRelease:
-        """Fetch latest release data."""
-
-        try:
-            return await self.update_checker.latest_release()
-        except UpdateCheckerError as e:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="update_check_failed",
-            ) from e

homeassistant/components/ntfy/entity.py

@@ -7,11 +7,10 @@ from yarl import URL
 from homeassistant.config_entries import ConfigSubentry
 from homeassistant.const import CONF_URL
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
-from homeassistant.helpers.entity import Entity, EntityDescription
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
+from homeassistant.helpers.entity import Entity
 
 from .const import CONF_TOPIC, DOMAIN
-from .coordinator import BaseDataUpdateCoordinator, NtfyConfigEntry
+from .coordinator import NtfyConfigEntry
 
 
 class NtfyBaseEntity(Entity):
@@ -39,29 +38,6 @@ class NtfyBaseEntity(Entity):
             identifiers={(DOMAIN, f"{config_entry.entry_id}_{subentry.subentry_id}")},
             via_device=(DOMAIN, config_entry.entry_id),
         )
-        self.ntfy = config_entry.runtime_data.account.ntfy
+        self.ntfy = config_entry.runtime_data.ntfy
         self.config_entry = config_entry
         self.subentry = subentry
-
-
-class NtfyCommonBaseEntity(CoordinatorEntity[BaseDataUpdateCoordinator]):
-    """Base entity for common entities."""
-
-    _attr_has_entity_name = True
-
-    def __init__(
-        self,
-        coordinator: BaseDataUpdateCoordinator,
-        description: EntityDescription,
-    ) -> None:
-        """Initialize entity."""
-        super().__init__(coordinator)
-        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{description.key}"
-        self._attr_device_info = DeviceInfo(
-            entry_type=DeviceEntryType.SERVICE,
-            manufacturer="ntfy LLC",
-            model="ntfy",
-            configuration_url=URL(coordinator.config_entry.data[CONF_URL]) / "app",
-            identifiers={(DOMAIN, coordinator.config_entry.entry_id)},
-        )

homeassistant/components/ntfy/sensor.py

@@ -7,19 +7,22 @@ from dataclasses import dataclass
 from enum import StrEnum
 
 from aiontfy import Account as NtfyAccount
+from yarl import URL
 
 from homeassistant.components.sensor import (
     SensorDeviceClass,
     SensorEntity,
     SensorEntityDescription,
 )
-from homeassistant.const import EntityCategory, UnitOfInformation, UnitOfTime
+from homeassistant.const import CONF_URL, EntityCategory, UnitOfInformation, UnitOfTime
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
+from .const import DOMAIN
 from .coordinator import NtfyConfigEntry, NtfyDataUpdateCoordinator
-from .entity import NtfyCommonBaseEntity
 
 PARALLEL_UPDATES = 0
 
@@ -230,19 +233,38 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the sensor platform."""
-    coordinator = config_entry.runtime_data.account
+    coordinator = config_entry.runtime_data
     async_add_entities(
         NtfySensorEntity(coordinator, description)
         for description in SENSOR_DESCRIPTIONS
     )
 
 
-class NtfySensorEntity(NtfyCommonBaseEntity, SensorEntity):
+class NtfySensorEntity(CoordinatorEntity[NtfyDataUpdateCoordinator], SensorEntity):
     """Representation of a ntfy sensor entity."""
 
     entity_description: NtfySensorEntityDescription
     coordinator: NtfyDataUpdateCoordinator
 
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: NtfyDataUpdateCoordinator,
+        description: NtfySensorEntityDescription,
+    ) -> None:
+        """Initialize a sensor entity."""
+        super().__init__(coordinator)
+        self.entity_description = description
+        self._attr_unique_id = f"{coordinator.config_entry.entry_id}_{description.key}"
+        self._attr_device_info = DeviceInfo(
+            entry_type=DeviceEntryType.SERVICE,
+            manufacturer="ntfy LLC",
+            model="ntfy",
+            configuration_url=URL(coordinator.config_entry.data[CONF_URL]) / "app",
+            identifiers={(DOMAIN, coordinator.config_entry.entry_id)},
+        )
+
     @property
     def native_value(self) -> StateType:
         """Return the state of the sensor."""

homeassistant/components/ntfy/strings.json

@@ -261,11 +261,6 @@
           "supporter": "Supporter"
         }
       }
-    },
-    "update": {
-      "update": {
-        "name": "ntfy version"
-      }
     }
   },
   "exceptions": {
@@ -307,9 +302,6 @@
     },
     "timeout_error": {
       "message": "Failed to connect to ntfy service due to a connection timeout"
-    },
-    "update_check_failed": {
-      "message": "Failed to check for latest ntfy update"
     }
   },
   "issues": {

homeassistant/components/ntfy/update.py

@@ -1,116 +0,0 @@
-"""Update platform for the ntfy integration."""
-
-from __future__ import annotations
-
-from enum import StrEnum
-
-from homeassistant.components.update import (
-    UpdateEntity,
-    UpdateEntityDescription,
-    UpdateEntityFeature,
-)
-from homeassistant.const import CONF_URL, EntityCategory
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity import EntityDescription
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from . import NTFY_KEY
-from .const import DEFAULT_URL
-from .coordinator import (
-    NtfyConfigEntry,
-    NtfyLatestReleaseUpdateCoordinator,
-    NtfyVersionDataUpdateCoordinator,
-)
-from .entity import NtfyCommonBaseEntity
-
-PARALLEL_UPDATES = 0
-
-
-class NtfyUpdate(StrEnum):
-    """Ntfy update."""
-
-    UPDATE = "update"
-
-
-DESCRIPTION = UpdateEntityDescription(
-    key=NtfyUpdate.UPDATE,
-    translation_key=NtfyUpdate.UPDATE,
-    entity_category=EntityCategory.DIAGNOSTIC,
-)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: NtfyConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up update platform."""
-    if (
-        entry.data[CONF_URL] != DEFAULT_URL
-        and (version_coordinator := entry.runtime_data.version).data is not None
-    ):
-        update_coordinator = hass.data[NTFY_KEY]
-        async_add_entities(
-            [NtfyUpdateEntity(version_coordinator, update_coordinator, DESCRIPTION)]
-        )
-
-
-class NtfyUpdateEntity(NtfyCommonBaseEntity, UpdateEntity):
-    """Representation of an update entity."""
-
-    _attr_supported_features = UpdateEntityFeature.RELEASE_NOTES
-    coordinator: NtfyVersionDataUpdateCoordinator
-
-    def __init__(
-        self,
-        coordinator: NtfyVersionDataUpdateCoordinator,
-        update_checker: NtfyLatestReleaseUpdateCoordinator,
-        description: EntityDescription,
-    ) -> None:
-        """Initialize the entity."""
-        super().__init__(coordinator, description)
-        self.update_checker = update_checker
-        if self._attr_device_info and self.installed_version:
-            self._attr_device_info.update({"sw_version": self.installed_version})
-
-    @property
-    def installed_version(self) -> str | None:
-        """Current version."""
-        return self.coordinator.data.version if self.coordinator.data else None
-
-    @property
-    def title(self) -> str | None:
-        """Title of the release."""
-
-        return f"ntfy {self.update_checker.data.name}"
-
-    @property
-    def release_url(self) -> str | None:
-        """URL to the full release notes."""
-
-        return self.update_checker.data.html_url
-
-    @property
-    def latest_version(self) -> str | None:
-        """Latest version."""
-
-        return self.update_checker.data.tag_name.removeprefix("v")
-
-    async def async_release_notes(self) -> str | None:
-        """Return the release notes."""
-        return self.update_checker.data.body
-
-    async def async_added_to_hass(self) -> None:
-        """When entity is added to hass.
-
-        Register extra update listener for the update checker coordinator.
-        """
-        await super().async_added_to_hass()
-        self.async_on_remove(
-            self.update_checker.async_add_listener(self._handle_coordinator_update)
-        )
-
-    @property
-    def available(self) -> bool:
-        """Return if entity is available."""
-        return super().available and self.update_checker.last_update_success

homeassistant/components/openai_conversation/config_flow.py

@@ -512,11 +512,6 @@ class OpenAISubentryFlowHandler(ConfigSubentryFlow):
                     options.pop(CONF_WEB_SEARCH_REGION, None)
                     options.pop(CONF_WEB_SEARCH_COUNTRY, None)
                     options.pop(CONF_WEB_SEARCH_TIMEZONE, None)
-            if (
-                user_input.get(CONF_CODE_INTERPRETER)
-                and user_input.get(CONF_REASONING_EFFORT) == "minimal"
-            ):
-                errors[CONF_CODE_INTERPRETER] = "code_interpreter_minimal_reasoning"
 
             options.update(user_input)
             if not errors:
@@ -544,15 +539,15 @@ class OpenAISubentryFlowHandler(ConfigSubentryFlow):
         if not model.startswith(("o", "gpt-5")) or model.startswith("gpt-5-pro"):
             return []
 
-        models_reasoning_map: dict[str | tuple[str, ...], list[str]] = {
+        MODELS_REASONING_MAP = {
             "gpt-5.2-pro": ["medium", "high", "xhigh"],
-            ("gpt-5.2", "gpt-5.3"): ["none", "low", "medium", "high", "xhigh"],
+            "gpt-5.2": ["none", "low", "medium", "high", "xhigh"],
             "gpt-5.1": ["none", "low", "medium", "high"],
             "gpt-5": ["minimal", "low", "medium", "high"],
             "": ["low", "medium", "high"],  # The default case
         }
 
-        for prefix, options in models_reasoning_map.items():
+        for prefix, options in MODELS_REASONING_MAP.items():
             if model.startswith(prefix):
                 return options
         return []  # pragma: no cover

homeassistant/components/openai_conversation/strings.json

@@ -38,7 +38,6 @@
       },
       "entry_type": "AI task",
       "error": {
-        "code_interpreter_minimal_reasoning": "[%key:component::openai_conversation::config_subentries::conversation::error::code_interpreter_minimal_reasoning%]",
         "model_not_supported": "[%key:component::openai_conversation::config_subentries::conversation::error::model_not_supported%]",
         "web_search_minimal_reasoning": "[%key:component::openai_conversation::config_subentries::conversation::error::web_search_minimal_reasoning%]"
       },
@@ -94,7 +93,6 @@
       },
       "entry_type": "Conversation agent",
       "error": {
-        "code_interpreter_minimal_reasoning": "Code interpreter is not supported with minimal reasoning effort",
         "model_not_supported": "This model is not supported, please select a different model",
         "web_search_minimal_reasoning": "Web search is currently not supported with minimal reasoning effort"
       },

homeassistant/components/overseerr/config_flow.py

@@ -69,7 +69,7 @@ class OverseerrConfigFlow(ConfigFlow, domain=DOMAIN):
                 else:
                     if self.source == SOURCE_USER:
                         return self.async_create_entry(
-                            title="Seerr",
+                            title="Overseerr",
                             data={
                                 CONF_HOST: host,
                                 CONF_PORT: port,

homeassistant/components/overseerr/manifest.json

@@ -1,6 +1,6 @@
 {
   "domain": "overseerr",
-  "name": "Seerr",
+  "name": "Overseerr",
   "after_dependencies": ["cloud"],
   "codeowners": ["@joostlek", "@AmGarera"],
   "config_flow": true,

homeassistant/components/overseerr/strings.json

@@ -25,8 +25,8 @@
           "url": "[%key:common::config_flow::data::url%]"
         },
         "data_description": {
-          "api_key": "The API key of the Seerr instance.",
-          "url": "The URL of the Seerr instance."
+          "api_key": "The API key of the Overseerr instance.",
+          "url": "The URL of the Overseerr instance."
         }
       }
     }
@@ -114,7 +114,7 @@
       "message": "[%key:common::config_flow::error::invalid_api_key%]"
     },
     "connection_error": {
-      "message": "Error connecting to the Seerr instance: {error}"
+      "message": "Error connecting to the Overseerr instance: {error}"
     }
   },
   "selector": {
@@ -137,11 +137,11 @@
   },
   "services": {
     "get_requests": {
-      "description": "Retrieves a list of media requests from Seerr.",
+      "description": "Retrieves a list of media requests from Overseerr.",
       "fields": {
         "config_entry_id": {
-          "description": "The Seerr instance to get requests from.",
-          "name": "Seerr instance"
+          "description": "The Overseerr instance to get requests from.",
+          "name": "Overseerr instance"
         },
         "requested_by": {
           "description": "Filter the requests by the user ID that requested them.",