Add total disk size to glances as an entity (#168131)

Co-authored-by: Joostlek <joostlek@outlook.com>

.claude/agents/raise-pull-request.md

@@ -186,15 +186,11 @@ If `CHANGE_TYPE` IS "Breaking change" or "Deprecation", keep the `## Breaking ch
 
 ## Step 10: Push Branch and Create PR
 
-```bash
-# Get branch name and GitHub username
-BRANCH=$(git branch --show-current)
-PUSH_REMOTE=$(git config "branch.$BRANCH.remote" 2>/dev/null || git remote | head -1)
-GITHUB_USER=$(gh api user --jq .login 2>/dev/null || git remote get-url "$PUSH_REMOTE" | sed -E 's#.*[:/]([^/]+)/([^/]+)(\.git)?$#\1#')
+Push the branch with upstream tracking, and create a PR against `home-assistant/core` with the generated title and body:
 
+```bash
 # Create PR (gh pr create pushes the branch automatically)
 gh pr create --repo home-assistant/core --base dev \
-  --head "$GITHUB_USER:$BRANCH" \
   --draft \
   --title "TITLE_HERE" \
   --body "$(cat <<'EOF'

.github/renovate.json

@@ -0,0 +1,205 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": ["config:recommended"],
+
+  "enabledManagers": [
+    "pep621",
+    "pip_requirements",
+    "pre-commit",
+    "homeassistant-manifest"
+  ],
+
+  "pre-commit": {
+    "enabled": true
+  },
+
+  "pip_requirements": {
+    "managerFilePatterns": [
+      "/(^|/)requirements[\\w_-]*\\.txt$/",
+      "/(^|/)homeassistant/package_constraints\\.txt$/"
+    ]
+  },
+
+  "homeassistant-manifest": {
+    "managerFilePatterns": [
+      "/^homeassistant/components/[^/]+/manifest\\.json$/"
+    ]
+  },
+
+  "minimumReleaseAge": "7 days",
+  "prConcurrentLimit": 10,
+  "prHourlyLimit": 2,
+  "schedule": ["before 6am"],
+
+  "semanticCommits": "disabled",
+  "commitMessageAction": "Update",
+  "commitMessageTopic": "{{depName}}",
+  "commitMessageExtra": "to {{newVersion}}",
+
+  "automerge": false,
+
+  "vulnerabilityAlerts": {
+    "enabled": false
+  },
+
+  "packageRules": [
+    {
+      "description": "Deny all by default — allowlist below re-enables specific packages",
+      "matchPackageNames": ["*"],
+      "enabled": false
+    },
+    {
+      "description": "Core runtime dependencies (allowlisted)",
+      "matchPackageNames": [
+        "aiohttp",
+        "aiohttp-fast-zlib",
+        "aiohttp_cors",
+        "aiohttp-asyncmdnsresolver",
+        "yarl",
+        "httpx",
+        "requests",
+        "urllib3",
+        "certifi",
+        "orjson",
+        "PyYAML",
+        "Jinja2",
+        "cryptography",
+        "pyOpenSSL",
+        "PyJWT",
+        "SQLAlchemy",
+        "Pillow",
+        "attrs",
+        "uv",
+        "voluptuous",
+        "voluptuous-serialize",
+        "voluptuous-openapi",
+        "zeroconf"
+      ],
+      "enabled": true,
+      "labels": ["dependency", "core"]
+    },
+    {
+      "description": "Common Python utilities (allowlisted)",
+      "matchPackageNames": [
+        "astral",
+        "atomicwrites-homeassistant",
+        "audioop-lts",
+        "awesomeversion",
+        "bcrypt",
+        "ciso8601",
+        "cronsim",
+        "defusedxml",
+        "fnv-hash-fast",
+        "getmac",
+        "ical",
+        "ifaddr",
+        "lru-dict",
+        "mutagen",
+        "propcache",
+        "pyserial",
+        "python-slugify",
+        "PyTurboJPEG",
+        "securetar",
+        "standard-aifc",
+        "standard-telnetlib",
+        "ulid-transform",
+        "url-normalize",
+        "xmltodict"
+      ],
+      "enabled": true,
+      "labels": ["dependency"]
+    },
+    {
+      "description": "Home Assistant ecosystem packages (core-maintained, no cooldown)",
+      "matchPackageNames": [
+        "hassil",
+        "home-assistant-bluetooth",
+        "home-assistant-frontend",
+        "home-assistant-intents",
+        "infrared-protocols"
+      ],
+      "enabled": true,
+      "minimumReleaseAge": null,
+      "labels": ["dependency", "core"]
+    },
+    {
+      "description": "Test dependencies (allowlisted)",
+      "matchPackageNames": [
+        "pytest",
+        "pytest-asyncio",
+        "pytest-aiohttp",
+        "pytest-cov",
+        "pytest-freezer",
+        "pytest-github-actions-annotate-failures",
+        "pytest-socket",
+        "pytest-sugar",
+        "pytest-timeout",
+        "pytest-unordered",
+        "pytest-picked",
+        "pytest-xdist",
+        "pylint",
+        "pylint-per-file-ignores",
+        "astroid",
+        "coverage",
+        "freezegun",
+        "syrupy",
+        "respx",
+        "requests-mock",
+        "ruff",
+        "codespell",
+        "yamllint",
+        "zizmor"
+      ],
+      "enabled": true,
+      "labels": ["dependency"]
+    },
+    {
+      "description": "For types-* stubs, only allow patch updates. Major/minor bumps track the upstream runtime package version and must be manually coordinated with the corresponding pin.",
+      "matchPackageNames": ["/^types-/"],
+      "matchUpdateTypes": ["patch"],
+      "enabled": true,
+      "labels": ["dependency"]
+    },
+    {
+      "description": "Pre-commit hook repos (allowlisted, matched by owner/repo)",
+      "matchPackageNames": [
+        "astral-sh/ruff-pre-commit",
+        "codespell-project/codespell",
+        "adrienverge/yamllint",
+        "zizmorcore/zizmor-pre-commit"
+      ],
+      "enabled": true,
+      "labels": ["dependency"]
+    },
+    {
+      "description": "Group ruff pre-commit hook with its PyPI twin into one PR",
+      "matchPackageNames": ["astral-sh/ruff-pre-commit", "ruff"],
+      "groupName": "ruff",
+      "groupSlug": "ruff"
+    },
+    {
+      "description": "Group codespell pre-commit hook with its PyPI twin into one PR",
+      "matchPackageNames": ["codespell-project/codespell", "codespell"],
+      "groupName": "codespell",
+      "groupSlug": "codespell"
+    },
+    {
+      "description": "Group yamllint pre-commit hook with its PyPI twin into one PR",
+      "matchPackageNames": ["adrienverge/yamllint", "yamllint"],
+      "groupName": "yamllint",
+      "groupSlug": "yamllint"
+    },
+    {
+      "description": "Group zizmor pre-commit hook with its PyPI twin into one PR",
+      "matchPackageNames": ["zizmorcore/zizmor-pre-commit", "zizmor"],
+      "groupName": "zizmor",
+      "groupSlug": "zizmor"
+    },
+    {
+      "description": "Group pylint with astroid (their versions are linked and must move together)",
+      "matchPackageNames": ["pylint", "astroid"],
+      "groupName": "pylint",
+      "groupSlug": "pylint"
+    }
+  ]
+}

.github/workflows/builder.yml

@@ -53,10 +53,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: |
@@ -207,353 +207,353 @@ jobs:
           push: true
           version: ${{ needs.init.outputs.version }}
 
-  # build_machine:
-  #   name: Build ${{ matrix.machine }} 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
-  #         - 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
-  #   steps:
-  #     - name: Checkout the repository
-  #       uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
-  #       with:
-  #         persist-credentials: false
+  build_machine:
+    name: Build ${{ matrix.machine }} 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
+          - 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
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          persist-credentials: false
 
-  #     - name: Compute extra tags
-  #       id: tags
-  #       shell: bash
-  #       env:
-  #         VERSION: ${{ needs.init.outputs.version }}
-  #       run: |
-  #         if [[ "${VERSION}" =~ d ]]; then
-  #           echo "extra_tags=dev" >> "$GITHUB_OUTPUT"
-  #         elif [[ "${VERSION}" =~ b ]]; then
-  #           echo "extra_tags=beta" >> "$GITHUB_OUTPUT"
-  #         else
-  #           echo "extra_tags=stable" >> "$GITHUB_OUTPUT"
-  #         fi
+      - name: Compute extra tags
+        id: tags
+        shell: bash
+        env:
+          VERSION: ${{ needs.init.outputs.version }}
+        run: |
+          if [[ "${VERSION}" =~ d ]]; then
+            echo "extra_tags=dev" >> "$GITHUB_OUTPUT"
+          elif [[ "${VERSION}" =~ b ]]; then
+            echo "extra_tags=beta" >> "$GITHUB_OUTPUT"
+          else
+            echo "extra_tags=stable" >> "$GITHUB_OUTPUT"
+          fi
 
-  #     - name: Build machine image
-  #       uses: home-assistant/builder/actions/build-image@62a1597b84b3461abad9816d9cd92862a2b542c3 # 2026.03.2
-  #       with:
-  #         arch: ${{ matrix.arch }}
-  #         build-args: |
-  #           BUILD_FROM=ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
-  #         cache-gha: false
-  #         container-registry-password: ${{ secrets.GITHUB_TOKEN }}
-  #         context: machine/
-  #         cosign-base-identity: "https://github.com/home-assistant/core/.*"
-  #         cosign-base-verify: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
-  #         file: machine/${{ matrix.machine }}
-  #         image: ghcr.io/home-assistant/${{ matrix.machine }}-homeassistant
-  #         image-tags: |
-  #           ${{ needs.init.outputs.version }}
-  #           ${{ steps.tags.outputs.extra_tags }}
-  #         push: true
-  #         version: ${{ needs.init.outputs.version }}
+      - name: Build machine image
+        uses: home-assistant/builder/actions/build-image@62a1597b84b3461abad9816d9cd92862a2b542c3 # 2026.03.2
+        with:
+          arch: ${{ matrix.arch }}
+          build-args: |
+            BUILD_FROM=ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
+          cache-gha: false
+          container-registry-password: ${{ secrets.GITHUB_TOKEN }}
+          context: machine/
+          cosign-base-identity: "https://github.com/home-assistant/core/.*"
+          cosign-base-verify: ghcr.io/home-assistant/${{ matrix.arch }}-homeassistant:${{ needs.init.outputs.version }}
+          file: machine/${{ matrix.machine }}
+          image: ghcr.io/home-assistant/${{ matrix.machine }}-homeassistant
+          image-tags: |
+            ${{ needs.init.outputs.version }}
+            ${{ steps.tags.outputs.extra_tags }}
+          push: true
+          version: ${{ needs.init.outputs.version }}
 
-  # 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
+  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: 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
+        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"]'
+      - 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@cad07c2e89fa2edd6e2d7bab4c1aa38e53f76003 # v4.1.1
-  #       with:
-  #         cosign-release: "v2.5.3"
+  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@cad07c2e89fa2edd6e2d7bab4c1aa38e53f76003 # v4.1.1
+        with:
+          cosign-release: "v2.5.3"
 
-  #     - name: Login to DockerHub
-  #       if: matrix.registry == 'docker.io/homeassistant'
-  #       uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
-  #       with:
-  #         username: ${{ secrets.DOCKERHUB_USERNAME }}
-  #         password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Login to DockerHub
+        if: matrix.registry == 'docker.io/homeassistant'
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
 
-  #     - name: Login to GitHub Container Registry
-  #       uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
-  #       with:
-  #         registry: ghcr.io
-  #         username: ${{ github.repository_owner }}
-  #         password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.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"
+      - 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@030e881283bb7a6894de51c315a6bfe6a94e05cf # v6.0.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') }}
+      # 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@030e881283bb7a6894de51c315a6bfe6a94e05cf # v6.0.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@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # v3.7.1
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@4d04d5d9486b7bd6fa91e7baf45bbb4f8b9deedd # 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: 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
+      - 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
+          # 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[@]}"
+          # 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
+          # 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"
+          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
+  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
-  #       uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
-  #       with:
-  #         python-version-file: ".python-version"
+      - name: Set up Python
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        with:
+          python-version-file: ".python-version"
 
-  #     - name: Download translations
-  #       uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
-  #       with:
-  #         name: translations
+      - name: Download translations
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
+        with:
+          name: translations
 
-  #     - name: Extract translations
-  #       run: |
-  #         tar xvf translations.tar.gz
-  #         rm translations.tar.gz
+      - 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: 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@cef221092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.0
-  #       with:
-  #         skip-existing: true
+      - name: Upload package to PyPI
+        uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.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
+  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@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
-  #       with:
-  #         registry: ghcr.io
-  #         username: ${{ github.repository_owner }}
-  #         password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.GITHUB_TOKEN }}
 
-  #     - name: Build Docker image
-  #       uses: docker/build-push-action@d08e5c354a6adb9ed34480a06d141179aa583294 # v7.0.0
-  #       with:
-  #         context: . # So action will not pull the repository again
-  #         file: ./script/hassfest/docker/Dockerfile
-  #         load: true
-  #         tags: ${{ env.HASSFEST_IMAGE_TAG }}
+      - name: Build Docker image
+        uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
+        with:
+          context: . # So action will not pull the repository again
+          file: ./script/hassfest/docker/Dockerfile
+          load: true
+          tags: ${{ env.HASSFEST_IMAGE_TAG }}
 
-  #     - name: Run hassfest against core
-  #       run: docker run --rm -v "${GITHUB_WORKSPACE}":/github/workspace "${HASSFEST_IMAGE_TAG}" --core-path=/github/workspace
+      - 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@d08e5c354a6adb9ed34480a06d141179aa583294 # v7.0.0
-  #       with:
-  #         context: . # So action will not pull the repository again
-  #         file: ./script/hassfest/docker/Dockerfile
-  #         push: true
-  #         tags: ${{ env.HASSFEST_IMAGE_TAG }},${{ env.HASSFEST_IMAGE_NAME }}:latest
+      - name: Push Docker image
+        if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
+        id: push
+        uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
+        with:
+          context: . # So action will not pull the repository again
+          file: ./script/hassfest/docker/Dockerfile
+          push: true
+          tags: ${{ env.HASSFEST_IMAGE_TAG }},${{ env.HASSFEST_IMAGE_NAME }}:latest
 
-  #     - name: Generate artifact attestation
-  #       if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
-  #       uses: actions/attest@59d89421af93a897026c735860bf21b6eb4f7b26 # v4.1.0
-  #       with:
-  #         subject-name: ${{ env.HASSFEST_IMAGE_NAME }}
-  #         subject-digest: ${{ steps.push.outputs.digest }}
-  #         push-to-registry: true
+      - name: Generate artifact attestation
+        if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
+        uses: actions/attest@59d89421af93a897026c735860bf21b6eb4f7b26 # v4.1.0
+        with:
+          subject-name: ${{ env.HASSFEST_IMAGE_NAME }}
+          subject-digest: ${{ steps.push.outputs.digest }}
+          push-to-registry: true

.gitignore

@@ -142,5 +142,6 @@ pytest_buckets.txt
 
 # AI tooling
 .claude/settings.local.json
+.claude/worktrees/
 .serena/
 

.pre-commit-config.yaml

@@ -8,7 +8,7 @@ repos:
       - id: ruff-format
         files: ^((homeassistant|pylint|script|tests)/.+)?[^/]+\.(py|pyi)$
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.4.1
+    rev: v2.4.2
     hooks:
       - id: codespell
         args:
@@ -36,7 +36,7 @@ repos:
           - --branch=master
           - --branch=rc
   - repo: https://github.com/adrienverge/yamllint.git
-    rev: v1.37.1
+    rev: v1.38.0
     hooks:
       - id: yamllint
   - repo: https://github.com/rbubley/mirrors-prettier

CODEOWNERS

@@ -362,6 +362,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/deluge/ @tkdrob
 /homeassistant/components/demo/ @home-assistant/core
 /tests/components/demo/ @home-assistant/core
+/homeassistant/components/denon_rs232/ @balloob
+/tests/components/denon_rs232/ @balloob
 /homeassistant/components/denonavr/ @ol-iver @starkillerOG
 /tests/components/denonavr/ @ol-iver @starkillerOG
 /homeassistant/components/derivative/ @afaucogney @karwosts

Dockerfile

@@ -19,24 +19,22 @@ ENV \
     UV_SYSTEM_PYTHON=true \
     UV_NO_CACHE=true
 
+WORKDIR /usr/src
+
 # Home Assistant S6-Overlay
 COPY rootfs /
 
 # Add go2rtc binary
 COPY --from=ghcr.io/alexxit/go2rtc@sha256:675c318b23c06fd862a61d262240c9a63436b4050d177ffc68a32710d9e05bae /usr/local/bin/go2rtc /bin/go2rtc
 
-RUN \
-    # Verify go2rtc can be executed
-    go2rtc --version \
-    # Install uv
-    && pip3 install uv==0.11.1
-
-WORKDIR /usr/src
-
 ## Setup Home Assistant Core dependencies
 COPY --parents requirements.txt homeassistant/package_constraints.txt homeassistant/
 RUN \
-    uv pip install \
+    # Verify go2rtc can be executed
+    go2rtc --version \
+    # Install uv at the version pinned in the requirements file
+    && pip3 install --no-cache-dir "uv==$(awk -F'==' '/^uv==/{print $2}' homeassistant/requirements.txt)" \
+    && uv pip install \
         --no-build \
         -r homeassistant/requirements.txt
 
@@ -50,7 +48,7 @@ RUN \
         -r homeassistant/requirements_all.txt
 
 ## Setup Home Assistant Core
-COPY --parents CODEOWNERS LICENSE* README* homeassistant pyproject.toml homeassistant/
+COPY --parents LICENSE* README* homeassistant/ pyproject.toml homeassistant/
 RUN \
     uv pip install \
         -e ./homeassistant \

homeassistant/auth/jwt_wrapper.py

@@ -7,23 +7,31 @@ to speed up the process.
 
 from __future__ import annotations
 
+from collections.abc import Container, Iterable, Sequence
 from datetime import timedelta
-from functools import lru_cache, partial
-from typing import Any
+from functools import lru_cache
+from typing import Any, override
 
-from jwt import DecodeError, PyJWS, PyJWT
+from jwt import DecodeError, PyJWK, PyJWS, PyJWT
+from jwt.algorithms import AllowedPublicKeys
+from jwt.types import Options
 
 from homeassistant.util.json import json_loads
 
 JWT_TOKEN_CACHE_SIZE = 16
 MAX_TOKEN_SIZE = 8192
 
-_VERIFY_KEYS = ("signature", "exp", "nbf", "iat", "aud", "iss", "sub", "jti")
-
-_VERIFY_OPTIONS: dict[str, Any] = {f"verify_{key}": True for key in _VERIFY_KEYS} | {
-    "require": []
-}
-_NO_VERIFY_OPTIONS = {f"verify_{key}": False for key in _VERIFY_KEYS}
+_NO_VERIFY_OPTIONS = Options(
+    verify_signature=False,
+    verify_exp=False,
+    verify_nbf=False,
+    verify_iat=False,
+    verify_aud=False,
+    verify_iss=False,
+    verify_sub=False,
+    verify_jti=False,
+    require=[],
+)
 
 
 class _PyJWSWithLoadCache(PyJWS):
@@ -38,9 +46,6 @@ class _PyJWSWithLoadCache(PyJWS):
         return super()._load(jwt)
 
 
-_jws = _PyJWSWithLoadCache()
-
-
 @lru_cache(maxsize=JWT_TOKEN_CACHE_SIZE)
 def _decode_payload(json_payload: str) -> dict[str, Any]:
     """Decode the payload from a JWS dictionary."""
@@ -56,21 +61,12 @@ def _decode_payload(json_payload: str) -> dict[str, Any]:
 class _PyJWTWithVerify(PyJWT):
     """PyJWT with a fast decode implementation."""
 
-    def decode_payload(
-        self, jwt: str, key: str, options: dict[str, Any], algorithms: list[str]
-    ) -> dict[str, Any]:
-        """Decode a JWT's payload."""
-        if len(jwt) > MAX_TOKEN_SIZE:
-            # Avoid caching impossible tokens
-            raise DecodeError("Token too large")
-        return _decode_payload(
-            _jws.decode_complete(
-                jwt=jwt,
-                key=key,
-                algorithms=algorithms,
-                options=options,
-            )["payload"]
-        )
+    def __init__(self) -> None:
+        """Initialize the PyJWT instance."""
+        # We require exp and iat claims to be present
+        super().__init__(Options(require=["exp", "iat"]))
+        # Override the _jws instance with our cached version
+        self._jws = _PyJWSWithLoadCache()
 
     def verify_and_decode(
         self,
@@ -79,37 +75,70 @@ class _PyJWTWithVerify(PyJWT):
         algorithms: list[str],
         issuer: str | None = None,
         leeway: float | timedelta = 0,
-        options: dict[str, Any] | None = None,
+        options: Options | None = None,
     ) -> dict[str, Any]:
         """Verify a JWT's signature and claims."""
-        merged_options = {**_VERIFY_OPTIONS, **(options or {})}
-        payload = self.decode_payload(
+        return self.decode(
             jwt=jwt,
             key=key,
-            options=merged_options,
             algorithms=algorithms,
-        )
-        # These should never be missing since we verify them
-        # but this is an additional safeguard to make sure
-        # nothing slips through.
-        assert "exp" in payload, "exp claim is required"
-        assert "iat" in payload, "iat claim is required"
-        self._validate_claims(
-            payload=payload,
-            options=merged_options,
             issuer=issuer,
             leeway=leeway,
+            options=options,
         )
-        return payload
+
+    @override
+    def decode(
+        self,
+        jwt: str | bytes,
+        key: AllowedPublicKeys | PyJWK | str | bytes = "",
+        algorithms: Sequence[str] | None = None,
+        options: Options | None = None,
+        verify: bool | None = None,
+        detached_payload: bytes | None = None,
+        audience: str | Iterable[str] | None = None,
+        subject: str | None = None,
+        issuer: str | Container[str] | None = None,
+        leeway: float | timedelta = 0,
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        """Decode a JWT, verifying the signature and claims."""
+        if len(jwt) > MAX_TOKEN_SIZE:
+            # Avoid caching impossible tokens
+            raise DecodeError("Token too large")
+        return super().decode(
+            jwt=jwt,
+            key=key,
+            algorithms=algorithms,
+            options=options,
+            verify=verify,
+            detached_payload=detached_payload,
+            audience=audience,
+            subject=subject,
+            issuer=issuer,
+            leeway=leeway,
+            **kwargs,
+        )
+
+    @override
+    def _decode_payload(self, decoded: dict[str, Any]) -> dict[str, Any]:
+        return _decode_payload(decoded["payload"])
 
 
 _jwt = _PyJWTWithVerify()
 verify_and_decode = _jwt.verify_and_decode
-unverified_hs256_token_decode = lru_cache(maxsize=JWT_TOKEN_CACHE_SIZE)(
-    partial(
-        _jwt.decode_payload, key="", algorithms=["HS256"], options=_NO_VERIFY_OPTIONS
+
+
+@lru_cache(maxsize=JWT_TOKEN_CACHE_SIZE)
+def unverified_hs256_token_decode(jwt: str) -> dict[str, Any]:
+    """Decode a JWT without verifying the signature."""
+    return _jwt.decode(
+        jwt=jwt,
+        key="",
+        algorithms=["HS256"],
+        options=_NO_VERIFY_OPTIONS,
     )
-)
+
 
 __all__ = [
     "unverified_hs256_token_decode",

homeassistant/brands/denon.json

@@ -1,5 +1,5 @@
 {
   "domain": "denon",
   "name": "Denon",
-  "integrations": ["denon", "denonavr", "heos"]
+  "integrations": ["denon", "denonavr", "denon_rs232", "heos"]
 }

homeassistant/components/acer_projector/const.py

@@ -6,10 +6,11 @@ from typing import Final
 
 from homeassistant.const import STATE_OFF, STATE_ON
 
+CONF_READ_TIMEOUT: Final = "timeout"
 CONF_WRITE_TIMEOUT: Final = "write_timeout"
 
 DEFAULT_NAME: Final = "Acer Projector"
-DEFAULT_TIMEOUT: Final = 1
+DEFAULT_READ_TIMEOUT: Final = 1
 DEFAULT_WRITE_TIMEOUT: Final = 1
 
 ECO_MODE: Final = "ECO Mode"

homeassistant/components/acer_projector/manifest.json

@@ -5,5 +5,5 @@
   "documentation": "https://www.home-assistant.io/integrations/acer_projector",
   "iot_class": "local_polling",
   "quality_scale": "legacy",
-  "requirements": ["pyserial==3.5"]
+  "requirements": ["serialx==1.2.2"]
 }

homeassistant/components/acer_projector/switch.py

@@ -6,7 +6,7 @@ import logging
 import re
 from typing import Any
 
-import serial
+from serialx import Serial, SerialException
 import voluptuous as vol
 
 from homeassistant.components.switch import (
@@ -16,21 +16,22 @@ from homeassistant.components.switch import (
 from homeassistant.const import (
     CONF_FILENAME,
     CONF_NAME,
-    CONF_TIMEOUT,
     STATE_OFF,
     STATE_ON,
     STATE_UNKNOWN,
 )
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 from .const import (
     CMD_DICT,
+    CONF_READ_TIMEOUT,
     CONF_WRITE_TIMEOUT,
     DEFAULT_NAME,
-    DEFAULT_TIMEOUT,
+    DEFAULT_READ_TIMEOUT,
     DEFAULT_WRITE_TIMEOUT,
     ECO_MODE,
     ICON,
@@ -45,7 +46,7 @@ PLATFORM_SCHEMA = SWITCH_PLATFORM_SCHEMA.extend(
     {
         vol.Required(CONF_FILENAME): cv.isdevice,
         vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
-        vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int,
+        vol.Optional(CONF_READ_TIMEOUT, default=DEFAULT_READ_TIMEOUT): cv.positive_int,
         vol.Optional(
             CONF_WRITE_TIMEOUT, default=DEFAULT_WRITE_TIMEOUT
         ): cv.positive_int,
@@ -62,10 +63,10 @@ def setup_platform(
     """Connect with serial port and return Acer Projector."""
     serial_port = config[CONF_FILENAME]
     name = config[CONF_NAME]
-    timeout = config[CONF_TIMEOUT]
+    read_timeout = config[CONF_READ_TIMEOUT]
     write_timeout = config[CONF_WRITE_TIMEOUT]
 
-    add_entities([AcerSwitch(serial_port, name, timeout, write_timeout)], True)
+    add_entities([AcerSwitch(serial_port, name, read_timeout, write_timeout)], True)
 
 
 class AcerSwitch(SwitchEntity):
@@ -77,14 +78,14 @@ class AcerSwitch(SwitchEntity):
         self,
         serial_port: str,
         name: str,
-        timeout: int,
+        read_timeout: int,
         write_timeout: int,
     ) -> None:
         """Init of the Acer projector."""
-        self.serial = serial.Serial(
-            port=serial_port, timeout=timeout, write_timeout=write_timeout
-        )
         self._serial_port = serial_port
+        self._read_timeout = read_timeout
+        self._write_timeout = write_timeout
+
         self._attr_name = name
         self._attributes = {
             LAMP_HOURS: STATE_UNKNOWN,
@@ -94,22 +95,26 @@ class AcerSwitch(SwitchEntity):
 
     def _write_read(self, msg: str) -> str:
         """Write to the projector and read the return."""
-        ret = ""
+
         # Sometimes the projector won't answer for no reason or the projector
         # was disconnected during runtime.
         # This way the projector can be reconnected and will still work
         try:
-            if not self.serial.is_open:
-                self.serial.open()
-            self.serial.write(msg.encode("utf-8"))
-            # Size is an experience value there is no real limit.
-            # AFAIK there is no limit and no end character so we will usually
-            # need to wait for timeout
-            ret = self.serial.read_until(size=20).decode("utf-8")
-        except serial.SerialException:
-            _LOGGER.error("Problem communicating with %s", self._serial_port)
-        self.serial.close()
-        return ret
+            with Serial.from_url(
+                self._serial_port,
+                read_timeout=self._read_timeout,
+                write_timeout=self._write_timeout,
+            ) as serial:
+                serial.write(msg.encode("utf-8"))
+
+                # Size is an experience value there is no real limit.
+                # AFAIK there is no limit and no end character so we will usually
+                # need to wait for timeout
+                return serial.read_until(size=20).decode("utf-8")
+        except (OSError, SerialException, TimeoutError) as exc:
+            raise HomeAssistantError(
+                f"Problem communicating with {self._serial_port}"
+            ) from exc
 
     def _write_read_format(self, msg: str) -> str:
         """Write msg, obtain answer and format output."""

homeassistant/components/actron_air/quality_scale.yaml

@@ -57,9 +57,9 @@ rules:
   entity-category: done
   entity-device-class: todo
   entity-disabled-by-default: todo
-  entity-translations: todo
+  entity-translations: done
   exception-translations: done
-  icon-translations: todo
+  icon-translations: done
   reconfiguration-flow: todo
   repair-issues:
     status: exempt

homeassistant/components/air_quality/strings.json

@@ -3,6 +3,7 @@
     "condition_behavior_name": "Condition passes if",
     "condition_threshold_name": "Threshold type",
     "trigger_behavior_name": "Trigger when",
+    "trigger_for_name": "For at least",
     "trigger_threshold_name": "Threshold type"
   },
   "conditions": {
@@ -249,6 +250,9 @@
         "behavior": {
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
+        "for": {
+          "name": "[%key:component::air_quality::common::trigger_for_name%]"
+        },
         "threshold": {
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
@@ -269,6 +273,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::air_quality::common::trigger_for_name%]"
         }
       },
       "name": "Carbon monoxide cleared"
@@ -279,6 +286,9 @@
         "behavior": {
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
+        "for": {
+          "name": "[%key:component::air_quality::common::trigger_for_name%]"
+        },
         "threshold": {
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
@@ -290,6 +300,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::air_quality::common::trigger_for_name%]"
         }
       },
       "name": "Carbon monoxide detected"
@@ -299,6 +312,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::air_quality::common::trigger_for_name%]"
         }
       },
       "name": "Gas cleared"
@@ -308,6 +324,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::air_quality::common::trigger_for_name%]"
         }
       },
       "name": "Gas detected"
@@ -327,6 +346,9 @@
         "behavior": {
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
+        "for": {
+          "name": "[%key:component::air_quality::common::trigger_for_name%]"
+        },
         "threshold": {
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
@@ -348,6 +370,9 @@
         "behavior": {
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
+        "for": {
+          "name": "[%key:component::air_quality::common::trigger_for_name%]"
+        },
         "threshold": {
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
@@ -369,6 +394,9 @@
         "behavior": {
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
+        "for": {
+          "name": "[%key:component::air_quality::common::trigger_for_name%]"
+        },
         "threshold": {
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
@@ -390,6 +418,9 @@
         "behavior": {
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
+        "for": {
+          "name": "[%key:component::air_quality::common::trigger_for_name%]"
+        },
         "threshold": {
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
@@ -411,6 +442,9 @@
         "behavior": {
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
+        "for": {
+          "name": "[%key:component::air_quality::common::trigger_for_name%]"
+        },
         "threshold": {
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
@@ -432,6 +466,9 @@
         "behavior": {
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
+        "for": {
+          "name": "[%key:component::air_quality::common::trigger_for_name%]"
+        },
         "threshold": {
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
@@ -453,6 +490,9 @@
         "behavior": {
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
+        "for": {
+          "name": "[%key:component::air_quality::common::trigger_for_name%]"
+        },
         "threshold": {
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
@@ -474,6 +514,9 @@
         "behavior": {
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
+        "for": {
+          "name": "[%key:component::air_quality::common::trigger_for_name%]"
+        },
         "threshold": {
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
@@ -485,6 +528,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::air_quality::common::trigger_for_name%]"
         }
       },
       "name": "Smoke cleared"
@@ -494,6 +540,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::air_quality::common::trigger_for_name%]"
         }
       },
       "name": "Smoke detected"
@@ -513,6 +562,9 @@
         "behavior": {
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
+        "for": {
+          "name": "[%key:component::air_quality::common::trigger_for_name%]"
+        },
         "threshold": {
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
@@ -534,6 +586,9 @@
         "behavior": {
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
+        "for": {
+          "name": "[%key:component::air_quality::common::trigger_for_name%]"
+        },
         "threshold": {
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
@@ -555,6 +610,9 @@
         "behavior": {
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
+        "for": {
+          "name": "[%key:component::air_quality::common::trigger_for_name%]"
+        },
         "threshold": {
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }

homeassistant/components/air_quality/triggers.yaml

@@ -9,6 +9,11 @@
           - first
           - last
           - any
+  for: &trigger_for
+    required: true
+    default: 00:00:00
+    selector:
+      duration:
 
 # --- Unit lists for multi-unit pollutants ---
 
@@ -163,6 +168,7 @@
 # Binary sensor detected/cleared trigger fields
 .trigger_binary_fields: &trigger_binary_fields
   behavior: *trigger_behavior
+  for: *trigger_for
 
 # --- Binary sensor targets ---
 
@@ -294,6 +300,7 @@ co_crossed_threshold:
   target: *target_co_sensor
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -320,6 +327,7 @@ co2_crossed_threshold:
   target: *target_co2
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -344,6 +352,7 @@ pm1_crossed_threshold:
   target: *target_pm1
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -368,6 +377,7 @@ pm25_crossed_threshold:
   target: *target_pm25
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -392,6 +402,7 @@ pm4_crossed_threshold:
   target: *target_pm4
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -416,6 +427,7 @@ pm10_crossed_threshold:
   target: *target_pm10
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -442,6 +454,7 @@ ozone_crossed_threshold:
   target: *target_ozone
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -470,6 +483,7 @@ voc_crossed_threshold:
   target: *target_voc
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -498,6 +512,7 @@ voc_ratio_crossed_threshold:
   target: *target_voc_ratio
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -526,6 +541,7 @@ no_crossed_threshold:
   target: *target_no
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -554,6 +570,7 @@ no2_crossed_threshold:
   target: *target_no2
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -580,6 +597,7 @@ n2o_crossed_threshold:
   target: *target_n2o
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -606,6 +624,7 @@ so2_crossed_threshold:
   target: *target_so2
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
     threshold:
       required: true
       selector:

homeassistant/components/alarm_control_panel/strings.json

@@ -1,7 +1,8 @@
 {
   "common": {
     "condition_behavior_name": "Condition passes if",
-    "trigger_behavior_name": "Trigger when"
+    "trigger_behavior_name": "Trigger when",
+    "trigger_for_name": "For at least"
   },
   "conditions": {
     "is_armed": {
@@ -234,6 +235,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::alarm_control_panel::common::trigger_for_name%]"
         }
       },
       "name": "Alarm armed"
@@ -243,6 +247,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::alarm_control_panel::common::trigger_for_name%]"
         }
       },
       "name": "Alarm armed away"
@@ -252,6 +259,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::alarm_control_panel::common::trigger_for_name%]"
         }
       },
       "name": "Alarm armed home"
@@ -261,6 +271,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::alarm_control_panel::common::trigger_for_name%]"
         }
       },
       "name": "Alarm armed night"
@@ -270,6 +283,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::alarm_control_panel::common::trigger_for_name%]"
         }
       },
       "name": "Alarm armed vacation"
@@ -279,6 +295,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::alarm_control_panel::common::trigger_for_name%]"
         }
       },
       "name": "Alarm disarmed"
@@ -288,6 +307,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::alarm_control_panel::common::trigger_for_name%]"
         }
       },
       "name": "Alarm triggered"

homeassistant/components/alarm_control_panel/triggers.yaml

@@ -13,6 +13,11 @@
             - last
             - any
           translation_key: trigger_behavior
+    for:
+      required: true
+      default: 00:00:00
+      selector:
+        duration:
 
 armed: *trigger_common
 

homeassistant/components/analytics_insights/strings.json

@@ -11,12 +11,12 @@
       "user": {
         "data": {
           "tracked_apps": "Apps",
-          "tracked_custom_integrations": "Community integrations",
+          "tracked_custom_integrations": "Custom integrations",
           "tracked_integrations": "Integrations"
         },
         "data_description": {
           "tracked_apps": "Select the apps you want to track",
-          "tracked_custom_integrations": "Select the community integrations you want to track",
+          "tracked_custom_integrations": "Select the custom integrations you want to track",
           "tracked_integrations": "Select the integrations you want to track"
         }
       }
@@ -31,7 +31,7 @@
         "unit_of_measurement": "[%key:component::analytics_insights::entity::sensor::apps::unit_of_measurement%]"
       },
       "custom_integrations": {
-        "name": "{custom_integration_domain} (community)",
+        "name": "{custom_integration_domain} (custom)",
         "unit_of_measurement": "[%key:component::analytics_insights::entity::sensor::apps::unit_of_measurement%]"
       },
       "total_active_installations": {

homeassistant/components/assist_satellite/strings.json

@@ -1,7 +1,8 @@
 {
   "common": {
     "condition_behavior_name": "Condition passes if",
-    "trigger_behavior_name": "Trigger when"
+    "trigger_behavior_name": "Trigger when",
+    "trigger_for_name": "For at least"
   },
   "conditions": {
     "is_idle": {
@@ -160,6 +161,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::assist_satellite::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::assist_satellite::common::trigger_for_name%]"
         }
       },
       "name": "Satellite became idle"
@@ -169,6 +173,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::assist_satellite::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::assist_satellite::common::trigger_for_name%]"
         }
       },
       "name": "Satellite started listening"
@@ -178,6 +185,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::assist_satellite::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::assist_satellite::common::trigger_for_name%]"
         }
       },
       "name": "Satellite started processing"
@@ -187,6 +197,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::assist_satellite::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::assist_satellite::common::trigger_for_name%]"
         }
       },
       "name": "Satellite started responding"

homeassistant/components/assist_satellite/triggers.yaml

@@ -13,6 +13,11 @@
             - last
             - any
           translation_key: trigger_behavior
+    for:
+      required: true
+      default: 00:00:00
+      selector:
+        duration:
 
 idle: *trigger_common
 listening: *trigger_common

homeassistant/components/auth/__init__.py

@@ -157,7 +157,6 @@ from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.config_entry_oauth2_flow import OAuth2AuthorizeCallbackView
 from homeassistant.helpers.typing import ConfigType
-from homeassistant.loader import bind_hass
 from homeassistant.util import dt as dt_util
 from homeassistant.util.hass_dict import HassKey
 
@@ -173,7 +172,6 @@ CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
 DELETE_CURRENT_TOKEN_DELAY = 2
 
 
-@bind_hass
 def create_auth_code(
     hass: HomeAssistant, client_id: str, credential: Credentials
 ) -> str:

homeassistant/components/automation/__init__.py

@@ -83,7 +83,6 @@ from homeassistant.helpers.trace import (
     trace_path,
 )
 from homeassistant.helpers.typing import ConfigType
-from homeassistant.loader import bind_hass
 from homeassistant.util.dt import parse_datetime
 from homeassistant.util.hass_dict import HassKey
 
@@ -143,6 +142,7 @@ _EXPERIMENTAL_CONDITION_PLATFORMS = {
     "occupancy",
     "person",
     "power",
+    "remote",
     "schedule",
     "select",
     "siren",
@@ -150,6 +150,8 @@ _EXPERIMENTAL_CONDITION_PLATFORMS = {
     "temperature",
     "text",
     "timer",
+    "todo",
+    "update",
     "vacuum",
     "valve",
     "water_heater",
@@ -235,7 +237,6 @@ class IfAction(Protocol):
         """AND all conditions."""
 
 
-@bind_hass
 def is_on(hass: HomeAssistant, entity_id: str) -> bool:
     """Return true if specified automation entity_id is on.
 

homeassistant/components/battery/strings.json

@@ -3,6 +3,7 @@
     "condition_behavior_name": "Condition passes if",
     "condition_threshold_name": "Threshold type",
     "trigger_behavior_name": "Trigger when",
+    "trigger_for_name": "For at least",
     "trigger_threshold_name": "Threshold type"
   },
   "conditions": {
@@ -87,6 +88,9 @@
         "behavior": {
           "name": "[%key:component::battery::common::trigger_behavior_name%]"
         },
+        "for": {
+          "name": "[%key:component::battery::common::trigger_for_name%]"
+        },
         "threshold": {
           "name": "[%key:component::battery::common::trigger_threshold_name%]"
         }
@@ -98,6 +102,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::battery::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::battery::common::trigger_for_name%]"
         }
       },
       "name": "Battery low"
@@ -107,6 +114,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::battery::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::battery::common::trigger_for_name%]"
         }
       },
       "name": "Battery not low"
@@ -116,6 +126,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::battery::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::battery::common::trigger_for_name%]"
         }
       },
       "name": "Battery started charging"
@@ -125,6 +138,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::battery::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::battery::common::trigger_for_name%]"
         }
       },
       "name": "Battery stopped charging"

homeassistant/components/battery/triggers.yaml

@@ -9,6 +9,11 @@
           - first
           - last
           - any
+  for: &trigger_for
+    required: true
+    default: 00:00:00
+    selector:
+      duration:
 
 .battery_threshold_entity: &battery_threshold_entity
   - domain: input_number
@@ -42,21 +47,25 @@
 low:
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
   target: *trigger_target_battery
 
 not_low:
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
   target: *trigger_target_battery
 
 started_charging:
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
   target: *trigger_target_charging
 
 stopped_charging:
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
   target: *trigger_target_charging
 
 level_changed:
@@ -74,6 +83,7 @@ level_crossed_threshold:
   target: *trigger_target_percentage
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
     threshold:
       required: true
       selector:

homeassistant/components/camera/__init__.py

@@ -58,7 +58,6 @@ from homeassistant.helpers.event import async_track_time_interval
 from homeassistant.helpers.network import get_url
 from homeassistant.helpers.template import Template
 from homeassistant.helpers.typing import ConfigType, VolDictType
-from homeassistant.loader import bind_hass
 
 from .const import (
     CAMERA_IMAGE_TIMEOUT,
@@ -163,7 +162,6 @@ class CameraCapabilities:
     frontend_stream_types: set[StreamType]
 
 
-@bind_hass
 async def async_request_stream(hass: HomeAssistant, entity_id: str, fmt: str) -> str:
     """Request a stream for a camera entity."""
     camera = get_camera_from_entity_id(hass, entity_id)
@@ -212,7 +210,6 @@ async def _async_get_image(
     raise HomeAssistantError("Unable to get image")
 
 
-@bind_hass
 async def async_get_image(
     hass: HomeAssistant,
     entity_id: str,
@@ -247,14 +244,12 @@ async def _async_get_stream_image(
     return None
 
 
-@bind_hass
 async def async_get_stream_source(hass: HomeAssistant, entity_id: str) -> str | None:
     """Fetch the stream source for a camera entity."""
     camera = get_camera_from_entity_id(hass, entity_id)
     return await camera.stream_source()
 
 
-@bind_hass
 async def async_get_mjpeg_stream(
     hass: HomeAssistant, request: web.Request, entity_id: str
 ) -> web.StreamResponse | None:

homeassistant/components/camera/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/camera",
   "integration_type": "entity",
   "quality_scale": "internal",
-  "requirements": ["PyTurboJPEG==1.8.0"]
+  "requirements": ["PyTurboJPEG==2.2.0"]
 }

homeassistant/components/climate/strings.json

@@ -3,6 +3,7 @@
     "condition_behavior_name": "Condition passes if",
     "condition_threshold_name": "Threshold type",
     "trigger_behavior_name": "Trigger when",
+    "trigger_for_name": "For at least",
     "trigger_threshold_name": "Threshold type"
   },
   "conditions": {
@@ -385,6 +386,9 @@
         "behavior": {
           "name": "[%key:component::climate::common::trigger_behavior_name%]"
         },
+        "for": {
+          "name": "[%key:component::climate::common::trigger_for_name%]"
+        },
         "hvac_mode": {
           "description": "The HVAC modes to trigger on.",
           "name": "Modes"
@@ -397,6 +401,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::climate::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::climate::common::trigger_for_name%]"
         }
       },
       "name": "Climate-control device started cooling"
@@ -406,6 +413,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::climate::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::climate::common::trigger_for_name%]"
         }
       },
       "name": "Climate-control device started drying"
@@ -415,6 +425,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::climate::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::climate::common::trigger_for_name%]"
         }
       },
       "name": "Climate-control device started heating"
@@ -434,6 +447,9 @@
         "behavior": {
           "name": "[%key:component::climate::common::trigger_behavior_name%]"
         },
+        "for": {
+          "name": "[%key:component::climate::common::trigger_for_name%]"
+        },
         "threshold": {
           "name": "[%key:component::climate::common::trigger_threshold_name%]"
         }
@@ -455,6 +471,9 @@
         "behavior": {
           "name": "[%key:component::climate::common::trigger_behavior_name%]"
         },
+        "for": {
+          "name": "[%key:component::climate::common::trigger_for_name%]"
+        },
         "threshold": {
           "name": "[%key:component::climate::common::trigger_threshold_name%]"
         }
@@ -466,6 +485,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::climate::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::climate::common::trigger_for_name%]"
         }
       },
       "name": "Climate-control device turned off"
@@ -475,6 +497,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::climate::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::climate::common::trigger_for_name%]"
         }
       },
       "name": "Climate-control device turned on"

homeassistant/components/climate/triggers.yaml

@@ -13,6 +13,11 @@
             - first
             - last
             - any
+    for: &trigger_for
+      required: true
+      default: 00:00:00
+      selector:
+        duration:
 
 .humidity_threshold_entity: &humidity_threshold_entity
   - domain: input_number
@@ -50,6 +55,7 @@ hvac_mode_changed:
   target: *trigger_climate_target
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
     hvac_mode:
       context:
         filter_target: target
@@ -76,6 +82,7 @@ target_humidity_crossed_threshold:
   target: *trigger_climate_target
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -101,6 +108,7 @@ target_temperature_crossed_threshold:
   target: *trigger_climate_target
   fields:
     behavior: *trigger_behavior
+    for: *trigger_for
     threshold:
       required: true
       selector:

homeassistant/components/cloud/__init__.py

@@ -36,7 +36,7 @@ from homeassistant.helpers.dispatcher import (
 from homeassistant.helpers.event import async_call_later
 from homeassistant.helpers.service import async_register_admin_service
 from homeassistant.helpers.typing import ConfigType
-from homeassistant.loader import async_get_integration, bind_hass
+from homeassistant.loader import async_get_integration
 from homeassistant.util.signal_type import SignalType
 
 # Pre-import backup to avoid it being imported
@@ -181,7 +181,6 @@ class CloudConnectionState(Enum):
     CLOUD_DISCONNECTED = "cloud_disconnected"
 
 
-@bind_hass
 @callback
 def async_is_logged_in(hass: HomeAssistant) -> bool:
     """Test if user is logged in.
@@ -191,7 +190,6 @@ def async_is_logged_in(hass: HomeAssistant) -> bool:
     return DATA_CLOUD in hass.data and hass.data[DATA_CLOUD].is_logged_in
 
 
-@bind_hass
 @callback
 def async_is_connected(hass: HomeAssistant) -> bool:
     """Test if connected to the cloud."""
@@ -207,7 +205,6 @@ def async_listen_connection_change(
     return async_dispatcher_connect(hass, SIGNAL_CLOUD_CONNECTION_STATE, target)
 
 
-@bind_hass
 @callback
 def async_active_subscription(hass: HomeAssistant) -> bool:
     """Test if user has an active subscription."""
@@ -230,7 +227,6 @@ async def async_get_or_create_cloudhook(hass: HomeAssistant, webhook_id: str) ->
     return await async_create_cloudhook(hass, webhook_id)
 
 
-@bind_hass
 async def async_create_cloudhook(hass: HomeAssistant, webhook_id: str) -> str:
     """Create a cloudhook."""
     if not async_is_connected(hass):
@@ -245,7 +241,6 @@ async def async_create_cloudhook(hass: HomeAssistant, webhook_id: str) -> str:
     return cloudhook_url
 
 
-@bind_hass
 async def async_delete_cloudhook(hass: HomeAssistant, webhook_id: str) -> None:
     """Delete a cloudhook."""
     if DATA_CLOUD not in hass.data:
@@ -272,7 +267,6 @@ def async_listen_cloudhook_change(
     )
 
 
-@bind_hass
 @callback
 def async_remote_ui_url(hass: HomeAssistant) -> str:
     """Get the remote UI URL."""

homeassistant/components/configurator/__init__.py

@@ -25,7 +25,6 @@ from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity import async_generate_entity_id
 from homeassistant.helpers.event import async_call_later
 from homeassistant.helpers.typing import ConfigType
-from homeassistant.loader import bind_hass
 from homeassistant.util.async_ import run_callback_threadsafe
 
 _KEY_INSTANCE = "configurator"
@@ -54,7 +53,6 @@ type ConfiguratorCallback = Callable[[list[dict[str, str]]], None]
 CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
 
 
-@bind_hass
 @async_callback
 def async_request_config(
     hass: HomeAssistant,
@@ -93,7 +91,6 @@ def async_request_config(
     return request_id
 
 
-@bind_hass
 def request_config(hass: HomeAssistant, *args: Any, **kwargs: Any) -> str:
     """Create a new request for configuration.
 
@@ -104,7 +101,6 @@ def request_config(hass: HomeAssistant, *args: Any, **kwargs: Any) -> str:
     ).result()
 
 
-@bind_hass
 @async_callback
 def async_notify_errors(hass: HomeAssistant, request_id: str, error: str) -> None:
     """Add errors to a config request."""
@@ -112,7 +108,6 @@ def async_notify_errors(hass: HomeAssistant, request_id: str, error: str) -> Non
         _get_requests(hass)[request_id].async_notify_errors(request_id, error)
 
 
-@bind_hass
 def notify_errors(hass: HomeAssistant, request_id: str, error: str) -> None:
     """Add errors to a config request."""
     return run_callback_threadsafe(
@@ -120,7 +115,6 @@ def notify_errors(hass: HomeAssistant, request_id: str, error: str) -> None:
     ).result()
 
 
-@bind_hass
 @async_callback
 def async_request_done(hass: HomeAssistant, request_id: str) -> None:
     """Mark a configuration request as done."""
@@ -128,7 +122,6 @@ def async_request_done(hass: HomeAssistant, request_id: str) -> None:
         _get_requests(hass).pop(request_id).async_request_done(request_id)
 
 
-@bind_hass
 def request_done(hass: HomeAssistant, request_id: str) -> None:
     """Mark a configuration request as done."""
     return run_callback_threadsafe(

homeassistant/components/conversation/__init__.py

@@ -23,7 +23,6 @@ from homeassistant.helpers import config_validation as cv, intent
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.reload import async_integration_yaml_config
 from homeassistant.helpers.typing import ConfigType
-from homeassistant.loader import bind_hass
 
 from .agent_manager import (
     AgentInfo,
@@ -127,7 +126,6 @@ CONFIG_SCHEMA = vol.Schema(
 
 
 @callback
-@bind_hass
 def async_set_agent(
     hass: HomeAssistant,
     config_entry: ConfigEntry,
@@ -138,7 +136,6 @@ def async_set_agent(
 
 
 @callback
-@bind_hass
 def async_unset_agent(
     hass: HomeAssistant,
     config_entry: ConfigEntry,

homeassistant/components/counter/strings.json

@@ -1,6 +1,7 @@
 {
   "common": {
-    "trigger_behavior_name": "Trigger when"
+    "trigger_behavior_name": "Trigger when",
+    "trigger_for_name": "For at least"
   },
   "conditions": {
     "is_value": {
@@ -96,6 +97,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::counter::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::counter::common::trigger_for_name%]"
         }
       },
       "name": "Counter reached maximum"
@@ -105,6 +109,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::counter::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::counter::common::trigger_for_name%]"
         }
       },
       "name": "Counter reached minimum"
@@ -114,6 +121,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::counter::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::counter::common::trigger_for_name%]"
         }
       },
       "name": "Counter reset"

homeassistant/components/counter/triggers.yaml

@@ -13,6 +13,11 @@
             - first
             - last
             - any
+    for:
+      required: true
+      default: 00:00:00
+      selector:
+        duration:
 
 incremented:
   target:

homeassistant/components/cover/__init__.py

@@ -29,7 +29,6 @@ from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity import Entity, EntityDescription
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.typing import ConfigType
-from homeassistant.loader import bind_hass
 from homeassistant.util.hass_dict import HassKey
 
 from .condition import make_cover_is_closed_condition, make_cover_is_open_condition
@@ -87,7 +86,6 @@ __all__ = [
 ]
 
 
-@bind_hass
 def is_closed(hass: HomeAssistant, entity_id: str) -> bool:
     """Return if the cover is closed based on the statemachine."""
     return hass.states.is_state(entity_id, CoverState.CLOSED)

homeassistant/components/cover/strings.json

@@ -1,7 +1,8 @@
 {
   "common": {
     "condition_behavior_name": "Condition passes if",
-    "trigger_behavior_name": "Trigger when"
+    "trigger_behavior_name": "Trigger when",
+    "trigger_for_name": "For at least"
   },
   "conditions": {
     "awning_is_closed": {
@@ -254,6 +255,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::cover::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::cover::common::trigger_for_name%]"
         }
       },
       "name": "Awning closed"
@@ -263,6 +267,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::cover::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::cover::common::trigger_for_name%]"
         }
       },
       "name": "Awning opened"
@@ -272,6 +279,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::cover::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::cover::common::trigger_for_name%]"
         }
       },
       "name": "Blind closed"
@@ -281,6 +291,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::cover::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::cover::common::trigger_for_name%]"
         }
       },
       "name": "Blind opened"
@@ -290,6 +303,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::cover::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::cover::common::trigger_for_name%]"
         }
       },
       "name": "Curtain closed"
@@ -299,6 +315,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::cover::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::cover::common::trigger_for_name%]"
         }
       },
       "name": "Curtain opened"
@@ -308,6 +327,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::cover::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::cover::common::trigger_for_name%]"
         }
       },
       "name": "Shade closed"
@@ -317,6 +339,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::cover::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::cover::common::trigger_for_name%]"
         }
       },
       "name": "Shade opened"
@@ -326,6 +351,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::cover::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::cover::common::trigger_for_name%]"
         }
       },
       "name": "Shutter closed"
@@ -335,6 +363,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::cover::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::cover::common::trigger_for_name%]"
         }
       },
       "name": "Shutter opened"

homeassistant/components/cover/triggers.yaml

@@ -9,6 +9,11 @@
           - first
           - last
           - any
+  for:
+    required: true
+    default: 00:00:00
+    selector:
+      duration:
 
 awning_closed:
   fields: *trigger_common_fields

homeassistant/components/demo/image_processing.py

@@ -45,7 +45,7 @@ class DemoImageProcessingFace(ImageProcessingFaceEntity):
         """Return minimum confidence for send events."""
         return 80
 
-    def process_image(self, image: bytes) -> None:
+    async def async_process_image(self, image: bytes) -> None:
         """Process image."""
         demo_data = [
             FaceInformation(
@@ -58,4 +58,4 @@ class DemoImageProcessingFace(ImageProcessingFaceEntity):
             FaceInformation(confidence=62.53, name="Luna"),
         ]
 
-        self.process_faces(demo_data, 4)
+        self.async_process_faces(demo_data, 4)

homeassistant/components/denon_rs232/__init__.py

@@ -0,0 +1,57 @@
+"""The Denon RS232 integration."""
+
+from __future__ import annotations
+
+from denon_rs232 import DenonReceiver, ReceiverState
+from denon_rs232.models import MODELS
+
+from homeassistant.config_entries import ConfigEntryState
+from homeassistant.const import CONF_DEVICE, CONF_MODEL, Platform
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import ConfigEntryNotReady
+
+from .const import LOGGER, DenonRS232ConfigEntry
+
+PLATFORMS = [Platform.MEDIA_PLAYER]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: DenonRS232ConfigEntry) -> bool:
+    """Set up Denon RS232 from a config entry."""
+    port = entry.data[CONF_DEVICE]
+    model = MODELS[entry.data[CONF_MODEL]]
+    receiver = DenonReceiver(port, model=model)
+
+    try:
+        await receiver.connect()
+        await receiver.query_state()
+    except (ConnectionError, OSError, TimeoutError) as err:
+        LOGGER.error("Error connecting to Denon receiver at %s: %s", port, err)
+        if receiver.connected:
+            await receiver.disconnect()
+        raise ConfigEntryNotReady from err
+
+    entry.runtime_data = receiver
+
+    @callback
+    def _on_disconnect(state: ReceiverState | None) -> None:
+        # Only reload if the entry is still loaded. During entry removal,
+        # disconnect() fires this callback but the entry is already gone.
+        if state is None and entry.state is ConfigEntryState.LOADED:
+            LOGGER.warning("Denon receiver disconnected, reloading config entry")
+            hass.config_entries.async_schedule_reload(entry.entry_id)
+
+    entry.async_on_unload(receiver.subscribe(_on_disconnect))
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: DenonRS232ConfigEntry) -> bool:
+    """Unload a config entry."""
+    unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+
+    if unload_ok:
+        await entry.runtime_data.disconnect()
+
+    return unload_ok

homeassistant/components/denon_rs232/config_flow.py

@@ -0,0 +1,119 @@
+"""Config flow for the Denon RS232 integration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from denon_rs232 import DenonReceiver
+from denon_rs232.models import MODELS
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_DEVICE, CONF_MODEL
+from homeassistant.helpers.selector import (
+    SelectOptionDict,
+    SelectSelector,
+    SelectSelectorConfig,
+    SelectSelectorMode,
+    SerialSelector,
+)
+
+from .const import DOMAIN, LOGGER
+
+CONF_MODEL_NAME = "model_name"
+
+# Build a flat list of (model_key, individual_name) pairs by splitting
+# grouped names like "AVR-3803 / AVC-3570 / AVR-2803" into separate entries.
+# Sorted alphabetically with "Other" at the bottom.
+MODEL_OPTIONS: list[tuple[str, str]] = sorted(
+    (
+        (_key, _name)
+        for _key, _model in MODELS.items()
+        if _key != "other"
+        for _name in _model.name.split(" / ")
+    ),
+    key=lambda x: x[1],
+)
+MODEL_OPTIONS.append(("other", "Other"))
+
+
+async def _async_attempt_connect(port: str, model_key: str) -> str | None:
+    """Attempt to connect to the receiver at the given port.
+
+    Returns None on success, error on failure.
+    """
+    model = MODELS[model_key]
+    receiver = DenonReceiver(port, model=model)
+
+    try:
+        await receiver.connect()
+    except (
+        # When the port contains invalid connection data
+        ValueError,
+        # If it is a remote port, and we cannot connect
+        ConnectionError,
+        OSError,
+        TimeoutError,
+    ):
+        return "cannot_connect"
+    except Exception:  # noqa: BLE001
+        LOGGER.exception("Unexpected exception")
+        return "unknown"
+    else:
+        await receiver.disconnect()
+        return None
+
+
+class DenonRS232ConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Denon RS232."""
+
+    VERSION = 1
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            model_key, _, model_name = user_input[CONF_MODEL].partition(":")
+            resolved_name = model_name if model_key != "other" else None
+
+            self._async_abort_entries_match({CONF_DEVICE: user_input[CONF_DEVICE]})
+            error = await _async_attempt_connect(user_input[CONF_DEVICE], model_key)
+            if not error:
+                return self.async_create_entry(
+                    title=resolved_name or "Denon Receiver",
+                    data={
+                        CONF_DEVICE: user_input[CONF_DEVICE],
+                        CONF_MODEL: model_key,
+                        CONF_MODEL_NAME: resolved_name,
+                    },
+                )
+            errors["base"] = error
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=self.add_suggested_values_to_schema(
+                vol.Schema(
+                    {
+                        vol.Required(CONF_MODEL): SelectSelector(
+                            SelectSelectorConfig(
+                                options=[
+                                    SelectOptionDict(
+                                        value=f"{key}:{name}",
+                                        label=name,
+                                    )
+                                    for key, name in MODEL_OPTIONS
+                                ],
+                                mode=SelectSelectorMode.DROPDOWN,
+                                translation_key="model",
+                            )
+                        ),
+                        vol.Required(CONF_DEVICE): SerialSelector(),
+                    }
+                ),
+                user_input or {},
+            ),
+            errors=errors,
+        )

homeassistant/components/denon_rs232/const.py

@@ -0,0 +1,12 @@
+"""Constants for the Denon RS232 integration."""
+
+import logging
+
+from denon_rs232 import DenonReceiver
+
+from homeassistant.config_entries import ConfigEntry
+
+LOGGER = logging.getLogger(__package__)
+DOMAIN = "denon_rs232"
+
+type DenonRS232ConfigEntry = ConfigEntry[DenonReceiver]

homeassistant/components/denon_rs232/manifest.json

@@ -0,0 +1,13 @@
+{
+  "domain": "denon_rs232",
+  "name": "Denon RS232",
+  "codeowners": ["@balloob"],
+  "config_flow": true,
+  "dependencies": ["usb"],
+  "documentation": "https://www.home-assistant.io/integrations/denon_rs232",
+  "integration_type": "hub",
+  "iot_class": "local_push",
+  "loggers": ["denon_rs232"],
+  "quality_scale": "bronze",
+  "requirements": ["denon-rs232==4.1.0"]
+}

homeassistant/components/denon_rs232/media_player.py

@@ -0,0 +1,235 @@
+"""Media player platform for the Denon RS232 integration."""
+
+from __future__ import annotations
+
+from typing import Literal, cast
+
+from denon_rs232 import (
+    MIN_VOLUME_DB,
+    VOLUME_DB_RANGE,
+    DenonReceiver,
+    InputSource,
+    MainPlayer,
+    ReceiverState,
+    ZonePlayer,
+)
+
+from homeassistant.components.media_player import (
+    MediaPlayerDeviceClass,
+    MediaPlayerEntity,
+    MediaPlayerEntityFeature,
+    MediaPlayerState,
+)
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .config_flow import CONF_MODEL_NAME
+from .const import DOMAIN, DenonRS232ConfigEntry
+
+INPUT_SOURCE_DENON_TO_HA: dict[InputSource, str] = {
+    InputSource.PHONO: "phono",
+    InputSource.CD: "cd",
+    InputSource.TUNER: "tuner",
+    InputSource.DVD: "dvd",
+    InputSource.VDP: "vdp",
+    InputSource.TV: "tv",
+    InputSource.DBS_SAT: "dbs_sat",
+    InputSource.VCR_1: "vcr_1",
+    InputSource.VCR_2: "vcr_2",
+    InputSource.VCR_3: "vcr_3",
+    InputSource.V_AUX: "v_aux",
+    InputSource.CDR_TAPE1: "cdr_tape1",
+    InputSource.MD_TAPE2: "md_tape2",
+    InputSource.HDP: "hdp",
+    InputSource.DVR: "dvr",
+    InputSource.TV_CBL: "tv_cbl",
+    InputSource.SAT: "sat",
+    InputSource.NET_USB: "net_usb",
+    InputSource.DOCK: "dock",
+    InputSource.IPOD: "ipod",
+    InputSource.BD: "bd",
+    InputSource.SAT_CBL: "sat_cbl",
+    InputSource.MPLAY: "mplay",
+    InputSource.GAME: "game",
+    InputSource.AUX1: "aux1",
+    InputSource.AUX2: "aux2",
+    InputSource.NET: "net",
+    InputSource.BT: "bt",
+    InputSource.USB_IPOD: "usb_ipod",
+    InputSource.EIGHT_K: "eight_k",
+    InputSource.PANDORA: "pandora",
+    InputSource.SIRIUSXM: "siriusxm",
+    InputSource.SPOTIFY: "spotify",
+    InputSource.FLICKR: "flickr",
+    InputSource.IRADIO: "iradio",
+    InputSource.SERVER: "server",
+    InputSource.FAVORITES: "favorites",
+    InputSource.LASTFM: "lastfm",
+    InputSource.XM: "xm",
+    InputSource.SIRIUS: "sirius",
+    InputSource.HDRADIO: "hdradio",
+    InputSource.DAB: "dab",
+}
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: DenonRS232ConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the Denon RS232 media player."""
+    receiver = config_entry.runtime_data
+    entities = [DenonRS232MediaPlayer(receiver, receiver.main, config_entry, "main")]
+
+    if receiver.zone_2.power is not None:
+        entities.append(
+            DenonRS232MediaPlayer(receiver, receiver.zone_2, config_entry, "zone_2")
+        )
+    if receiver.zone_3.power is not None:
+        entities.append(
+            DenonRS232MediaPlayer(receiver, receiver.zone_3, config_entry, "zone_3")
+        )
+
+    async_add_entities(entities)
+
+
+class DenonRS232MediaPlayer(MediaPlayerEntity):
+    """Representation of a Denon receiver controlled over RS232."""
+
+    _attr_device_class = MediaPlayerDeviceClass.RECEIVER
+    _attr_has_entity_name = True
+    _attr_translation_key = "receiver"
+    _attr_should_poll = False
+
+    _volume_min = MIN_VOLUME_DB
+    _volume_range = VOLUME_DB_RANGE
+
+    def __init__(
+        self,
+        receiver: DenonReceiver,
+        player: MainPlayer | ZonePlayer,
+        config_entry: DenonRS232ConfigEntry,
+        zone: Literal["main", "zone_2", "zone_3"],
+    ) -> None:
+        """Initialize the media player."""
+        self._receiver = receiver
+        self._player = player
+        self._is_main = zone == "main"
+
+        model = receiver.model
+        assert model is not None  # We always set this
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, config_entry.entry_id)},
+            manufacturer="Denon",
+            model_id=config_entry.data.get(CONF_MODEL_NAME),
+        )
+        self._attr_unique_id = f"{config_entry.entry_id}_{zone}"
+
+        self._attr_source_list = sorted(
+            INPUT_SOURCE_DENON_TO_HA[source] for source in model.input_sources
+        )
+        self._attr_supported_features = (
+            MediaPlayerEntityFeature.TURN_ON
+            | MediaPlayerEntityFeature.TURN_OFF
+            | MediaPlayerEntityFeature.VOLUME_SET
+            | MediaPlayerEntityFeature.VOLUME_STEP
+            | MediaPlayerEntityFeature.SELECT_SOURCE
+        )
+
+        if zone == "main":
+            self._attr_name = None
+            self._attr_supported_features |= MediaPlayerEntityFeature.VOLUME_MUTE
+        else:
+            self._attr_name = "Zone 2" if zone == "zone_2" else "Zone 3"
+
+        self._async_update_from_player()
+
+    async def async_added_to_hass(self) -> None:
+        """Subscribe to receiver state updates."""
+        self.async_on_remove(self._receiver.subscribe(self._async_on_state_update))
+
+    @callback
+    def _async_on_state_update(self, state: ReceiverState | None) -> None:
+        """Handle a state update from the receiver."""
+        if state is None:
+            self._attr_available = False
+        else:
+            self._attr_available = True
+            self._async_update_from_player()
+        self.async_write_ha_state()
+
+    @callback
+    def _async_update_from_player(self) -> None:
+        """Update entity attributes from the shared player object."""
+        if self._player.power is None:
+            self._attr_state = None
+        else:
+            self._attr_state = (
+                MediaPlayerState.ON if self._player.power else MediaPlayerState.OFF
+            )
+
+        source = self._player.input_source
+        self._attr_source = INPUT_SOURCE_DENON_TO_HA.get(source) if source else None
+
+        volume_min = self._player.volume_min
+        volume_max = self._player.volume_max
+        if volume_min is not None:
+            self._volume_min = volume_min
+
+            if volume_max is not None and volume_max > volume_min:
+                self._volume_range = volume_max - volume_min
+
+        volume = self._player.volume
+        if volume is not None:
+            self._attr_volume_level = (volume - self._volume_min) / self._volume_range
+        else:
+            self._attr_volume_level = None
+
+        if self._is_main:
+            self._attr_is_volume_muted = cast(MainPlayer, self._player).mute
+
+    async def async_turn_on(self) -> None:
+        """Turn the receiver on."""
+        await self._player.power_on()
+
+    async def async_turn_off(self) -> None:
+        """Turn the receiver off."""
+        await self._player.power_standby()
+
+    async def async_set_volume_level(self, volume: float) -> None:
+        """Set volume level, range 0..1."""
+        db = volume * self._volume_range + self._volume_min
+        await self._player.set_volume(db)
+
+    async def async_volume_up(self) -> None:
+        """Volume up."""
+        await self._player.volume_up()
+
+    async def async_volume_down(self) -> None:
+        """Volume down."""
+        await self._player.volume_down()
+
+    async def async_mute_volume(self, mute: bool) -> None:
+        """Mute or unmute."""
+        player = cast(MainPlayer, self._player)
+        if mute:
+            await player.mute_on()
+        else:
+            await player.mute_off()
+
+    async def async_select_source(self, source: str) -> None:
+        """Select input source."""
+        input_source = next(
+            (
+                input_source
+                for input_source, ha_source in INPUT_SOURCE_DENON_TO_HA.items()
+                if ha_source == source
+            ),
+            None,
+        )
+        if input_source is None:
+            raise HomeAssistantError("Invalid source")
+
+        await self._player.select_input_source(input_source)

homeassistant/components/denon_rs232/quality_scale.yaml

@@ -0,0 +1,64 @@
+rules:
+  # Bronze
+  action-setup: done
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions: done
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup: done
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions: todo
+  config-entry-unloading: done
+  docs-configuration-parameters: todo
+  docs-installation-parameters: todo
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: todo
+  parallel-updates: todo
+  reauthentication-flow: todo
+  test-coverage: todo
+
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info: todo
+  discovery: todo
+  docs-data-update: todo
+  docs-examples: todo
+  docs-known-limitations: todo
+  docs-supported-devices: todo
+  docs-supported-functions: todo
+  docs-troubleshooting: todo
+  docs-use-cases: todo
+  dynamic-devices:
+    status: exempt
+    comment: "The integration does not create dynamic devices."
+  entity-category: todo
+  entity-device-class: todo
+  entity-disabled-by-default: todo
+  entity-translations: todo
+  exception-translations: todo
+  icon-translations: todo
+  reconfiguration-flow: todo
+  repair-issues: todo
+  stale-devices:
+    status: exempt
+    comment: "The integration does not create devices that can become stale."
+
+  # Platinum
+  async-dependency: done
+  inject-websession: todo
+  strict-typing: todo

homeassistant/components/denon_rs232/strings.json

@@ -0,0 +1,84 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "step": {
+      "user": {
+        "data": {
+          "device": "[%key:common::config_flow::data::port%]",
+          "model": "Receiver model"
+        },
+        "data_description": {
+          "device": "Serial port path to connect to",
+          "model": "Determines available features"
+        }
+      }
+    }
+  },
+  "entity": {
+    "media_player": {
+      "receiver": {
+        "state_attributes": {
+          "source": {
+            "state": {
+              "aux1": "Aux 1",
+              "aux2": "Aux 2",
+              "bd": "BD Player",
+              "bt": "Bluetooth",
+              "cd": "CD",
+              "cdr_tape1": "CDR/Tape 1",
+              "dab": "DAB",
+              "dbs_sat": "DBS/Sat",
+              "dock": "Dock",
+              "dvd": "DVD",
+              "dvr": "DVR",
+              "eight_k": "8K",
+              "favorites": "Favorites",
+              "flickr": "Flickr",
+              "game": "Game",
+              "hdp": "HDP",
+              "hdradio": "HD Radio",
+              "ipod": "iPod",
+              "iradio": "Internet Radio",
+              "lastfm": "Last.fm",
+              "md_tape2": "MD/Tape 2",
+              "mplay": "Media Player",
+              "net": "HEOS Music",
+              "net_usb": "Network/USB",
+              "pandora": "Pandora",
+              "phono": "Phono",
+              "sat": "Sat",
+              "sat_cbl": "Satellite/Cable",
+              "server": "Server",
+              "sirius": "Sirius",
+              "siriusxm": "SiriusXM",
+              "spotify": "Spotify",
+              "tuner": "Tuner",
+              "tv": "TV Audio",
+              "tv_cbl": "TV/Cable",
+              "usb_ipod": "USB/iPod",
+              "v_aux": "V. Aux",
+              "vcr_1": "VCR 1",
+              "vcr_2": "VCR 2",
+              "vcr_3": "VCR 3",
+              "vdp": "VDP",
+              "xm": "XM"
+            }
+          }
+        }
+      }
+    }
+  },
+  "selector": {
+    "model": {
+      "options": {
+        "other": "Other"
+      }
+    }
+  }
+}

homeassistant/components/device_tracker/__init__.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from homeassistant.const import ATTR_GPS_ACCURACY, STATE_HOME  # noqa: F401
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.typing import ConfigType
-from homeassistant.loader import bind_hass
 
 from .config_entry import (  # noqa: F401
     ScannerEntity,
@@ -52,7 +51,6 @@ from .legacy import (  # noqa: F401
 )
 
 
-@bind_hass
 def is_on(hass: HomeAssistant, entity_id: str) -> bool:
     """Return the state if any or a specified device is home."""
     return hass.states.is_state(entity_id, STATE_HOME)

homeassistant/components/device_tracker/strings.json

@@ -1,7 +1,8 @@
 {
   "common": {
     "condition_behavior_name": "Condition passes if",
-    "trigger_behavior_name": "Trigger when"
+    "trigger_behavior_name": "Trigger when",
+    "trigger_for_name": "For at least"
   },
   "conditions": {
     "is_home": {
@@ -126,6 +127,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::device_tracker::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::device_tracker::common::trigger_for_name%]"
         }
       },
       "name": "Entered home"
@@ -135,6 +139,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::device_tracker::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::device_tracker::common::trigger_for_name%]"
         }
       },
       "name": "Left home"

homeassistant/components/device_tracker/triggers.yaml

@@ -13,6 +13,11 @@
             - last
             - any
           translation_key: trigger_behavior
+    for:
+      required: true
+      default: 00:00:00
+      selector:
+        duration:
 
 entered_home: *trigger_common
 left_home: *trigger_common

homeassistant/components/doods/manifest.json

@@ -6,5 +6,5 @@
   "iot_class": "local_polling",
   "loggers": ["pydoods"],
   "quality_scale": "legacy",
-  "requirements": ["pydoods==1.0.2", "Pillow==12.1.1"]
+  "requirements": ["pydoods==1.0.2", "Pillow==12.2.0"]
 }

homeassistant/components/door/strings.json

@@ -1,7 +1,8 @@
 {
   "common": {
     "condition_behavior_name": "Condition passes if",
-    "trigger_behavior_name": "Trigger when"
+    "trigger_behavior_name": "Trigger when",
+    "trigger_for_name": "For at least"
   },
   "conditions": {
     "is_closed": {
@@ -45,6 +46,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::door::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::door::common::trigger_for_name%]"
         }
       },
       "name": "Door closed"
@@ -54,6 +58,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::door::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::door::common::trigger_for_name%]"
         }
       },
       "name": "Door opened"

homeassistant/components/door/triggers.yaml

@@ -9,6 +9,11 @@
           - first
           - last
           - any
+  for:
+    required: true
+    default: 00:00:00
+    selector:
+      duration:
 
 closed:
   fields: *trigger_common_fields

homeassistant/components/dsmr/sensor.py

@@ -87,6 +87,7 @@ class MbusDeviceType(IntEnum):
     GAS = 3
     HEAT = 4
     WATER = 7
+    HEAT_COOL = 12
 
 
 SENSORS: tuple[DSMRSensorEntityDescription, ...] = (
@@ -571,6 +572,16 @@ SENSORS_MBUS_DEVICE_TYPE: dict[int, tuple[DSMRSensorEntityDescription, ...]] = {
             state_class=SensorStateClass.TOTAL_INCREASING,
         ),
     ),
+    MbusDeviceType.HEAT_COOL: (
+        DSMRSensorEntityDescription(
+            key="heat_reading",
+            translation_key="heat_meter_reading",
+            obis_reference="MBUS_METER_READING",
+            is_heat=True,
+            device_class=SensorDeviceClass.ENERGY,
+            state_class=SensorStateClass.TOTAL_INCREASING,
+        ),
+    ),
 }
 
 

homeassistant/components/duco/const.py

@@ -5,5 +5,5 @@ from datetime import timedelta
 from homeassistant.const import Platform
 
 DOMAIN = "duco"
-PLATFORMS = [Platform.FAN]
+PLATFORMS = [Platform.FAN, Platform.SENSOR]
 SCAN_INTERVAL = timedelta(seconds=30)

homeassistant/components/duco/diagnostics.py

@@ -0,0 +1,53 @@
+"""Diagnostics support for Duco."""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import asdict
+from typing import Any
+
+from homeassistant.components.diagnostics import async_redact_data
+from homeassistant.const import CONF_HOST
+from homeassistant.core import HomeAssistant
+
+from .coordinator import DucoConfigEntry
+
+TO_REDACT = {
+    CONF_HOST,
+    "mac",
+    "host_name",
+    "serial_board_box",
+    "serial_board_comm",
+    "serial_duco_box",
+    "serial_duco_comm",
+}
+
+
+async def async_get_config_entry_diagnostics(
+    hass: HomeAssistant, entry: DucoConfigEntry
+) -> dict[str, Any]:
+    """Return diagnostics for a config entry."""
+    coordinator = entry.runtime_data
+
+    board = asdict(coordinator.board_info)
+    board.pop("time")
+
+    lan_info, duco_diags, write_remaining = await asyncio.gather(
+        coordinator.client.async_get_lan_info(),
+        coordinator.client.async_get_diagnostics(),
+        coordinator.client.async_get_write_req_remaining(),
+    )
+
+    return async_redact_data(
+        {
+            "entry_data": entry.data,
+            "board_info": board,
+            "lan_info": asdict(lan_info),
+            "nodes": {
+                str(node_id): asdict(node) for node_id, node in coordinator.data.items()
+            },
+            "duco_diagnostics": [asdict(d) for d in duco_diags],
+            "write_requests_remaining": write_remaining,
+        },
+        TO_REDACT,
+    )

homeassistant/components/duco/icons.json

@@ -0,0 +1,15 @@
+{
+  "entity": {
+    "sensor": {
+      "iaq_co2": {
+        "default": "mdi:molecule-co2"
+      },
+      "iaq_rh": {
+        "default": "mdi:water-percent"
+      },
+      "ventilation_state": {
+        "default": "mdi:tune-variant"
+      }
+    }
+  }
+}

homeassistant/components/duco/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "local_polling",
   "loggers": ["duco"],
   "quality_scale": "bronze",
-  "requirements": ["python-duco-client==0.3.0"]
+  "requirements": ["python-duco-client==0.3.1"]
 }

homeassistant/components/duco/quality_scale.yaml

@@ -45,7 +45,7 @@ rules:
 
   # Gold
   devices: done
-  diagnostics: todo
+  diagnostics: done
   discovery-update-info:
     status: todo
     comment: >-
@@ -71,11 +71,11 @@ rules:
       Users can pair new modules (CO2 sensors, humidity sensors, zone valves)
       to their Duco box. Dynamic device support to be added in a follow-up PR.
   entity-category: todo
-  entity-device-class: todo
-  entity-disabled-by-default: todo
+  entity-device-class: done
+  entity-disabled-by-default: done
   entity-translations: done
-  exception-translations: todo
-  icon-translations: todo
+  exception-translations: done
+  icon-translations: done
   reconfiguration-flow: todo
   repair-issues: todo
   stale-devices:

homeassistant/components/duco/sensor.py

@@ -0,0 +1,119 @@
+"""Sensor platform for the Duco integration."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from duco.models import Node, NodeType, VentilationState
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+    SensorStateClass,
+)
+from homeassistant.const import CONCENTRATION_PARTS_PER_MILLION, PERCENTAGE
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import DucoConfigEntry, DucoCoordinator
+from .entity import DucoEntity
+
+PARALLEL_UPDATES = 0
+
+
+@dataclass(frozen=True, kw_only=True)
+class DucoSensorEntityDescription(SensorEntityDescription):
+    """Duco sensor entity description."""
+
+    value_fn: Callable[[Node], int | float | str | None]
+    node_types: tuple[NodeType, ...]
+
+
+SENSOR_DESCRIPTIONS: tuple[DucoSensorEntityDescription, ...] = (
+    DucoSensorEntityDescription(
+        key="ventilation_state",
+        translation_key="ventilation_state",
+        device_class=SensorDeviceClass.ENUM,
+        options=[s.lower() for s in VentilationState],
+        value_fn=lambda node: (
+            node.ventilation.state.lower() if node.ventilation else None
+        ),
+        node_types=(NodeType.BOX,),
+    ),
+    DucoSensorEntityDescription(
+        key="co2",
+        device_class=SensorDeviceClass.CO2,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=CONCENTRATION_PARTS_PER_MILLION,
+        value_fn=lambda node: node.sensor.co2 if node.sensor else None,
+        node_types=(NodeType.UCCO2,),
+    ),
+    DucoSensorEntityDescription(
+        key="iaq_co2",
+        translation_key="iaq_co2",
+        native_unit_of_measurement=PERCENTAGE,
+        state_class=SensorStateClass.MEASUREMENT,
+        entity_registry_enabled_default=False,
+        value_fn=lambda node: node.sensor.iaq_co2 if node.sensor else None,
+        node_types=(NodeType.UCCO2,),
+    ),
+    DucoSensorEntityDescription(
+        key="humidity",
+        device_class=SensorDeviceClass.HUMIDITY,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=PERCENTAGE,
+        value_fn=lambda node: node.sensor.rh if node.sensor else None,
+        node_types=(NodeType.BSRH,),
+    ),
+    DucoSensorEntityDescription(
+        key="iaq_rh",
+        translation_key="iaq_rh",
+        native_unit_of_measurement=PERCENTAGE,
+        state_class=SensorStateClass.MEASUREMENT,
+        entity_registry_enabled_default=False,
+        value_fn=lambda node: node.sensor.iaq_rh if node.sensor else None,
+        node_types=(NodeType.BSRH,),
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: DucoConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Duco sensor entities."""
+    coordinator = entry.runtime_data
+
+    async_add_entities(
+        DucoSensorEntity(coordinator, node, description)
+        for node in coordinator.data.values()
+        for description in SENSOR_DESCRIPTIONS
+        if node.general.node_type in description.node_types
+    )
+
+
+class DucoSensorEntity(DucoEntity, SensorEntity):
+    """Sensor entity for a Duco node."""
+
+    entity_description: DucoSensorEntityDescription
+
+    def __init__(
+        self,
+        coordinator: DucoCoordinator,
+        node: Node,
+        description: DucoSensorEntityDescription,
+    ) -> None:
+        """Initialize the sensor entity."""
+        super().__init__(coordinator, node)
+        self.entity_description = description
+        self._attr_unique_id = (
+            f"{coordinator.config_entry.unique_id}_{node.node_id}_{description.key}"
+        )
+
+    @property
+    def native_value(self) -> int | float | str | None:
+        """Return the sensor value."""
+        return self.entity_description.value_fn(self._node)

homeassistant/components/duco/strings.json

@@ -29,6 +29,36 @@
           }
         }
       }
+    },
+    "sensor": {
+      "iaq_co2": {
+        "name": "CO2 air quality index"
+      },
+      "iaq_rh": {
+        "name": "Humidity air quality index"
+      },
+      "ventilation_state": {
+        "name": "Ventilation state",
+        "state": {
+          "aut1": "Automatic boost (15 min)",
+          "aut2": "Automatic boost (30 min)",
+          "aut3": "Automatic boost (45 min)",
+          "auto": "Automatic",
+          "cnt1": "Continuous low speed",
+          "cnt2": "Continuous medium speed",
+          "cnt3": "Continuous high speed",
+          "empt": "Empty house",
+          "man1": "Manual low speed (15 min)",
+          "man1x2": "Manual low speed (30 min)",
+          "man1x3": "Manual low speed (45 min)",
+          "man2": "Manual medium speed (15 min)",
+          "man2x2": "Manual medium speed (30 min)",
+          "man2x3": "Manual medium speed (45 min)",
+          "man3": "Manual high speed (15 min)",
+          "man3x2": "Manual high speed (30 min)",
+          "man3x3": "Manual high speed (45 min)"
+        }
+      }
     }
   },
   "exceptions": {

homeassistant/components/enphase_envoy/manifest.json

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

homeassistant/components/eurotronic_cometblue/__init__.py

@@ -18,6 +18,7 @@ from .coordinator import CometBlueConfigEntry, CometBlueDataUpdateCoordinator
 PLATFORMS: list[Platform] = [
     Platform.BUTTON,
     Platform.CLIMATE,
+    Platform.SENSOR,
 ]
 
 

homeassistant/components/eurotronic_cometblue/coordinator.py

@@ -32,6 +32,7 @@ class CometBlueCoordinatorData:
 
     temperatures: dict[str, float | int] = field(default_factory=dict)
     holiday: dict = field(default_factory=dict)
+    battery: int | None = None
 
 
 class CometBlueDataUpdateCoordinator(DataUpdateCoordinator[CometBlueCoordinatorData]):
@@ -53,6 +54,7 @@ class CometBlueDataUpdateCoordinator(DataUpdateCoordinator[CometBlueCoordinatorD
         )
         self.device = cometblue
         self.address = cometblue.client.address
+        self.data = CometBlueCoordinatorData()
 
     async def send_command(
         self,
@@ -64,11 +66,11 @@ class CometBlueDataUpdateCoordinator(DataUpdateCoordinator[CometBlueCoordinatorD
         LOGGER.debug("Updating device %s with '%s'", self.name, payload)
         retry_count = 0
         while retry_count < MAX_RETRIES:
+            retry_count += 1
             try:
                 async with self.device:
                     return await function(**payload)
             except (InvalidByteValueError, TimeoutError, BleakError) as ex:
-                retry_count += 1
                 if retry_count >= MAX_RETRIES:
                     raise HomeAssistantError(
                         f"Error sending command to '{self.name}': {ex}"
@@ -88,20 +90,23 @@ class CometBlueDataUpdateCoordinator(DataUpdateCoordinator[CometBlueCoordinatorD
 
     async def _async_update_data(self) -> CometBlueCoordinatorData:
         """Poll the device."""
-        data: CometBlueCoordinatorData = CometBlueCoordinatorData()
+        data = CometBlueCoordinatorData()
 
         retry_count = 0
 
         while retry_count < MAX_RETRIES and not data.temperatures:
             try:
+                retry_count += 1
                 async with self.device:
                     # temperatures are required and must trigger a retry if not available
                     if not data.temperatures:
                         data.temperatures = await self.device.get_temperature_async()
-                    # holiday is optional and should not trigger a retry
+                    # holiday and battery are optional and should not trigger a retry
                     try:
                         if not data.holiday:
                             data.holiday = await self.device.get_holiday_async(1) or {}
+                        if not data.battery:
+                            data.battery = await self.device.get_battery_async()
                     except InvalidByteValueError as ex:
                         LOGGER.warning(
                             "Failed to retrieve optional data for %s: %s (%s)",
@@ -110,7 +115,6 @@ class CometBlueDataUpdateCoordinator(DataUpdateCoordinator[CometBlueCoordinatorD
                             ex,
                         )
             except (InvalidByteValueError, TimeoutError, BleakError) as ex:
-                retry_count += 1
                 if retry_count >= MAX_RETRIES:
                     raise UpdateFailed(
                         f"Error retrieving data: {ex}", retry_after=30
@@ -128,5 +132,9 @@ class CometBlueDataUpdateCoordinator(DataUpdateCoordinator[CometBlueCoordinatorD
                 ) from ex
 
         # If one value was not retrieved correctly, keep the old value
+        if not data.holiday:
+            data.holiday = self.data.holiday
+        if not data.battery:
+            data.battery = self.data.battery
         LOGGER.debug("Received data for %s: %s", self.name, data)
         return data

homeassistant/components/eurotronic_cometblue/sensor.py

@@ -0,0 +1,53 @@
+"""Comet Blue sensor integration."""
+
+from __future__ import annotations
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+)
+from homeassistant.const import PERCENTAGE
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import CometBlueConfigEntry, CometBlueDataUpdateCoordinator
+from .entity import CometBlueBluetoothEntity
+
+PARALLEL_UPDATES = 0
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: CometBlueConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the client entities."""
+
+    coordinator = entry.runtime_data
+    entities = [CometBlueBatterySensorEntity(coordinator)]
+
+    async_add_entities(entities)
+
+
+class CometBlueBatterySensorEntity(CometBlueBluetoothEntity, SensorEntity):
+    """Representation of a sensor."""
+
+    def __init__(
+        self,
+        coordinator: CometBlueDataUpdateCoordinator,
+    ) -> None:
+        """Initialize CometBlueSensorEntity."""
+
+        super().__init__(coordinator)
+        self.entity_description = SensorEntityDescription(
+            key="battery",
+            device_class=SensorDeviceClass.BATTERY,
+            native_unit_of_measurement=PERCENTAGE,
+        )
+        self._attr_unique_id = f"{coordinator.address}-{self.entity_description.key}"
+
+    @property
+    def native_value(self) -> float | None:
+        """Return the entity value to represent the entity state."""
+        return self.coordinator.data.battery

homeassistant/components/evohome/climate.py

@@ -39,9 +39,17 @@ from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 from homeassistant.util import dt as dt_util
 
-from .const import ATTR_DURATION, ATTR_PERIOD, DOMAIN, EVOHOME_DATA, EvoService
+from .const import (
+    ATTR_DURATION,
+    ATTR_PERIOD,
+    DOMAIN,
+    EVOHOME_DATA,
+    RESET_BREAKS_IN_HA_VERSION,
+    EvoService,
+)
 from .coordinator import EvoDataUpdateCoordinator
 from .entity import EvoChild, EvoEntity, is_valid_zone
+from .helpers import async_create_deprecation_issue_once
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -185,6 +193,11 @@ class EvoZone(EvoChild, EvoClimateEntity):
 
     async def async_clear_zone_override(self) -> None:
         """Clear the zone override (if any) and return to following its schedule."""
+        async_create_deprecation_issue_once(
+            self.hass,
+            "deprecated_clear_zone_override_service",
+            RESET_BREAKS_IN_HA_VERSION,
+        )
         await self.coordinator.call_client_api(self._evo_device.reset())
 
     async def async_set_zone_override(
@@ -447,6 +460,13 @@ class EvoController(EvoClimateEntity):
 
     async def async_set_preset_mode(self, preset_mode: str) -> None:
         """Set the preset mode; if None, then revert to 'Auto' mode."""
+        if preset_mode == PRESET_RESET:
+            async_create_deprecation_issue_once(
+                self.hass,
+                "deprecated_preset_reset",
+                RESET_BREAKS_IN_HA_VERSION,
+            )
+
         await self._set_tcs_mode(HA_PRESET_TO_TCS.get(preset_mode, EvoSystemMode.AUTO))
 
     @callback

homeassistant/components/evohome/const.py

@@ -22,11 +22,13 @@ CONF_LOCATION_IDX: Final = "location_idx"
 SCAN_INTERVAL_DEFAULT: Final = timedelta(seconds=300)
 SCAN_INTERVAL_MINIMUM: Final = timedelta(seconds=60)
 
-ATTR_PERIOD: Final = "period"  # number of days
 ATTR_DURATION: Final = "duration"  # number of minutes, <24h
-
+ATTR_PERIOD: Final = "period"  # number of days
 ATTR_SETPOINT: Final = "setpoint"
 
+# Support for the reset service calls/presets is being deprecated
+RESET_BREAKS_IN_HA_VERSION: Final = "2026.11.0"
+
 
 @unique
 class EvoService(StrEnum):
@@ -37,3 +39,4 @@ class EvoService(StrEnum):
     RESET_SYSTEM = "reset_system"
     SET_ZONE_OVERRIDE = "set_zone_override"
     CLEAR_ZONE_OVERRIDE = "clear_zone_override"
+    SET_DHW_OVERRIDE = "set_dhw_override"

homeassistant/components/evohome/helpers.py

@@ -0,0 +1,36 @@
+"""Helpers for the Evohome integration."""
+
+from __future__ import annotations
+
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import issue_registry as ir
+
+from .const import DOMAIN
+
+
+@callback
+def async_create_deprecation_issue_once(
+    hass: HomeAssistant,
+    issue_id: str,
+    breaks_in_ha_version: str,
+    translation_key: str | None = None,
+    translation_placeholders: dict[str, str] | None = None,
+) -> None:
+    """Create or update a deprecation issue entry."""
+
+    placeholders = {
+        **(translation_placeholders or {}),
+        "breaks_in_ha_version": breaks_in_ha_version,
+    }
+
+    ir.async_get(hass).async_get_or_create(
+        DOMAIN,
+        issue_id,
+        breaks_in_ha_version=breaks_in_ha_version,
+        is_fixable=False,
+        is_persistent=True,
+        issue_domain=DOMAIN,
+        severity=ir.IssueSeverity.WARNING,
+        translation_key=translation_key or issue_id,
+        translation_placeholders=placeholders,
+    )

homeassistant/components/evohome/icons.json

@@ -22,6 +22,9 @@
     "reset_system": {
       "service": "mdi:refresh"
     },
+    "set_dhw_override": {
+      "service": "mdi:water-heater"
+    },
     "set_system_mode": {
       "service": "mdi:pencil"
     },

homeassistant/components/evohome/services.py

@@ -14,15 +14,24 @@ from evohomeasync2.schemas.const import (
 import voluptuous as vol
 
 from homeassistant.components.climate import DOMAIN as CLIMATE_DOMAIN
-from homeassistant.const import ATTR_MODE
+from homeassistant.components.water_heater import DOMAIN as WATER_HEATER_DOMAIN
+from homeassistant.const import ATTR_MODE, ATTR_STATE
 from homeassistant.core import HomeAssistant, ServiceCall, callback
 from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import config_validation as cv, service
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 from homeassistant.helpers.service import verify_domain_control
 
-from .const import ATTR_DURATION, ATTR_PERIOD, ATTR_SETPOINT, DOMAIN, EvoService
+from .const import (
+    ATTR_DURATION,
+    ATTR_PERIOD,
+    ATTR_SETPOINT,
+    DOMAIN,
+    RESET_BREAKS_IN_HA_VERSION,
+    EvoService,
+)
 from .coordinator import EvoDataUpdateCoordinator
+from .helpers import async_create_deprecation_issue_once
 
 # System service schemas (registered as domain services)
 SET_SYSTEM_MODE_SCHEMA: Final[dict[str | vol.Marker, Any]] = {
@@ -49,6 +58,15 @@ SET_ZONE_OVERRIDE_SCHEMA: Final[dict[str | vol.Marker, Any]] = {
     ),
 }
 
+# DHW service schemas (registered as entity services)
+SET_DHW_OVERRIDE_SCHEMA: Final[dict[str | vol.Marker, Any]] = {
+    vol.Required(ATTR_STATE): cv.boolean,
+    vol.Optional(ATTR_DURATION): vol.All(
+        cv.time_period,
+        vol.Range(min=timedelta(days=0), max=timedelta(days=1)),
+    ),
+}
+
 
 def _register_zone_entity_services(hass: HomeAssistant) -> None:
     """Register entity-level services for zones."""
@@ -71,6 +89,19 @@ def _register_zone_entity_services(hass: HomeAssistant) -> None:
     )
 
 
+def _register_dhw_entity_services(hass: HomeAssistant) -> None:
+    """Register entity-level services for DHW zones."""
+
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        EvoService.SET_DHW_OVERRIDE,
+        entity_domain=WATER_HEATER_DOMAIN,
+        schema=SET_DHW_OVERRIDE_SCHEMA,
+        func="async_set_dhw_override",
+    )
+
+
 def _validate_set_system_mode_params(tcs: ControlSystem, data: dict[str, Any]) -> None:
     """Validate that a set_system_mode service call is properly formed."""
 
@@ -135,6 +166,13 @@ def setup_service_functions(
         # via that service call may be able to emulate the reset even if the system
         # doesn't support AutoWithReset natively
 
+        if call.service == EvoService.RESET_SYSTEM:
+            async_create_deprecation_issue_once(
+                hass,
+                "deprecated_reset_system_service",
+                RESET_BREAKS_IN_HA_VERSION,
+            )
+
         if call.service == EvoService.SET_SYSTEM_MODE:
             _validate_set_system_mode_params(coordinator.tcs, call.data)
 
@@ -156,3 +194,4 @@ def setup_service_functions(
     )
 
     _register_zone_entity_services(hass)
+    _register_dhw_entity_services(hass)

homeassistant/components/evohome/services.yaml

@@ -58,3 +58,19 @@ clear_zone_override:
       domain: climate
       supported_features:
         - climate.ClimateEntityFeature.TARGET_TEMPERATURE
+
+set_dhw_override:
+  target:
+    entity:
+      integration: evohome
+      domain: water_heater
+  fields:
+    state:
+      required: true
+      selector:
+        boolean:
+    duration:
+      example: "02:15"
+      selector:
+        duration:
+          enable_second: false

homeassistant/components/evohome/strings.json

@@ -19,9 +19,23 @@
       "message": "Only zones support the `{service}` action"
     }
   },
+  "issues": {
+    "deprecated_clear_zone_override_service": {
+      "description": "Using the `clear_zone_override` action is deprecated and will stop working in Home Assistant {breaks_in_ha_version}. Use the zone's Reset button instead.",
+      "title": "Evohome clear zone override action is deprecated"
+    },
+    "deprecated_preset_reset": {
+      "description": "Using the `Reset` preset on an Evohome controller is deprecated and will stop working in Home Assistant {breaks_in_ha_version}. Use the system's Reset button instead.",
+      "title": "Evohome Reset preset is deprecated"
+    },
+    "deprecated_reset_system_service": {
+      "description": "Using the `reset_system` action is deprecated and will stop working in Home Assistant {breaks_in_ha_version}. Use the system's Reset button instead.",
+      "title": "Evohome reset system action is deprecated"
+    }
+  },
   "services": {
     "clear_zone_override": {
-      "description": "Sets a zone to follow its schedule.",
+      "description": "Sets a zone to follow its schedule (deprecated).",
       "name": "Clear zone override"
     },
     "refresh_system": {
@@ -29,11 +43,25 @@
       "name": "Refresh system"
     },
     "reset_system": {
-      "description": "Sets the system to `Auto` mode and resets all the zones to follow their schedules. Not all Evohome systems support this feature (i.e. `AutoWithReset` mode).",
+      "description": "Sets a system's mode to `Auto` mode and resets all its zones to follow their schedules (deprecated). Some older systems may not support this feature.",
       "name": "Reset system"
     },
+    "set_dhw_override": {
+      "description": "Overrides a DHW's state, either indefinitely or for a specified duration, after which it will revert to following its schedule.",
+      "fields": {
+        "duration": {
+          "description": "The DHW will revert to its schedule after this time. If 0 the change is until the next scheduled setpoint.",
+          "name": "Duration"
+        },
+        "state": {
+          "description": "The DHW state: True (on: heat the water up to the setpoint) or False (off).",
+          "name": "State"
+        }
+      },
+      "name": "Set DHW override"
+    },
     "set_system_mode": {
-      "description": "Sets the system mode, either indefinitely, or for a specified period of time, after which it will revert to `Auto`. Not all systems support all modes.",
+      "description": "Sets a system's mode, either indefinitely or until a specified end time, after which it will revert to `Auto`. Not all systems support all modes.",
       "fields": {
         "duration": {
           "description": "The duration in hours; used only with `AutoWithEco` mode (up to 24 hours).",
@@ -51,7 +79,7 @@
       "name": "Set system mode"
     },
     "set_zone_override": {
-      "description": "Overrides the zone's setpoint, either indefinitely, or for a specified period of time, after which it will revert to following its schedule.",
+      "description": "Overrides a zone's setpoint, either indefinitely or for a specified duration, after which it will revert to following its schedule.",
       "fields": {
         "duration": {
           "description": "The zone will revert to its schedule after this time. If 0 the change is until the next scheduled setpoint.",

homeassistant/components/evohome/water_heater.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from datetime import timedelta
 import logging
 from typing import Any
 
@@ -97,6 +98,28 @@ class EvoDHW(EvoChild, WaterHeaterEntity):
             PRECISION_TENTHS if coordinator.client_v1 else PRECISION_WHOLE
         )
 
+    async def async_set_dhw_override(
+        self, state: bool, duration: timedelta | None = None
+    ) -> None:
+        """Override the DHW zone's on/off state, either permanently or for a duration."""
+
+        if duration is None:
+            until = None  # indefinitely, aka permanent override
+        elif duration.total_seconds() == 0:
+            await self._update_schedule()
+            until = self.setpoints.get("next_sp_from")
+        else:
+            until = dt_util.now() + duration
+
+        until = dt_util.as_utc(until) if until else None
+
+        if state:
+            await self.coordinator.call_client_api(self._evo_device.set_on(until=until))
+        else:
+            await self.coordinator.call_client_api(
+                self._evo_device.set_off(until=until)
+            )
+
     @property
     def current_operation(self) -> str | None:
         """Return the current operating mode (Auto, On, or Off)."""

homeassistant/components/fan/__init__.py

@@ -25,7 +25,6 @@ from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity import ToggleEntity, ToggleEntityDescription
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.typing import ConfigType
-from homeassistant.loader import bind_hass
 from homeassistant.util.hass_dict import HassKey
 from homeassistant.util.percentage import (
     percentage_to_ranged_value,
@@ -88,7 +87,6 @@ class NotValidPresetModeError(ServiceValidationError):
         )
 
 
-@bind_hass
 def is_on(hass: HomeAssistant, entity_id: str) -> bool:
     """Return if the fans are on based on the statemachine."""
     entity = hass.states.get(entity_id)

homeassistant/components/fan/strings.json

@@ -1,7 +1,8 @@
 {
   "common": {
     "condition_behavior_name": "Condition passes if",
-    "trigger_behavior_name": "Trigger when"
+    "trigger_behavior_name": "Trigger when",
+    "trigger_for_name": "For at least"
   },
   "conditions": {
     "is_off": {
@@ -196,6 +197,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::fan::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::fan::common::trigger_for_name%]"
         }
       },
       "name": "Fan turned off"
@@ -205,6 +209,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::fan::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::fan::common::trigger_for_name%]"
         }
       },
       "name": "Fan turned on"

homeassistant/components/fan/triggers.yaml

@@ -13,6 +13,11 @@
             - last
             - any
           translation_key: trigger_behavior
+    for:
+      required: true
+      default: 00:00:00
+      selector:
+        duration:
 
 turned_on: *trigger_common
 turned_off: *trigger_common

homeassistant/components/ffmpeg/__init__.py

@@ -20,7 +20,6 @@ from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.typing import ConfigType
-from homeassistant.loader import bind_hass
 from homeassistant.util.system_info import is_official_image
 
 from .const import (
@@ -71,7 +70,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     return True
 
 
-@bind_hass
 def get_ffmpeg_manager(hass: HomeAssistant) -> FFmpegManager:
     """Return the FFmpegManager."""
     if DATA_FFMPEG not in hass.data:
@@ -79,7 +77,6 @@ def get_ffmpeg_manager(hass: HomeAssistant) -> FFmpegManager:
     return hass.data[DATA_FFMPEG]
 
 
-@bind_hass
 async def async_get_image(
     hass: HomeAssistant,
     input_source: str,

homeassistant/components/freshr/coordinator.py

@@ -6,7 +6,7 @@ from datetime import timedelta
 from aiohttp import ClientError
 from pyfreshr import FreshrClient
 from pyfreshr.exceptions import ApiResponseError, LoginError
-from pyfreshr.models import DeviceReadings, DeviceSummary
+from pyfreshr.models import DeviceReadings, DeviceSummary, DeviceType
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
@@ -18,6 +18,12 @@ from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, Upda
 
 from .const import DOMAIN, LOGGER
 
+_DEVICE_TYPE_NAMES: dict[DeviceType, str] = {
+    DeviceType.FRESH_R: "Fresh-r",
+    DeviceType.FORWARD: "Fresh-r Forward",
+    DeviceType.MONITOR: "Fresh-r Monitor",
+}
+
 DEVICES_SCAN_INTERVAL = timedelta(hours=1)
 READINGS_SCAN_INTERVAL = timedelta(minutes=10)
 
@@ -110,6 +116,12 @@ class FreshrReadingsCoordinator(DataUpdateCoordinator[DeviceReadings]):
         )
         self._device = device
         self._client = client
+        self.device_info = dr.DeviceInfo(
+            identifiers={(DOMAIN, device.id)},
+            name=_DEVICE_TYPE_NAMES.get(device.device_type, "Fresh-r"),
+            serial_number=device.id,
+            manufacturer="Fresh-r",
+        )
 
     @property
     def device_id(self) -> str:

homeassistant/components/freshr/entity.py

@@ -0,0 +1,18 @@
+"""Base entity for the Fresh-r integration."""
+
+from __future__ import annotations
+
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .coordinator import FreshrReadingsCoordinator
+
+
+class FreshrEntity(CoordinatorEntity[FreshrReadingsCoordinator]):
+    """Base class for Fresh-r entities."""
+
+    _attr_has_entity_name = True
+
+    def __init__(self, coordinator: FreshrReadingsCoordinator) -> None:
+        """Initialize the Fresh-r entity."""
+        super().__init__(coordinator)
+        self._attr_device_info = coordinator.device_info

homeassistant/components/freshr/manifest.json

@@ -6,6 +6,6 @@
   "documentation": "https://www.home-assistant.io/integrations/freshr",
   "integration_type": "hub",
   "iot_class": "cloud_polling",
-  "quality_scale": "silver",
+  "quality_scale": "platinum",
   "requirements": ["pyfreshr==1.2.0"]
 }

homeassistant/components/freshr/sensor.py

@@ -21,12 +21,10 @@ from homeassistant.const import (
     UnitOfVolumeFlowRate,
 )
 from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import DOMAIN
 from .coordinator import FreshrConfigEntry, FreshrReadingsCoordinator
+from .entity import FreshrEntity
 
 PARALLEL_UPDATES = 0
 
@@ -93,12 +91,6 @@ _TEMP = FreshrSensorEntityDescription(
     value_fn=lambda r: r.temp,
 )
 
-_DEVICE_TYPE_NAMES: dict[DeviceType, str] = {
-    DeviceType.FRESH_R: "Fresh-r",
-    DeviceType.FORWARD: "Fresh-r Forward",
-    DeviceType.MONITOR: "Fresh-r Monitor",
-}
-
 SENSOR_TYPES: dict[DeviceType, tuple[FreshrSensorEntityDescription, ...]] = {
     DeviceType.FRESH_R: (_T1, _T2, _CO2, _HUM, _FLOW, _DP),
     DeviceType.FORWARD: (_T1, _T2, _CO2, _HUM, _FLOW, _DP, _TEMP),
@@ -131,17 +123,10 @@ async def async_setup_entry(
             descriptions = SENSOR_TYPES.get(
                 device.device_type, SENSOR_TYPES[DeviceType.FRESH_R]
             )
-            device_info = DeviceInfo(
-                identifiers={(DOMAIN, device_id)},
-                name=_DEVICE_TYPE_NAMES.get(device.device_type, "Fresh-r"),
-                serial_number=device_id,
-                manufacturer="Fresh-r",
-            )
             entities.extend(
                 FreshrSensor(
                     config_entry.runtime_data.readings[device_id],
                     description,
-                    device_info,
                 )
                 for description in descriptions
             )
@@ -151,22 +136,19 @@ async def async_setup_entry(
     config_entry.async_on_unload(coordinator.async_add_listener(_check_devices))
 
 
-class FreshrSensor(CoordinatorEntity[FreshrReadingsCoordinator], SensorEntity):
+class FreshrSensor(FreshrEntity, SensorEntity):
     """Representation of a Fresh-r sensor."""
 
-    _attr_has_entity_name = True
     entity_description: FreshrSensorEntityDescription
 
     def __init__(
         self,
         coordinator: FreshrReadingsCoordinator,
         description: FreshrSensorEntityDescription,
-        device_info: DeviceInfo,
     ) -> None:
         """Initialize the sensor."""
         super().__init__(coordinator)
         self.entity_description = description
-        self._attr_device_info = device_info
         self._attr_unique_id = f"{coordinator.device_id}_{description.key}"
 
     @property

homeassistant/components/fritz/manifest.json

@@ -9,7 +9,7 @@
   "iot_class": "local_polling",
   "loggers": ["fritzconnection"],
   "quality_scale": "gold",
-  "requirements": ["fritzconnection[qr]==1.15.1", "xmltodict==1.0.2"],
+  "requirements": ["fritzconnection[qr]==1.15.1", "xmltodict==1.0.4"],
   "ssdp": [
     {
       "st": "urn:schemas-upnp-org:device:fritzbox:1"

homeassistant/components/frontend/__init__.py

@@ -34,7 +34,7 @@ from homeassistant.helpers.json import json_dumps_sorted
 from homeassistant.helpers.storage import Store
 from homeassistant.helpers.translation import async_get_translations
 from homeassistant.helpers.typing import ConfigType
-from homeassistant.loader import async_get_integration, bind_hass
+from homeassistant.loader import async_get_integration
 from homeassistant.util.hass_dict import HassKey
 
 from .pr_download import download_pr_artifact
@@ -354,7 +354,6 @@ class Panel:
         return response
 
 
-@bind_hass
 @callback
 def async_register_built_in_panel(
     hass: HomeAssistant,
@@ -393,7 +392,6 @@ def async_register_built_in_panel(
     hass.bus.async_fire(EVENT_PANELS_UPDATED)
 
 
-@bind_hass
 @callback
 def async_remove_panel(
     hass: HomeAssistant, frontend_url_path: str, *, warn_if_unknown: bool = True

homeassistant/components/garage_door/strings.json

@@ -1,7 +1,8 @@
 {
   "common": {
     "condition_behavior_name": "Condition passes if",
-    "trigger_behavior_name": "Trigger when"
+    "trigger_behavior_name": "Trigger when",
+    "trigger_for_name": "For at least"
   },
   "conditions": {
     "is_closed": {
@@ -45,6 +46,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::garage_door::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::garage_door::common::trigger_for_name%]"
         }
       },
       "name": "Garage door closed"
@@ -54,6 +58,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::garage_door::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::garage_door::common::trigger_for_name%]"
         }
       },
       "name": "Garage door opened"

homeassistant/components/garage_door/triggers.yaml

@@ -9,6 +9,11 @@
           - first
           - last
           - any
+  for:
+    required: true
+    default: 00:00:00
+    selector:
+      duration:
 
 closed:
   fields: *trigger_common_fields

homeassistant/components/gardena_bluetooth/__init__.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import asyncio
 import logging
 
 from bleak.backends.device import BLEDevice
@@ -13,7 +12,8 @@ from gardena_bluetooth.exceptions import (
     CharacteristicNotFound,
     CommunicationFailure,
 )
-from gardena_bluetooth.parse import CharacteristicTime
+from gardena_bluetooth.parse import CharacteristicTime, ProductType
+from gardena_bluetooth.scan import async_get_manufacturer_data
 
 from homeassistant.components import bluetooth
 from homeassistant.const import CONF_ADDRESS, Platform
@@ -29,7 +29,6 @@ from .coordinator import (
     GardenaBluetoothConfigEntry,
     GardenaBluetoothCoordinator,
 )
-from .util import async_get_product_type
 
 PLATFORMS: list[Platform] = [
     Platform.BINARY_SENSOR,
@@ -76,11 +75,10 @@ async def async_setup_entry(
 
     address = entry.data[CONF_ADDRESS]
 
-    try:
-        async with asyncio.timeout(TIMEOUT):
-            product_type = await async_get_product_type(hass, address)
-    except TimeoutError as exception:
-        raise ConfigEntryNotReady("Unable to find product type") from exception
+    mfg_data = await async_get_manufacturer_data({address})
+    product_type = mfg_data[address].product_type
+    if product_type == ProductType.UNKNOWN:
+        raise ConfigEntryNotReady("Unable to find product type")
 
     client = Client(get_connection(hass, address), product_type)
     try:

homeassistant/components/gardena_bluetooth/config_flow.py

@@ -9,6 +9,7 @@ from gardena_bluetooth.client import Client
 from gardena_bluetooth.const import PRODUCT_NAMES, DeviceInformation, ScanService
 from gardena_bluetooth.exceptions import CharacteristicNotFound, CommunicationFailure
 from gardena_bluetooth.parse import ManufacturerData, ProductType
+from gardena_bluetooth.scan import async_get_manufacturer_data
 import voluptuous as vol
 
 from homeassistant.components.bluetooth import (
@@ -24,41 +25,27 @@ from .const import DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
+_SUPPORTED_PRODUCT_TYPES = {
+    ProductType.PUMP,
+    ProductType.VALVE,
+    ProductType.WATER_COMPUTER,
+    ProductType.AUTOMATS,
+    ProductType.PRESSURE_TANKS,
+    ProductType.AQUA_CONTOURS,
+}
+
 
 def _is_supported(discovery_info: BluetoothServiceInfo):
     """Check if device is supported."""
     if ScanService not in discovery_info.service_uuids:
         return False
 
-    if not (data := discovery_info.manufacturer_data.get(ManufacturerData.company)):
+    if discovery_info.manufacturer_data.get(ManufacturerData.company) is None:
         _LOGGER.debug("Missing manufacturer data: %s", discovery_info)
         return False
-
-    manufacturer_data = ManufacturerData.decode(data)
-    product_type = ProductType.from_manufacturer_data(manufacturer_data)
-
-    if product_type not in (
-        ProductType.PUMP,
-        ProductType.VALVE,
-        ProductType.WATER_COMPUTER,
-        ProductType.AUTOMATS,
-        ProductType.PRESSURE_TANKS,
-        ProductType.AQUA_CONTOURS,
-    ):
-        _LOGGER.debug("Unsupported device: %s", manufacturer_data)
-        return False
-
     return True
 
 
-def _get_name(discovery_info: BluetoothServiceInfo):
-    data = discovery_info.manufacturer_data[ManufacturerData.company]
-    manufacturer_data = ManufacturerData.decode(data)
-    product_type = ProductType.from_manufacturer_data(manufacturer_data)
-
-    return PRODUCT_NAMES.get(product_type, "Gardena Device")
-
-
 class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Gardena Bluetooth."""
 
@@ -90,11 +77,13 @@ class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
     ) -> ConfigFlowResult:
         """Handle the bluetooth discovery step."""
         _LOGGER.debug("Discovered device: %s", discovery_info)
-        if not _is_supported(discovery_info):
+        data = await async_get_manufacturer_data({discovery_info.address})
+        product_type = data[discovery_info.address].product_type
+        if product_type not in _SUPPORTED_PRODUCT_TYPES:
             return self.async_abort(reason="no_devices_found")
 
         self.address = discovery_info.address
-        self.devices = {discovery_info.address: _get_name(discovery_info)}
+        self.devices = {discovery_info.address: PRODUCT_NAMES[product_type]}
         await self.async_set_unique_id(self.address)
         self._abort_if_unique_id_configured()
         return await self.async_step_confirm()
@@ -131,12 +120,21 @@ class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
             return await self.async_step_confirm()
 
         current_addresses = self._async_current_ids(include_ignore=False)
+        candidates = set()
         for discovery_info in async_discovered_service_info(self.hass):
             address = discovery_info.address
             if address in current_addresses or not _is_supported(discovery_info):
                 continue
+            candidates.add(address)
 
-            self.devices[address] = _get_name(discovery_info)
+        data = await async_get_manufacturer_data(candidates)
+        for address, mfg_data in data.items():
+            if mfg_data.product_type not in _SUPPORTED_PRODUCT_TYPES:
+                continue
+            self.devices[address] = PRODUCT_NAMES[mfg_data.product_type]
+
+        # Keep selection sorted by address to ensure stable tests
+        self.devices = dict(sorted(self.devices.items(), key=lambda x: x[0]))
 
         if not self.devices:
             return self.async_abort(reason="no_devices_found")

homeassistant/components/gardena_bluetooth/manifest.json

@@ -15,5 +15,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["bleak", "bleak_esphome", "gardena_bluetooth"],
-  "requirements": ["gardena-bluetooth==2.3.0"]
+  "requirements": ["gardena-bluetooth==2.4.0"]
 }

homeassistant/components/gardena_bluetooth/util.py

@@ -1,51 +0,0 @@
-"""Utility functions for Gardena Bluetooth integration."""
-
-import asyncio
-from collections.abc import AsyncIterator
-
-from gardena_bluetooth.parse import ManufacturerData, ProductType
-
-from homeassistant.components import bluetooth
-
-
-async def _async_service_info(
-    hass, address
-) -> AsyncIterator[bluetooth.BluetoothServiceInfoBleak]:
-    queue = asyncio.Queue[bluetooth.BluetoothServiceInfoBleak]()
-
-    def _callback(
-        service_info: bluetooth.BluetoothServiceInfoBleak,
-        change: bluetooth.BluetoothChange,
-    ) -> None:
-        if change != bluetooth.BluetoothChange.ADVERTISEMENT:
-            return
-
-        queue.put_nowait(service_info)
-
-    service_info = bluetooth.async_last_service_info(hass, address, True)
-    if service_info:
-        yield service_info
-
-    cancel = bluetooth.async_register_callback(
-        hass,
-        _callback,
-        {bluetooth.match.ADDRESS: address},
-        bluetooth.BluetoothScanningMode.ACTIVE,
-    )
-    try:
-        while True:
-            yield await queue.get()
-    finally:
-        cancel()
-
-
-async def async_get_product_type(hass, address: str) -> ProductType:
-    """Wait for enough packets of manufacturer data to get the product type."""
-    data = ManufacturerData()
-
-    async for service_info in _async_service_info(hass, address):
-        data.update(service_info.manufacturer_data.get(ManufacturerData.company, b""))
-        product_type = ProductType.from_manufacturer_data(data)
-        if product_type is not ProductType.UNKNOWN:
-            return product_type
-    raise AssertionError("Iterator should have been infinite")

homeassistant/components/gate/strings.json

@@ -1,7 +1,8 @@
 {
   "common": {
     "condition_behavior_name": "Condition passes if",
-    "trigger_behavior_name": "Trigger when"
+    "trigger_behavior_name": "Trigger when",
+    "trigger_for_name": "For at least"
   },
   "conditions": {
     "is_closed": {
@@ -45,6 +46,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::gate::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::gate::common::trigger_for_name%]"
         }
       },
       "name": "Gate closed"
@@ -54,6 +58,9 @@
       "fields": {
         "behavior": {
           "name": "[%key:component::gate::common::trigger_behavior_name%]"
+        },
+        "for": {
+          "name": "[%key:component::gate::common::trigger_for_name%]"
         }
       },
       "name": "Gate opened"

homeassistant/components/gate/triggers.yaml

@@ -9,6 +9,11 @@
           - first
           - last
           - any
+  for:
+    required: true
+    default: 00:00:00
+    selector:
+      duration:
 
 closed:
   fields: *trigger_common_fields

homeassistant/components/generic/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/generic",
   "integration_type": "device",
   "iot_class": "local_push",
-  "requirements": ["av==16.0.1", "Pillow==12.1.1"]
+  "requirements": ["av==16.0.1", "Pillow==12.2.0"]
 }

homeassistant/components/glances/icons.json

@@ -13,6 +13,9 @@
       "disk_free": {
         "default": "mdi:harddisk"
       },
+      "disk_size": {
+        "default": "mdi:harddisk"
+      },
       "disk_usage": {
         "default": "mdi:harddisk"
       },

homeassistant/components/glances/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "local_polling",
   "loggers": ["glances_api"],
-  "requirements": ["glances-api==0.8.0"]
+  "requirements": ["glances-api==0.10.0"]
 }

homeassistant/components/glances/sensor.py

@@ -49,6 +49,14 @@ SENSOR_TYPES = {
         device_class=SensorDeviceClass.DATA_SIZE,
         state_class=SensorStateClass.MEASUREMENT,
     ),
+    ("fs", "disk_size"): GlancesSensorEntityDescription(
+        key="disk_size",
+        type="fs",
+        translation_key="disk_size",
+        native_unit_of_measurement=UnitOfInformation.GIBIBYTES,
+        device_class=SensorDeviceClass.DATA_SIZE,
+        state_class=SensorStateClass.MEASUREMENT,
+    ),
     ("fs", "disk_free"): GlancesSensorEntityDescription(
         key="disk_free",
         type="fs",

homeassistant/components/glances/strings.json

@@ -50,6 +50,9 @@
       "disk_free": {
         "name": "{sensor_label} disk free"
       },
+      "disk_size": {
+        "name": "{sensor_label} disk size"
+      },
       "disk_usage": {
         "name": "{sensor_label} disk usage"
       },

homeassistant/components/go2rtc/__init__.py

@@ -175,6 +175,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
             await server.start()
         except Exception:  # noqa: BLE001
             _LOGGER.warning("Could not start go2rtc server", exc_info=True)
+            await session.close()
             return False
 
         async def on_stop(event: Event) -> None:

homeassistant/components/group/__init__.py

@@ -28,7 +28,6 @@ from homeassistant.helpers.group import (
 )
 from homeassistant.helpers.reload import async_reload_integration_platforms
 from homeassistant.helpers.typing import ConfigType
-from homeassistant.loader import bind_hass
 
 #
 # Below we ensure the config_flow is imported so it does not need the import
@@ -103,7 +102,6 @@ CONFIG_SCHEMA = vol.Schema(
 )
 
 
-@bind_hass
 def is_on(hass: HomeAssistant, entity_id: str) -> bool:
     """Test if the group state is in its ON-state."""
     if REG_KEY not in hass.data:
@@ -117,11 +115,10 @@ def is_on(hass: HomeAssistant, entity_id: str) -> bool:
 
 
 # expand_entity_ids and get_entity_ids are for backwards compatibility only
-expand_entity_ids = bind_hass(_expand_entity_ids)
-get_entity_ids = bind_hass(_get_entity_ids)
+expand_entity_ids = _expand_entity_ids
+get_entity_ids = _get_entity_ids
 
 
-@bind_hass
 def groups_with_entity(hass: HomeAssistant, entity_id: str) -> list[str]:
     """Get all groups that contain this entity.
 

homeassistant/components/growatt_server/sensor/sph.py

@@ -72,7 +72,7 @@ SPH_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         key="mix_export_to_grid",
         translation_key="mix_export_to_grid",
         api_key="pacToGridTotal",
-        native_unit_of_measurement=UnitOfPower.KILO_WATT,
+        native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
     ),
@@ -80,7 +80,7 @@ SPH_SENSOR_TYPES: tuple[GrowattSensorEntityDescription, ...] = (
         key="mix_import_from_grid",
         translation_key="mix_import_from_grid",
         api_key="pacToUserR",
-        native_unit_of_measurement=UnitOfPower.KILO_WATT,
+        native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
     ),

homeassistant/components/hassio/__init__.py

@@ -91,10 +91,14 @@ from .const import (
     DATA_STORE,
     DATA_SUPERVISOR_INFO,
     DOMAIN,
-    HASSIO_UPDATE_INTERVAL,
+    HASSIO_MAIN_UPDATE_INTERVAL,
+    MAIN_COORDINATOR,
+    STATS_COORDINATOR,
 )
 from .coordinator import (
-    HassioDataUpdateCoordinator,
+    HassioAddOnDataUpdateCoordinator,
+    HassioMainDataUpdateCoordinator,
+    HassioStatsDataUpdateCoordinator,
     get_addons_info,
     get_addons_list,
     get_addons_stats,
@@ -384,12 +388,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
             ]
             hass.data[DATA_SUPERVISOR_INFO]["addons"] = hass.data[DATA_ADDONS_LIST]
 
-        async_call_later(
-            hass,
-            HASSIO_UPDATE_INTERVAL,
-            HassJob(update_info_data, cancel_on_shutdown=True),
-        )
-
     # Fetch data
     update_info_task = hass.async_create_task(update_info_data(), eager_start=True)
 
@@ -436,7 +434,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
             # os info not yet fetched from supervisor, retry later
             async_call_later(
                 hass,
-                HASSIO_UPDATE_INTERVAL,
+                HASSIO_MAIN_UPDATE_INTERVAL,
                 async_setup_hardware_integration_job,
             )
             return
@@ -462,9 +460,20 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:  # noqa:
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up a config entry."""
     dev_reg = dr.async_get(hass)
-    coordinator = HassioDataUpdateCoordinator(hass, entry, dev_reg)
+
+    coordinator = HassioMainDataUpdateCoordinator(hass, entry, dev_reg)
     await coordinator.async_config_entry_first_refresh()
-    hass.data[ADDONS_COORDINATOR] = coordinator
+    hass.data[MAIN_COORDINATOR] = coordinator
+
+    addon_coordinator = HassioAddOnDataUpdateCoordinator(
+        hass, entry, dev_reg, coordinator.jobs
+    )
+    await addon_coordinator.async_config_entry_first_refresh()
+    hass.data[ADDONS_COORDINATOR] = addon_coordinator
+
+    stats_coordinator = HassioStatsDataUpdateCoordinator(hass, entry)
+    await stats_coordinator.async_config_entry_first_refresh()
+    hass.data[STATS_COORDINATOR] = stats_coordinator
 
     def deprecated_setup_issue() -> None:
         os_info = get_os_info(hass)
@@ -531,10 +540,12 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
     # Unload coordinator
-    coordinator: HassioDataUpdateCoordinator = hass.data[ADDONS_COORDINATOR]
+    coordinator: HassioMainDataUpdateCoordinator = hass.data[MAIN_COORDINATOR]
     coordinator.unload()
 
-    # Pop coordinator
+    # Pop coordinators
+    hass.data.pop(MAIN_COORDINATOR, None)
     hass.data.pop(ADDONS_COORDINATOR, None)
+    hass.data.pop(STATS_COORDINATOR, None)
 
     return unload_ok

homeassistant/components/hassio/binary_sensor.py

@@ -22,6 +22,7 @@ from .const import (
     ATTR_STATE,
     DATA_KEY_ADDONS,
     DATA_KEY_MOUNTS,
+    MAIN_COORDINATOR,
 )
 from .entity import HassioAddonEntity, HassioMountEntity
 
@@ -60,17 +61,18 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Binary sensor set up for Hass.io config entry."""
-    coordinator = hass.data[ADDONS_COORDINATOR]
+    addons_coordinator = hass.data[ADDONS_COORDINATOR]
+    coordinator = hass.data[MAIN_COORDINATOR]
 
     async_add_entities(
         itertools.chain(
             [
                 HassioAddonBinarySensor(
                     addon=addon,
-                    coordinator=coordinator,
+                    coordinator=addons_coordinator,
                     entity_description=entity_description,
                 )
-                for addon in coordinator.data[DATA_KEY_ADDONS].values()
+                for addon in addons_coordinator.data[DATA_KEY_ADDONS].values()
                 for entity_description in ADDON_ENTITY_DESCRIPTIONS
             ],
             [

homeassistant/components/hassio/const.py

@@ -77,7 +77,9 @@ EVENT_JOB = "job"
 UPDATE_KEY_SUPERVISOR = "supervisor"
 STARTUP_COMPLETE = "complete"
 
+MAIN_COORDINATOR = "hassio_main_coordinator"
 ADDONS_COORDINATOR = "hassio_addons_coordinator"
+STATS_COORDINATOR = "hassio_stats_coordinator"
 
 
 DATA_COMPONENT: HassKey[HassIO] = HassKey(DOMAIN)
@@ -94,7 +96,9 @@ DATA_SUPERVISOR_STATS = "hassio_supervisor_stats"
 DATA_ADDONS_INFO = "hassio_addons_info"
 DATA_ADDONS_STATS = "hassio_addons_stats"
 DATA_ADDONS_LIST = "hassio_addons_list"
-HASSIO_UPDATE_INTERVAL = timedelta(minutes=5)
+HASSIO_MAIN_UPDATE_INTERVAL = timedelta(minutes=5)
+HASSIO_ADDON_UPDATE_INTERVAL = timedelta(minutes=15)
+HASSIO_STATS_UPDATE_INTERVAL = timedelta(seconds=60)
 
 ATTR_AUTO_UPDATE = "auto_update"
 ATTR_VERSION = "version"

homeassistant/components/hassio/coordinator.py

@@ -7,7 +7,7 @@ from collections import defaultdict
 from collections.abc import Awaitable
 from copy import deepcopy
 import logging
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any
 
 from aiohasupervisor import SupervisorError, SupervisorNotFoundError
 from aiohasupervisor.models import (
@@ -15,9 +15,9 @@ from aiohasupervisor.models import (
     CIFSMountResponse,
     InstalledAddon,
     NFSMountResponse,
+    ResponseData,
     StoreInfo,
 )
-from aiohasupervisor.models.base import ResponseData
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_MANUFACTURER, ATTR_NAME
@@ -26,7 +26,6 @@ from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.debounce import Debouncer
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-from homeassistant.loader import bind_hass
 
 from .const import (
     ATTR_AUTO_UPDATE,
@@ -35,13 +34,11 @@ from .const import (
     ATTR_SLUG,
     ATTR_URL,
     ATTR_VERSION,
-    CONTAINER_INFO,
     CONTAINER_STATS,
     CORE_CONTAINER,
     DATA_ADDONS_INFO,
     DATA_ADDONS_LIST,
     DATA_ADDONS_STATS,
-    DATA_COMPONENT,
     DATA_CORE_INFO,
     DATA_CORE_STATS,
     DATA_HOST_INFO,
@@ -59,7 +56,9 @@ from .const import (
     DATA_SUPERVISOR_INFO,
     DATA_SUPERVISOR_STATS,
     DOMAIN,
-    HASSIO_UPDATE_INTERVAL,
+    HASSIO_ADDON_UPDATE_INTERVAL,
+    HASSIO_MAIN_UPDATE_INTERVAL,
+    HASSIO_STATS_UPDATE_INTERVAL,
     REQUEST_REFRESH_DELAY,
     SUPERVISOR_CONTAINER,
     SupervisorEntityModel,
@@ -74,7 +73,6 @@ _LOGGER = logging.getLogger(__name__)
 
 
 @callback
-@bind_hass
 def get_info(hass: HomeAssistant) -> dict[str, Any] | None:
     """Return generic information from Supervisor.
 
@@ -84,7 +82,6 @@ def get_info(hass: HomeAssistant) -> dict[str, Any] | None:
 
 
 @callback
-@bind_hass
 def get_host_info(hass: HomeAssistant) -> dict[str, Any] | None:
     """Return generic host information.
 
@@ -94,7 +91,6 @@ def get_host_info(hass: HomeAssistant) -> dict[str, Any] | None:
 
 
 @callback
-@bind_hass
 def get_store(hass: HomeAssistant) -> dict[str, Any] | None:
     """Return store information.
 
@@ -104,7 +100,6 @@ def get_store(hass: HomeAssistant) -> dict[str, Any] | None:
 
 
 @callback
-@bind_hass
 def get_supervisor_info(hass: HomeAssistant) -> dict[str, Any] | None:
     """Return Supervisor information.
 
@@ -114,7 +109,6 @@ def get_supervisor_info(hass: HomeAssistant) -> dict[str, Any] | None:
 
 
 @callback
-@bind_hass
 def get_network_info(hass: HomeAssistant) -> dict[str, Any] | None:
     """Return Host Network information.
 
@@ -124,7 +118,6 @@ def get_network_info(hass: HomeAssistant) -> dict[str, Any] | None:
 
 
 @callback
-@bind_hass
 def get_addons_info(hass: HomeAssistant) -> dict[str, dict[str, Any] | None] | None:
     """Return Addons info.
 
@@ -143,7 +136,6 @@ def get_addons_list(hass: HomeAssistant) -> list[dict[str, Any]] | None:
 
 
 @callback
-@bind_hass
 def get_addons_stats(hass: HomeAssistant) -> dict[str, dict[str, Any] | None]:
     """Return Addons stats.
 
@@ -153,7 +145,6 @@ def get_addons_stats(hass: HomeAssistant) -> dict[str, dict[str, Any] | None]:
 
 
 @callback
-@bind_hass
 def get_core_stats(hass: HomeAssistant) -> dict[str, Any]:
     """Return core stats.
 
@@ -163,7 +154,6 @@ def get_core_stats(hass: HomeAssistant) -> dict[str, Any]:
 
 
 @callback
-@bind_hass
 def get_supervisor_stats(hass: HomeAssistant) -> dict[str, Any]:
     """Return supervisor stats.
 
@@ -173,7 +163,6 @@ def get_supervisor_stats(hass: HomeAssistant) -> dict[str, Any]:
 
 
 @callback
-@bind_hass
 def get_os_info(hass: HomeAssistant) -> dict[str, Any] | None:
     """Return OS information.
 
@@ -183,7 +172,6 @@ def get_os_info(hass: HomeAssistant) -> dict[str, Any] | None:
 
 
 @callback
-@bind_hass
 def get_core_info(hass: HomeAssistant) -> dict[str, Any] | None:
     """Return Home Assistant Core information from Supervisor.
 
@@ -193,7 +181,6 @@ def get_core_info(hass: HomeAssistant) -> dict[str, Any] | None:
 
 
 @callback
-@bind_hass
 def get_issues_info(hass: HomeAssistant) -> SupervisorIssues | None:
     """Return Supervisor issues info.
 
@@ -318,7 +305,314 @@ def async_remove_devices_from_dev_reg(
             dev_reg.async_remove_device(dev.id)
 
 
-class HassioDataUpdateCoordinator(DataUpdateCoordinator):
+class HassioStatsDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
+    """Class to retrieve Hass.io container stats."""
+
+    config_entry: ConfigEntry
+
+    def __init__(self, hass: HomeAssistant, config_entry: ConfigEntry) -> None:
+        """Initialize coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            config_entry=config_entry,
+            name=DOMAIN,
+            update_interval=HASSIO_STATS_UPDATE_INTERVAL,
+            request_refresh_debouncer=Debouncer(
+                hass, _LOGGER, cooldown=REQUEST_REFRESH_DELAY, immediate=False
+            ),
+        )
+        self.supervisor_client = get_supervisor_client(hass)
+        self._container_updates: defaultdict[str, dict[str, set[str]]] = defaultdict(
+            lambda: defaultdict(set)
+        )
+
+    async def _async_update_data(self) -> dict[str, Any]:
+        """Update stats data via library."""
+        try:
+            await self._fetch_stats()
+        except SupervisorError as err:
+            raise UpdateFailed(f"Error on Supervisor API: {err}") from err
+
+        new_data: dict[str, Any] = {}
+        new_data[DATA_KEY_CORE] = get_core_stats(self.hass)
+        new_data[DATA_KEY_SUPERVISOR] = get_supervisor_stats(self.hass)
+        new_data[DATA_KEY_ADDONS] = get_addons_stats(self.hass)
+        return new_data
+
+    async def _fetch_stats(self) -> None:
+        """Fetch container stats for subscribed entities."""
+        container_updates = self._container_updates
+        data = self.hass.data
+        client = self.supervisor_client
+
+        # Fetch core and supervisor stats
+        updates: dict[str, Awaitable] = {}
+        if container_updates.get(CORE_CONTAINER, {}).get(CONTAINER_STATS):
+            updates[DATA_CORE_STATS] = client.homeassistant.stats()
+        if container_updates.get(SUPERVISOR_CONTAINER, {}).get(CONTAINER_STATS):
+            updates[DATA_SUPERVISOR_STATS] = client.supervisor.stats()
+
+        if updates:
+            api_results: list[ResponseData] = await asyncio.gather(*updates.values())
+            for key, result in zip(updates, api_results, strict=True):
+                data[key] = result.to_dict()
+
+        # Fetch addon stats
+        addons_list = get_addons_list(self.hass) or []
+        started_addons = {
+            addon[ATTR_SLUG]
+            for addon in addons_list
+            if addon.get("state") in {AddonState.STARTED, AddonState.STARTUP}
+        }
+
+        addons_stats: dict[str, Any] = data.setdefault(DATA_ADDONS_STATS, {})
+
+        # Clean up cache for stopped/removed addons
+        for slug in addons_stats.keys() - started_addons:
+            del addons_stats[slug]
+
+        # Fetch stats for addons with subscribed entities
+        addon_stats_results = dict(
+            await asyncio.gather(
+                *[
+                    self._update_addon_stats(slug)
+                    for slug in started_addons
+                    if container_updates.get(slug, {}).get(CONTAINER_STATS)
+                ]
+            )
+        )
+        addons_stats.update(addon_stats_results)
+
+    async def _update_addon_stats(self, slug: str) -> tuple[str, dict[str, Any] | None]:
+        """Update single addon stats."""
+        try:
+            stats = await self.supervisor_client.addons.addon_stats(slug)
+        except SupervisorError as err:
+            _LOGGER.warning("Could not fetch stats for %s: %s", slug, err)
+            return (slug, None)
+        return (slug, stats.to_dict())
+
+    @callback
+    def async_enable_container_updates(
+        self, slug: str, entity_id: str, types: set[str]
+    ) -> CALLBACK_TYPE:
+        """Enable stats updates for a container."""
+        enabled_updates = self._container_updates[slug]
+        for key in types:
+            enabled_updates[key].add(entity_id)
+
+        @callback
+        def _remove() -> None:
+            for key in types:
+                enabled_updates[key].discard(entity_id)
+                if not enabled_updates[key]:
+                    del enabled_updates[key]
+            if not enabled_updates:
+                self._container_updates.pop(slug, None)
+
+        return _remove
+
+
+class HassioAddOnDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
+    """Class to retrieve Hass.io Add-on status."""
+
+    config_entry: ConfigEntry
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: ConfigEntry,
+        dev_reg: dr.DeviceRegistry,
+        jobs: SupervisorJobs,
+    ) -> None:
+        """Initialize coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            config_entry=config_entry,
+            name=DOMAIN,
+            update_interval=HASSIO_ADDON_UPDATE_INTERVAL,
+            # We don't want an immediate refresh since we want to avoid
+            # hammering the Supervisor API on startup
+            request_refresh_debouncer=Debouncer(
+                hass, _LOGGER, cooldown=REQUEST_REFRESH_DELAY, immediate=False
+            ),
+        )
+        self.entry_id = config_entry.entry_id
+        self.dev_reg = dev_reg
+        self._addon_info_subscriptions: defaultdict[str, set[str]] = defaultdict(set)
+        self.supervisor_client = get_supervisor_client(hass)
+        self.jobs = jobs
+
+    async def _async_update_data(self) -> dict[str, Any]:
+        """Update data via library."""
+        is_first_update = not self.data
+        client = self.supervisor_client
+
+        try:
+            installed_addons: list[InstalledAddon] = await client.addons.list()
+            all_addons = {addon.slug for addon in installed_addons}
+
+            # Fetch addon info for all addons on first update, or only
+            # for addons with subscribed entities on subsequent updates.
+            addon_info_results = dict(
+                await asyncio.gather(
+                    *[
+                        self._update_addon_info(slug)
+                        for slug in all_addons
+                        if is_first_update or self._addon_info_subscriptions.get(slug)
+                    ]
+                )
+            )
+        except SupervisorError as err:
+            raise UpdateFailed(f"Error on Supervisor API: {err}") from err
+
+        # Update hass.data for legacy accessor functions
+        data = self.hass.data
+        addons_list_dicts = [addon.to_dict() for addon in installed_addons]
+        data[DATA_ADDONS_LIST] = addons_list_dicts
+
+        # Update addon info cache in hass.data
+        addon_info_cache: dict[str, Any] = data.setdefault(DATA_ADDONS_INFO, {})
+        for slug in addon_info_cache.keys() - all_addons:
+            del addon_info_cache[slug]
+        addon_info_cache.update(addon_info_results)
+
+        # Deprecated 2026.4.0: Folding addons.list results into supervisor_info
+        # for compatibility. Written to hass.data only, not coordinator data.
+        if DATA_SUPERVISOR_INFO in data:
+            data[DATA_SUPERVISOR_INFO]["addons"] = addons_list_dicts
+
+        # Build clean coordinator data
+        store_data = get_store(self.hass)
+        if store_data:
+            repositories = {
+                repo.slug: repo.name
+                for repo in StoreInfo.from_dict(store_data).repositories
+            }
+        else:
+            repositories = {}
+
+        new_data: dict[str, Any] = {}
+        new_data[DATA_KEY_ADDONS] = {
+            (slug := addon[ATTR_SLUG]): {
+                **addon,
+                ATTR_AUTO_UPDATE: (addon_info_cache.get(slug) or {}).get(
+                    ATTR_AUTO_UPDATE, False
+                ),
+                ATTR_REPOSITORY: repositories.get(
+                    repo_slug := addon.get(ATTR_REPOSITORY, ""), repo_slug
+                ),
+            }
+            for addon in addons_list_dicts
+        }
+
+        # If this is the initial refresh, register all addons
+        if is_first_update:
+            async_register_addons_in_dev_reg(
+                self.entry_id, self.dev_reg, new_data[DATA_KEY_ADDONS].values()
+            )
+
+        # Remove add-ons that are no longer installed from device registry
+        supervisor_addon_devices = {
+            list(device.identifiers)[0][1]
+            for device in self.dev_reg.devices.get_devices_for_config_entry_id(
+                self.entry_id
+            )
+            if device.model == SupervisorEntityModel.ADDON
+        }
+        if stale_addons := supervisor_addon_devices - set(new_data[DATA_KEY_ADDONS]):
+            async_remove_devices_from_dev_reg(self.dev_reg, stale_addons)
+
+        # If there are new add-ons, we should reload the config entry so we can
+        # create new devices and entities. We can return an empty dict because
+        # coordinator will be recreated.
+        if self.data and (
+            set(new_data[DATA_KEY_ADDONS]) - set(self.data[DATA_KEY_ADDONS])
+        ):
+            self.hass.async_create_task(
+                self.hass.config_entries.async_reload(self.entry_id)
+            )
+            return {}
+
+        return new_data
+
+    async def get_changelog(self, addon_slug: str) -> str | None:
+        """Get the changelog for an add-on."""
+        try:
+            return await self.supervisor_client.store.addon_changelog(addon_slug)
+        except SupervisorNotFoundError:
+            return None
+
+    async def _update_addon_info(self, slug: str) -> tuple[str, dict[str, Any] | None]:
+        """Return the info for an addon."""
+        try:
+            info = await self.supervisor_client.addons.addon_info(slug)
+        except SupervisorError as err:
+            _LOGGER.warning("Could not fetch info for %s: %s", slug, err)
+            return (slug, None)
+        # Translate to legacy hassio names for compatibility
+        info_dict = info.to_dict()
+        info_dict["hassio_api"] = info_dict.pop("supervisor_api")
+        info_dict["hassio_role"] = info_dict.pop("supervisor_role")
+        return (slug, info_dict)
+
+    @callback
+    def async_enable_addon_info_updates(
+        self, slug: str, entity_id: str
+    ) -> CALLBACK_TYPE:
+        """Enable info updates for an add-on."""
+        self._addon_info_subscriptions[slug].add(entity_id)
+
+        @callback
+        def _remove() -> None:
+            self._addon_info_subscriptions[slug].discard(entity_id)
+            if not self._addon_info_subscriptions[slug]:
+                del self._addon_info_subscriptions[slug]
+
+        return _remove
+
+    async def _async_refresh(
+        self,
+        log_failures: bool = True,
+        raise_on_auth_failed: bool = False,
+        scheduled: bool = False,
+        raise_on_entry_error: bool = False,
+    ) -> None:
+        """Refresh data."""
+        if not scheduled and not raise_on_auth_failed:
+            # Force reloading add-on updates for non-scheduled
+            # updates.
+            #
+            # If `raise_on_auth_failed` is set, it means this is
+            # the first refresh and we do not want to delay
+            # startup or cause a timeout so we only refresh the
+            # updates if this is not a scheduled refresh and
+            # we are not doing the first refresh.
+            try:
+                await self.supervisor_client.store.reload()
+            except SupervisorError as err:
+                _LOGGER.warning("Error on Supervisor API: %s", err)
+
+        await super()._async_refresh(
+            log_failures, raise_on_auth_failed, scheduled, raise_on_entry_error
+        )
+
+    async def force_addon_info_data_refresh(self, addon_slug: str) -> None:
+        """Force refresh of addon info data for a specific addon."""
+        try:
+            slug, info = await self._update_addon_info(addon_slug)
+            if info is not None and DATA_KEY_ADDONS in self.data:
+                if slug in self.data[DATA_KEY_ADDONS]:
+                    data = deepcopy(self.data)
+                    data[DATA_KEY_ADDONS][slug].update(info)
+                    self.async_set_updated_data(data)
+        except SupervisorError as err:
+            _LOGGER.warning("Could not refresh info for %s: %s", addon_slug, err)
+
+
+class HassioMainDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
     """Class to retrieve Hass.io status."""
 
     config_entry: ConfigEntry
@@ -332,82 +626,77 @@ class HassioDataUpdateCoordinator(DataUpdateCoordinator):
             _LOGGER,
             config_entry=config_entry,
             name=DOMAIN,
-            update_interval=HASSIO_UPDATE_INTERVAL,
+            update_interval=HASSIO_MAIN_UPDATE_INTERVAL,
             # We don't want an immediate refresh since we want to avoid
-            # fetching the container stats right away and avoid hammering
-            # the Supervisor API on startup
+            # hammering the Supervisor API on startup
             request_refresh_debouncer=Debouncer(
                 hass, _LOGGER, cooldown=REQUEST_REFRESH_DELAY, immediate=False
             ),
         )
-        self.hassio = hass.data[DATA_COMPONENT]
-        self.data = {}
         self.entry_id = config_entry.entry_id
         self.dev_reg = dev_reg
         self.is_hass_os = (get_info(self.hass) or {}).get("hassos") is not None
-        self._container_updates: defaultdict[str, dict[str, set[str]]] = defaultdict(
-            lambda: defaultdict(set)
-        )
         self.supervisor_client = get_supervisor_client(hass)
         self.jobs = SupervisorJobs(hass)
 
     async def _async_update_data(self) -> dict[str, Any]:
         """Update data via library."""
         is_first_update = not self.data
+        client = self.supervisor_client
 
         try:
-            await self.force_data_refresh(is_first_update)
+            (
+                info,
+                core_info,
+                supervisor_info,
+                os_info,
+                host_info,
+                store_info,
+                network_info,
+            ) = await asyncio.gather(
+                client.info(),
+                client.homeassistant.info(),
+                client.supervisor.info(),
+                client.os.info(),
+                client.host.info(),
+                client.store.info(),
+                client.network.info(),
+            )
+            mounts_info = await client.mounts.info()
+            await self.jobs.refresh_data(is_first_update)
         except SupervisorError as err:
             raise UpdateFailed(f"Error on Supervisor API: {err}") from err
 
+        # Build clean coordinator data
         new_data: dict[str, Any] = {}
-        supervisor_info = get_supervisor_info(self.hass) or {}
-        addons_info = get_addons_info(self.hass) or {}
-        addons_stats = get_addons_stats(self.hass)
-        store_data = get_store(self.hass)
-        mounts_info = await self.supervisor_client.mounts.info()
-        addons_list = get_addons_list(self.hass) or []
-
-        if store_data:
-            repositories = {
-                repo.slug: repo.name
-                for repo in StoreInfo.from_dict(store_data).repositories
-            }
-        else:
-            repositories = {}
-
-        new_data[DATA_KEY_ADDONS] = {
-            (slug := addon[ATTR_SLUG]): {
-                **addon,
-                **(addons_stats.get(slug) or {}),
-                ATTR_AUTO_UPDATE: (addons_info.get(slug) or {}).get(
-                    ATTR_AUTO_UPDATE, False
-                ),
-                ATTR_REPOSITORY: repositories.get(
-                    repo_slug := addon.get(ATTR_REPOSITORY, ""), repo_slug
-                ),
-            }
-            for addon in addons_list
-        }
-        if self.is_hass_os:
-            new_data[DATA_KEY_OS] = get_os_info(self.hass)
-
-        new_data[DATA_KEY_CORE] = {
-            **(get_core_info(self.hass) or {}),
-            **get_core_stats(self.hass),
-        }
-        new_data[DATA_KEY_SUPERVISOR] = {
-            **supervisor_info,
-            **get_supervisor_stats(self.hass),
-        }
-        new_data[DATA_KEY_HOST] = get_host_info(self.hass) or {}
+        new_data[DATA_KEY_CORE] = core_info.to_dict()
+        new_data[DATA_KEY_SUPERVISOR] = supervisor_info.to_dict()
+        new_data[DATA_KEY_HOST] = host_info.to_dict()
         new_data[DATA_KEY_MOUNTS] = {mount.name: mount for mount in mounts_info.mounts}
+        if self.is_hass_os:
+            new_data[DATA_KEY_OS] = os_info.to_dict()
 
-        # If this is the initial refresh, register all addons and return the dict
+        # Update hass.data for legacy accessor functions
+        data = self.hass.data
+        data[DATA_INFO] = info.to_dict()
+        data[DATA_CORE_INFO] = new_data[DATA_KEY_CORE]
+        data[DATA_OS_INFO] = new_data.get(DATA_KEY_OS, os_info.to_dict())
+        data[DATA_HOST_INFO] = new_data[DATA_KEY_HOST]
+        data[DATA_STORE] = store_info.to_dict()
+        data[DATA_NETWORK_INFO] = network_info.to_dict()
+        # Separate dict for hass.data supervisor info since we add deprecated
+        # compat keys that should not be in coordinator data
+        supervisor_info_dict = supervisor_info.to_dict()
+        # Deprecated 2026.4.0: Folding repositories and addons into
+        # supervisor_info for compatibility. Written to hass.data only, not
+        # coordinator data. Preserve the addons key from the addon coordinator.
+        supervisor_info_dict["repositories"] = data[DATA_STORE][ATTR_REPOSITORIES]
+        if (prev := data.get(DATA_SUPERVISOR_INFO)) and "addons" in prev:
+            supervisor_info_dict["addons"] = prev["addons"]
+        data[DATA_SUPERVISOR_INFO] = supervisor_info_dict
+
+        # If this is the initial refresh, register all main components
         if is_first_update:
-            async_register_addons_in_dev_reg(
-                self.entry_id, self.dev_reg, new_data[DATA_KEY_ADDONS].values()
-            )
             async_register_mounts_in_dev_reg(
                 self.entry_id, self.dev_reg, new_data[DATA_KEY_MOUNTS].values()
             )
@@ -423,17 +712,6 @@ class HassioDataUpdateCoordinator(DataUpdateCoordinator):
                     self.entry_id, self.dev_reg, new_data[DATA_KEY_OS]
                 )
 
-        # Remove add-ons that are no longer installed from device registry
-        supervisor_addon_devices = {
-            list(device.identifiers)[0][1]
-            for device in self.dev_reg.devices.get_devices_for_config_entry_id(
-                self.entry_id
-            )
-            if device.model == SupervisorEntityModel.ADDON
-        }
-        if stale_addons := supervisor_addon_devices - set(new_data[DATA_KEY_ADDONS]):
-            async_remove_devices_from_dev_reg(self.dev_reg, stale_addons)
-
         # Remove mounts that no longer exists from device registry
         supervisor_mount_devices = {
             device.name
@@ -453,12 +731,11 @@ class HassioDataUpdateCoordinator(DataUpdateCoordinator):
             # Remove the OS device if it exists and the installation is not hassos
             self.dev_reg.async_remove_device(dev.id)
 
-        # If there are new add-ons or mounts, we should reload the config entry so we can
+        # If there are new mounts, we should reload the config entry so we can
         # create new devices and entities. We can return an empty dict because
         # coordinator will be recreated.
         if self.data and (
-            set(new_data[DATA_KEY_ADDONS]) - set(self.data[DATA_KEY_ADDONS])
-            or set(new_data[DATA_KEY_MOUNTS]) - set(self.data[DATA_KEY_MOUNTS])
+            set(new_data[DATA_KEY_MOUNTS]) - set(self.data.get(DATA_KEY_MOUNTS, {}))
         ):
             self.hass.async_create_task(
                 self.hass.config_entries.async_reload(self.entry_id)
@@ -467,146 +744,6 @@ class HassioDataUpdateCoordinator(DataUpdateCoordinator):
 
         return new_data
 
-    async def get_changelog(self, addon_slug: str) -> str | None:
-        """Get the changelog for an add-on."""
-        try:
-            return await self.supervisor_client.store.addon_changelog(addon_slug)
-        except SupervisorNotFoundError:
-            return None
-
-    async def force_data_refresh(self, first_update: bool) -> None:
-        """Force update of the addon info."""
-        container_updates = self._container_updates
-
-        data = self.hass.data
-        client = self.supervisor_client
-
-        updates: dict[str, Awaitable[ResponseData]] = {
-            DATA_INFO: client.info(),
-            DATA_CORE_INFO: client.homeassistant.info(),
-            DATA_SUPERVISOR_INFO: client.supervisor.info(),
-            DATA_OS_INFO: client.os.info(),
-            DATA_STORE: client.store.info(),
-        }
-        if CONTAINER_STATS in container_updates[CORE_CONTAINER]:
-            updates[DATA_CORE_STATS] = client.homeassistant.stats()
-        if CONTAINER_STATS in container_updates[SUPERVISOR_CONTAINER]:
-            updates[DATA_SUPERVISOR_STATS] = client.supervisor.stats()
-
-        # Pull off addons.list results for further processing before caching
-        addons_list, *results = await asyncio.gather(
-            client.addons.list(), *updates.values()
-        )
-        for key, result in zip(updates, cast(list[ResponseData], results), strict=True):
-            data[key] = result.to_dict()
-
-        installed_addons = cast(list[InstalledAddon], addons_list)
-        data[DATA_ADDONS_LIST] = [addon.to_dict() for addon in installed_addons]
-
-        # Deprecated 2026.4.0: Folding repositories and addons.list results into supervisor_info for compatibility
-        # Can drop this after removal period
-        data[DATA_SUPERVISOR_INFO].update(
-            {
-                "repositories": data[DATA_STORE][ATTR_REPOSITORIES],
-                "addons": [addon.to_dict() for addon in installed_addons],
-            }
-        )
-
-        all_addons = {addon.slug for addon in installed_addons}
-        started_addons = {
-            addon.slug
-            for addon in installed_addons
-            if addon.state in {AddonState.STARTED, AddonState.STARTUP}
-        }
-
-        #
-        # Update addon info if its the first update or
-        # there is at least one entity that needs the data.
-        #
-        # When entities are added they call async_enable_container_updates
-        # to enable updates for the endpoints they need via
-        # async_added_to_hass. This ensures that we only update
-        # the data for the endpoints that are needed to avoid unnecessary
-        # API calls since otherwise we would fetch stats for all containers
-        # and throw them away.
-        #
-        for data_key, update_func, enabled_key, wanted_addons, needs_first_update in (
-            (
-                DATA_ADDONS_STATS,
-                self._update_addon_stats,
-                CONTAINER_STATS,
-                started_addons,
-                False,
-            ),
-            (
-                DATA_ADDONS_INFO,
-                self._update_addon_info,
-                CONTAINER_INFO,
-                all_addons,
-                True,
-            ),
-        ):
-            container_data: dict[str, Any] = data.setdefault(data_key, {})
-
-            # Clean up cache
-            for slug in container_data.keys() - wanted_addons:
-                del container_data[slug]
-
-            # Update cache from API
-            container_data.update(
-                dict(
-                    await asyncio.gather(
-                        *[
-                            update_func(slug)
-                            for slug in wanted_addons
-                            if (first_update and needs_first_update)
-                            or enabled_key in container_updates[slug]
-                        ]
-                    )
-                )
-            )
-
-        # Refresh jobs data
-        await self.jobs.refresh_data(first_update)
-
-    async def _update_addon_stats(self, slug: str) -> tuple[str, dict[str, Any] | None]:
-        """Update single addon stats."""
-        try:
-            stats = await self.supervisor_client.addons.addon_stats(slug)
-        except SupervisorError as err:
-            _LOGGER.warning("Could not fetch stats for %s: %s", slug, err)
-            return (slug, None)
-        return (slug, stats.to_dict())
-
-    async def _update_addon_info(self, slug: str) -> tuple[str, dict[str, Any] | None]:
-        """Return the info for an addon."""
-        try:
-            info = await self.supervisor_client.addons.addon_info(slug)
-        except SupervisorError as err:
-            _LOGGER.warning("Could not fetch info for %s: %s", slug, err)
-            return (slug, None)
-        # Translate to legacy hassio names for compatibility
-        info_dict = info.to_dict()
-        info_dict["hassio_api"] = info_dict.pop("supervisor_api")
-        info_dict["hassio_role"] = info_dict.pop("supervisor_role")
-        return (slug, info_dict)
-
-    @callback
-    def async_enable_container_updates(
-        self, slug: str, entity_id: str, types: set[str]
-    ) -> CALLBACK_TYPE:
-        """Enable updates for an add-on."""
-        enabled_updates = self._container_updates[slug]
-        for key in types:
-            enabled_updates[key].add(entity_id)
-
-        @callback
-        def _remove() -> None:
-            for key in types:
-                enabled_updates[key].remove(entity_id)
-
-        return _remove
-
     async def _async_refresh(
         self,
         log_failures: bool = True,
@@ -616,14 +753,16 @@ class HassioDataUpdateCoordinator(DataUpdateCoordinator):
     ) -> None:
         """Refresh data."""
         if not scheduled and not raise_on_auth_failed:
-            # Force refreshing updates for non-scheduled updates
+            # Force reloading updates of main components for
+            # non-scheduled updates.
+            #
             # If `raise_on_auth_failed` is set, it means this is
             # the first refresh and we do not want to delay
             # startup or cause a timeout so we only refresh the
             # updates if this is not a scheduled refresh and
             # we are not doing the first refresh.
             try:
-                await self.supervisor_client.refresh_updates()
+                await self.supervisor_client.reload_updates()
             except SupervisorError as err:
                 _LOGGER.warning("Error on Supervisor API: %s", err)
 
@@ -631,18 +770,6 @@ class HassioDataUpdateCoordinator(DataUpdateCoordinator):
             log_failures, raise_on_auth_failed, scheduled, raise_on_entry_error
         )
 
-    async def force_addon_info_data_refresh(self, addon_slug: str) -> None:
-        """Force refresh of addon info data for a specific addon."""
-        try:
-            slug, info = await self._update_addon_info(addon_slug)
-            if info is not None and DATA_KEY_ADDONS in self.data:
-                if slug in self.data[DATA_KEY_ADDONS]:
-                    data = deepcopy(self.data)
-                    data[DATA_KEY_ADDONS][slug].update(info)
-                    self.async_set_updated_data(data)
-        except SupervisorError as err:
-            _LOGGER.warning("Could not refresh info for %s: %s", addon_slug, err)
-
     @callback
     def unload(self) -> None:
         """Clean up when config entry unloaded."""