Remove overwriting of haffmpeg in smartthings test

Co-authored-by: Norbert Rittel <norbert@rittel.de>

.devcontainer/devcontainer.json

@@ -40,7 +40,8 @@
         "python.terminal.activateEnvInCurrentTerminal": true,
         "python.testing.pytestArgs": ["--no-cov"],
         "pylint.importStrategy": "fromEnvironment",
-        "python.analysis.typeCheckingMode": "basic",
+        // Pyright type checking is not compatible with mypy which Home Assistant uses for type checking
+        "python.analysis.typeCheckingMode": "off",
         "editor.formatOnPaste": false,
         "editor.formatOnSave": true,
         "editor.formatOnType": true,

.github/copilot-instructions.md

@@ -847,8 +847,8 @@ rules:
 ## Development Commands
 
 ### Code Quality & Linting
-- **Run all linters on all files**: `pre-commit run --all-files`
-- **Run linters on staged files only**: `pre-commit run`
+- **Run all linters on all files**: `prek run --all-files`
+- **Run linters on staged files only**: `prek run`
 - **PyLint on everything** (slow): `pylint homeassistant`
 - **PyLint on specific folder**: `pylint homeassistant/components/my_integration`
 - **MyPy type checking (whole project)**: `mypy homeassistant/`
@@ -1024,18 +1024,6 @@ class MyCoordinator(DataUpdateCoordinator[MyData]):
         )
 ```
 
-### Entity Performance Optimization
-```python
-# Use __slots__ for memory efficiency
-class MySensor(SensorEntity):
-    __slots__ = ("_attr_native_value", "_attr_available")
-    
-    @property 
-    def should_poll(self) -> bool:
-        """Disable polling when using coordinator."""
-        return False  # ✅ Let coordinator handle updates
-```
-
 ## Testing Patterns
 
 ### Testing Best Practices
@@ -1181,4 +1169,4 @@ python -m script.hassfest --integration-path homeassistant/components/my_integra
 pytest ./tests/components/my_integration \
   --cov=homeassistant.components.my_integration \
   --cov-report term-missing
-```
+```

.github/workflows/builder.yml

@@ -100,7 +100,7 @@ jobs:
 
       - name: Download nightly wheels of frontend
         if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@ac66b43f0e6a346234dd65d4d0c8fbb31cb316e5 # v11
+        uses: dawidd6/action-download-artifact@0bd50d53a6d7fb5cb921e607957e9cc12b4ce392 # v12
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
           repo: home-assistant/frontend
@@ -111,7 +111,7 @@ jobs:
 
       - name: Download nightly wheels of intents
         if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@ac66b43f0e6a346234dd65d4d0c8fbb31cb316e5 # v11
+        uses: dawidd6/action-download-artifact@0bd50d53a6d7fb5cb921e607957e9cc12b4ce392 # v12
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
           repo: OHF-Voice/intents-package
@@ -197,7 +197,7 @@ jobs:
           cosign-release: "v2.5.3"
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@e468171a9de216ec08956ac3ada2f0791b6bd435 # v3.11.1
+        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.12.0
 
       - name: Build variables
         id: vars
@@ -405,7 +405,7 @@ jobs:
             type=semver,pattern={{major}}.{{minor}},value=${{ needs.init.outputs.version }},enable=${{ !contains(needs.init.outputs.version, 'd') && !contains(needs.init.outputs.version, 'b') }}
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@e468171a9de216ec08956ac3ada2f0791b6bd435 # v3.7.1
+        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.7.1
 
       - name: Copy architecture images to DockerHub
         if: matrix.registry == 'docker.io/homeassistant'
@@ -551,7 +551,7 @@ jobs:
 
       - name: Generate artifact attestation
         if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
-        uses: actions/attest-build-provenance@977bb373ede98d70efdf65b84cb5f73e068dcc2a # v3.0.0
+        uses: actions/attest-build-provenance@00014ed6ed5efc5b1ab7f7f34a39eb55d41aa4f8 # v3.1.0
         with:
           subject-name: ${{ env.HASSFEST_IMAGE_NAME }}
           subject-digest: ${{ steps.push.outputs.digest }}

.github/workflows/ci.yaml

@@ -40,7 +40,7 @@ env:
   CACHE_VERSION: 2
   UV_CACHE_VERSION: 1
   MYPY_CACHE_VERSION: 1
-  HA_SHORT_VERSION: "2026.1"
+  HA_SHORT_VERSION: "2026.2"
   DEFAULT_PYTHON: "3.13.11"
   ALL_PYTHON_VERSIONS: "['3.13.11', '3.14.2']"
   # 10.3 is the oldest supported version
@@ -59,7 +59,6 @@ env:
   # 15 is the latest version
   # - 15.2 is the latest (as of 9 Feb 2023)
   POSTGRESQL_VERSIONS: "['postgres:12.14','postgres:15.2']"
-  PRE_COMMIT_CACHE: ~/.cache/pre-commit
   UV_CACHE_DIR: /tmp/uv-cache
   APT_CACHE_BASE: /home/runner/work/apt
   APT_CACHE_DIR: /home/runner/work/apt/cache
@@ -83,7 +82,6 @@ jobs:
       integrations_glob: ${{ steps.info.outputs.integrations_glob }}
       integrations: ${{ steps.integrations.outputs.changes }}
       apt_cache_key: ${{ steps.generate_apt_cache_key.outputs.key }}
-      pre-commit_cache_key: ${{ steps.generate_pre-commit_cache_key.outputs.key }}
       python_cache_key: ${{ steps.generate_python_cache_key.outputs.key }}
       requirements: ${{ steps.core.outputs.requirements }}
       mariadb_groups: ${{ steps.info.outputs.mariadb_groups }}
@@ -111,11 +109,6 @@ jobs:
             hashFiles('requirements_all.txt') }}-${{
             hashFiles('homeassistant/package_constraints.txt') }}-${{
             hashFiles('script/gen_requirements_all.py') }}" >> $GITHUB_OUTPUT
-      - name: Generate partial pre-commit restore key
-        id: generate_pre-commit_cache_key
-        run: >-
-          echo "key=pre-commit-${{ env.CACHE_VERSION }}-${{
-            hashFiles('.pre-commit-config.yaml') }}"  >> $GITHUB_OUTPUT
       - name: Generate partial apt restore key
         id: generate_apt_cache_key
         run: |
@@ -244,8 +237,8 @@ jobs:
           echo "skip_coverage: ${skip_coverage}"
           echo "skip_coverage=${skip_coverage}" >> $GITHUB_OUTPUT
 
-  pre-commit:
-    name: Prepare pre-commit base
+  prek:
+    name: Run prek checks
     runs-on: *runs-on-ubuntu
     needs: [info]
     if: |
@@ -254,147 +247,23 @@ jobs:
       && github.event.inputs.audit-licenses-only != 'true'
     steps:
       - *checkout
-      - &setup-python-default
-        name: Set up Python ${{ env.DEFAULT_PYTHON }}
-        id: python
-        uses: &actions-setup-python actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
-        with:
-          python-version: ${{ env.DEFAULT_PYTHON }}
-          check-latest: true
-      - name: Restore base Python virtual environment
-        id: cache-venv
-        uses: &actions-cache actions/cache@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
-        with:
-          path: venv
-          key: &key-pre-commit-venv >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ steps.python.outputs.python-version }}-venv-${{
-              needs.info.outputs.pre-commit_cache_key }}
-      - name: Create Python virtual environment
-        if: steps.cache-venv.outputs.cache-hit != 'true'
-        run: |
-          python -m venv venv
-          . venv/bin/activate
-          python --version
-          pip install "$(grep '^uv' < requirements.txt)"
-          uv pip install "$(cat requirements_test.txt | grep pre-commit)"
-      - name: Restore pre-commit environment from cache
-        id: cache-precommit
-        uses: *actions-cache
-        with:
-          path: ${{ env.PRE_COMMIT_CACHE }}
-          lookup-only: true
-          key: &key-pre-commit-env >-
-            ${{ runner.os }}-${{ runner.arch }}-${{ steps.python.outputs.python-version }}-${{
-              needs.info.outputs.pre-commit_cache_key }}
-      - name: Install pre-commit dependencies
-        if: steps.cache-precommit.outputs.cache-hit != 'true'
-        run: |
-          . venv/bin/activate
-          pre-commit install-hooks
-
-  lint-ruff-format:
-    name: Check ruff-format
-    runs-on: *runs-on-ubuntu
-    needs: &needs-pre-commit
-      - info
-      - pre-commit
-    steps:
-      - *checkout
-      - *setup-python-default
-      - &cache-restore-pre-commit-venv
-        name: Restore base Python virtual environment
-        id: cache-venv
-        uses: &actions-cache-restore actions/cache/restore@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
-        with:
-          path: venv
-          fail-on-cache-miss: true
-          key: *key-pre-commit-venv
-      - &cache-restore-pre-commit-env
-        name: Restore pre-commit environment from cache
-        id: cache-precommit
-        uses: *actions-cache-restore
-        with:
-          path: ${{ env.PRE_COMMIT_CACHE }}
-          fail-on-cache-miss: true
-          key: *key-pre-commit-env
-      - name: Run ruff-format
-        run: |
-          . venv/bin/activate
-          pre-commit run --hook-stage manual ruff-format --all-files --show-diff-on-failure
-        env:
-          RUFF_OUTPUT_FORMAT: github
-
-  lint-ruff:
-    name: Check ruff
-    runs-on: *runs-on-ubuntu
-    needs: *needs-pre-commit
-    steps:
-      - *checkout
-      - *setup-python-default
-      - *cache-restore-pre-commit-venv
-      - *cache-restore-pre-commit-env
-      - name: Run ruff
-        run: |
-          . venv/bin/activate
-          pre-commit run --hook-stage manual ruff-check --all-files --show-diff-on-failure
-        env:
-          RUFF_OUTPUT_FORMAT: github
-
-  lint-other:
-    name: Check other linters
-    runs-on: *runs-on-ubuntu
-    needs: *needs-pre-commit
-    steps:
-      - *checkout
-      - *setup-python-default
-      - *cache-restore-pre-commit-venv
-      - *cache-restore-pre-commit-env
-
       - name: Register yamllint problem matcher
         run: |
           echo "::add-matcher::.github/workflows/matchers/yamllint.json"
-      - name: Run yamllint
-        run: |
-          . venv/bin/activate
-          pre-commit run --hook-stage manual yamllint --all-files --show-diff-on-failure
-
       - name: Register check-json problem matcher
         run: |
           echo "::add-matcher::.github/workflows/matchers/check-json.json"
-      - name: Run check-json
-        run: |
-          . venv/bin/activate
-          pre-commit run --hook-stage manual check-json --all-files --show-diff-on-failure
-
-      - name: Run prettier (fully)
-        if: needs.info.outputs.test_full_suite == 'true'
-        run: |
-          . venv/bin/activate
-          pre-commit run --hook-stage manual prettier --all-files --show-diff-on-failure
-
-      - name: Run prettier (partially)
-        if: needs.info.outputs.test_full_suite == 'false'
-        shell: bash
-        run: |
-          . venv/bin/activate
-          shopt -s globstar
-          pre-commit run --hook-stage manual prettier --show-diff-on-failure --files {homeassistant,tests}/components/${{ needs.info.outputs.integrations_glob }}/{*,**/*}
-
       - name: Register check executables problem matcher
         run: |
           echo "::add-matcher::.github/workflows/matchers/check-executables-have-shebangs.json"
-      - name: Run executables check
-        run: |
-          . venv/bin/activate
-          pre-commit run --hook-stage manual check-executables-have-shebangs --all-files --show-diff-on-failure
-
       - name: Register codespell problem matcher
         run: |
           echo "::add-matcher::.github/workflows/matchers/codespell.json"
-      - name: Run codespell
-        run: |
-          . venv/bin/activate
-          pre-commit run --show-diff-on-failure --hook-stage manual codespell --all-files
+      - name: Run prek
+        uses: j178/prek-action@9d6a3097e0c1865ecce00cfb89fe80f2ee91b547 # v1.0.12
+        env:
+          PREK_SKIP: no-commit-to-branch,mypy,pylint,gen_requirements_all,hassfest,hassfest-metadata,hassfest-mypy-config
+          RUFF_OUTPUT_FORMAT: github
 
   lint-hadolint:
     name: Check ${{ matrix.file }}
@@ -434,7 +303,7 @@ jobs:
       - &setup-python-matrix
         name: Set up Python ${{ matrix.python-version }}
         id: python
-        uses: *actions-setup-python
+        uses: &actions-setup-python actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
         with:
           python-version: ${{ matrix.python-version }}
           check-latest: true
@@ -447,7 +316,7 @@ jobs:
             env.HA_SHORT_VERSION }}-$(date -u '+%Y-%m-%dT%H:%M:%s')" >> $GITHUB_OUTPUT
       - name: Restore base Python virtual environment
         id: cache-venv
-        uses: *actions-cache
+        uses: &actions-cache actions/cache@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
         with:
           path: venv
           key: &key-python-venv >-
@@ -562,7 +431,7 @@ jobs:
     steps:
       - &cache-restore-apt
         name: Restore apt cache
-        uses: *actions-cache-restore
+        uses: &actions-cache-restore actions/cache/restore@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
         with:
           path: *path-apt-cache
           fail-on-cache-miss: true
@@ -579,7 +448,13 @@ jobs:
             -o Dir::State::Lists=${{ env.APT_LIST_CACHE_DIR }} \
             libturbojpeg
       - *checkout
-      - *setup-python-default
+      - &setup-python-default
+        name: Set up Python ${{ env.DEFAULT_PYTHON }}
+        id: python
+        uses: *actions-setup-python
+        with:
+          python-version: ${{ env.DEFAULT_PYTHON }}
+          check-latest: true
       - &cache-restore-python-default
         name: Restore full Python ${{ env.DEFAULT_PYTHON }} virtual environment
         id: cache-venv
@@ -782,9 +657,7 @@ jobs:
       - base
       - gen-requirements-all
       - hassfest
-      - lint-other
-      - lint-ruff
-      - lint-ruff-format
+      - prek
       - mypy
     steps:
       - *cache-restore-apt
@@ -823,9 +696,7 @@ jobs:
       - base
       - gen-requirements-all
       - hassfest
-      - lint-other
-      - lint-ruff
-      - lint-ruff-format
+      - prek
       - mypy
       - prepare-pytest-full
     if: |
@@ -949,9 +820,7 @@ jobs:
       - base
       - gen-requirements-all
       - hassfest
-      - lint-other
-      - lint-ruff
-      - lint-ruff-format
+      - prek
       - mypy
     if: |
       needs.info.outputs.lint_only != 'true'
@@ -1066,9 +935,7 @@ jobs:
       - base
       - gen-requirements-all
       - hassfest
-      - lint-other
-      - lint-ruff
-      - lint-ruff-format
+      - prek
       - mypy
     if: |
       needs.info.outputs.lint_only != 'true'
@@ -1202,9 +1069,7 @@ jobs:
       - base
       - gen-requirements-all
       - hassfest
-      - lint-other
-      - lint-ruff
-      - lint-ruff-format
+      - prek
       - mypy
     if: |
       needs.info.outputs.lint_only != 'true'

.github/workflows/codeql.yml

@@ -24,11 +24,11 @@ jobs:
         uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@1b168cd39490f61582a9beae412bb7057a6b2c4e # v4.31.8
+        uses: github/codeql-action/init@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v4.31.10
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@1b168cd39490f61582a9beae412bb7057a6b2c4e # v4.31.8
+        uses: github/codeql-action/analyze@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v4.31.10
         with:
           category: "/language:python"

.gitignore

@@ -92,6 +92,7 @@ pip-selfcheck.json
 venv
 .venv
 Pipfile*
+uv.lock
 share/*
 /Scripts/
 

.pre-commit-config.yaml

@@ -39,14 +39,14 @@ repos:
       - id: prettier
         additional_dependencies:
           - prettier@3.6.2
-          - prettier-plugin-sort-json@4.1.1
+          - prettier-plugin-sort-json@4.2.0
   - repo: https://github.com/cdce8p/python-typing-update
     rev: v0.6.0
     hooks:
       # Run `python-typing-update` hook manually from time to time
       # to update python typing syntax.
       # Will require manual work, before submitting changes!
-      # pre-commit run --hook-stage manual python-typing-update --all-files
+      # prek run --hook-stage manual python-typing-update --all-files
       - id: python-typing-update
         stages: [manual]
         args:

.strict-typing

@@ -407,6 +407,7 @@ homeassistant.components.person.*
 homeassistant.components.pi_hole.*
 homeassistant.components.ping.*
 homeassistant.components.plugwise.*
+homeassistant.components.pooldose.*
 homeassistant.components.portainer.*
 homeassistant.components.powerfox.*
 homeassistant.components.powerwall.*
@@ -567,6 +568,7 @@ homeassistant.components.wake_word.*
 homeassistant.components.wallbox.*
 homeassistant.components.waqi.*
 homeassistant.components.water_heater.*
+homeassistant.components.watts.*
 homeassistant.components.watttime.*
 homeassistant.components.weather.*
 homeassistant.components.webhook.*

.vscode/settings.default.jsonc

@@ -7,8 +7,8 @@
   "python.testing.pytestEnabled": false,
   // https://code.visualstudio.com/docs/python/linting#_general-settings
   "pylint.importStrategy": "fromEnvironment",
-  // Pyright is too pedantic for Home Assistant
-  "python.analysis.typeCheckingMode": "basic",
+  // Pyright type checking is not compatible with mypy which Home Assistant uses for type checking
+  "python.analysis.typeCheckingMode": "off",
   "[python]": {
     "editor.defaultFormatter": "charliermarsh.ruff",
   },

.vscode/tasks.json

@@ -45,7 +45,7 @@
     {
       "label": "Ruff",
       "type": "shell",
-      "command": "pre-commit run ruff-check --all-files",
+      "command": "prek run ruff-check --all-files",
       "group": {
         "kind": "test",
         "isDefault": true
@@ -57,9 +57,9 @@
       "problemMatcher": []
     },
     {
-      "label": "Pre-commit",
+      "label": "Prek",
       "type": "shell",
-      "command": "pre-commit run --show-diff-on-failure",
+      "command": "prek run --show-diff-on-failure",
       "group": {
         "kind": "test",
         "isDefault": true
@@ -120,7 +120,7 @@
     {
       "label": "Generate Requirements",
       "type": "shell",
-      "command": "./script/gen_requirements_all.py",
+      "command": "${command:python.interpreterPath} -m script.gen_requirements_all",
       "group": {
         "kind": "build",
         "isDefault": true

CODEOWNERS

@@ -516,6 +516,8 @@ build.json @home-assistant/supervisor
 /tests/components/fireservicerota/ @cyberjunky
 /homeassistant/components/firmata/ @DaAwesomeP
 /tests/components/firmata/ @DaAwesomeP
+/homeassistant/components/fish_audio/ @noambav
+/tests/components/fish_audio/ @noambav
 /homeassistant/components/fitbit/ @allenporter
 /tests/components/fitbit/ @allenporter
 /homeassistant/components/fivem/ @Sander0542
@@ -530,6 +532,8 @@ build.json @home-assistant/supervisor
 /tests/components/flo/ @dmulcahey
 /homeassistant/components/flume/ @ChrisMandich @bdraco @jeeftor
 /tests/components/flume/ @ChrisMandich @bdraco @jeeftor
+/homeassistant/components/fluss/ @fluss
+/tests/components/fluss/ @fluss
 /homeassistant/components/flux_led/ @icemanch
 /tests/components/flux_led/ @icemanch
 /homeassistant/components/forecast_solar/ @klaasnicolaas @frenck
@@ -657,6 +661,8 @@ build.json @home-assistant/supervisor
 /tests/components/harmony/ @ehendrix23 @bdraco @mkeesey @Aohzan
 /homeassistant/components/hassio/ @home-assistant/supervisor
 /tests/components/hassio/ @home-assistant/supervisor
+/homeassistant/components/hdfury/ @glenndehaan
+/tests/components/hdfury/ @glenndehaan
 /homeassistant/components/hdmi_cec/ @inytar
 /tests/components/hdmi_cec/ @inytar
 /homeassistant/components/heatmiser/ @andylockran
@@ -664,8 +670,8 @@ build.json @home-assistant/supervisor
 /tests/components/heos/ @andrewsayre
 /homeassistant/components/here_travel_time/ @eifinger
 /tests/components/here_travel_time/ @eifinger
-/homeassistant/components/hikvision/ @mezz64
-/tests/components/hikvision/ @mezz64
+/homeassistant/components/hikvision/ @mezz64 @ptarjan
+/tests/components/hikvision/ @mezz64 @ptarjan
 /homeassistant/components/hikvisioncam/ @fbradyirl
 /homeassistant/components/hisense_aehw4a1/ @bannhead
 /tests/components/hisense_aehw4a1/ @bannhead
@@ -794,6 +800,8 @@ build.json @home-assistant/supervisor
 /tests/components/intellifire/ @jeeftor
 /homeassistant/components/intent/ @home-assistant/core @synesthesiam @arturpragacz
 /tests/components/intent/ @home-assistant/core @synesthesiam @arturpragacz
+/homeassistant/components/intent_script/ @arturpragacz
+/tests/components/intent_script/ @arturpragacz
 /homeassistant/components/intesishome/ @jnimmo
 /homeassistant/components/iometer/ @jukrebs
 /tests/components/iometer/ @jukrebs
@@ -1060,6 +1068,8 @@ build.json @home-assistant/supervisor
 /tests/components/myuplink/ @pajzo @astrandb
 /homeassistant/components/nam/ @bieniu
 /tests/components/nam/ @bieniu
+/homeassistant/components/namecheapdns/ @tr4nt0r
+/tests/components/namecheapdns/ @tr4nt0r
 /homeassistant/components/nanoleaf/ @milanmeu @joostlek
 /tests/components/nanoleaf/ @milanmeu @joostlek
 /homeassistant/components/nasweb/ @nasWebio
@@ -1164,6 +1174,8 @@ build.json @home-assistant/supervisor
 /tests/components/open_router/ @joostlek
 /homeassistant/components/openerz/ @misialq
 /tests/components/openerz/ @misialq
+/homeassistant/components/openevse/ @c00w @firstof9
+/tests/components/openevse/ @c00w @firstof9
 /homeassistant/components/openexchangerates/ @MartinHjelmare
 /tests/components/openexchangerates/ @MartinHjelmare
 /homeassistant/components/opengarage/ @danielhiversen
@@ -1195,8 +1207,8 @@ build.json @home-assistant/supervisor
 /tests/components/ourgroceries/ @OnFreund
 /homeassistant/components/overkiz/ @imicknl
 /tests/components/overkiz/ @imicknl
-/homeassistant/components/overseerr/ @joostlek
-/tests/components/overseerr/ @joostlek
+/homeassistant/components/overseerr/ @joostlek @AmGarera
+/tests/components/overseerr/ @joostlek @AmGarera
 /homeassistant/components/ovo_energy/ @timmo001
 /tests/components/ovo_energy/ @timmo001
 /homeassistant/components/p1_monitor/ @klaasnicolaas
@@ -1693,8 +1705,8 @@ build.json @home-assistant/supervisor
 /tests/components/trafikverket_train/ @gjohansson-ST
 /homeassistant/components/trafikverket_weatherstation/ @gjohansson-ST
 /tests/components/trafikverket_weatherstation/ @gjohansson-ST
-/homeassistant/components/transmission/ @engrbm87 @JPHutchins
-/tests/components/transmission/ @engrbm87 @JPHutchins
+/homeassistant/components/transmission/ @engrbm87 @JPHutchins @andrew-codechimp
+/tests/components/transmission/ @engrbm87 @JPHutchins @andrew-codechimp
 /homeassistant/components/trend/ @jpbede
 /tests/components/trend/ @jpbede
 /homeassistant/components/triggercmd/ @rvmey
@@ -1795,9 +1807,12 @@ build.json @home-assistant/supervisor
 /tests/components/waqi/ @joostlek
 /homeassistant/components/water_heater/ @home-assistant/core
 /tests/components/water_heater/ @home-assistant/core
+/homeassistant/components/waterfurnace/ @sdague @masterkoppa
 /homeassistant/components/watergate/ @adam-the-hero
 /tests/components/watergate/ @adam-the-hero
 /homeassistant/components/watson_tts/ @rutkai
+/homeassistant/components/watts/ @theobld-ww @devender-verma-ww @ssi-spyro
+/tests/components/watts/ @theobld-ww @devender-verma-ww @ssi-spyro
 /homeassistant/components/watttime/ @bachya
 /tests/components/watttime/ @bachya
 /homeassistant/components/waze_travel_time/ @eifinger

Dockerfile

@@ -24,7 +24,7 @@ ENV \
 COPY rootfs /
 
 # Add go2rtc binary
-COPY --from=ghcr.io/alexxit/go2rtc@sha256:baef0aa19d759fcfd31607b34ce8eaf039d496282bba57731e6ae326896d7640 /usr/local/bin/go2rtc /bin/go2rtc
+COPY --from=ghcr.io/alexxit/go2rtc@sha256:f394f6329f5389a4c9a7fc54b09fdec9621bbb78bf7a672b973440bbdfb02241 /usr/local/bin/go2rtc /bin/go2rtc
 
 RUN \
     # Verify go2rtc can be executed

homeassistant/auth/__init__.py

@@ -402,6 +402,8 @@ class AuthManager:
         if user.is_owner:
             raise ValueError("Unable to deactivate the owner")
         await self._store.async_deactivate_user(user)
+        for refresh_token in list(user.refresh_tokens.values()):
+            self.async_remove_refresh_token(refresh_token)
 
     async def async_remove_credentials(self, credentials: models.Credentials) -> None:
         """Remove credentials."""

homeassistant/components/accuweather/manifest.json

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

homeassistant/components/actron_air/__init__.py

@@ -18,7 +18,7 @@ from .coordinator import (
     ActronAirSystemCoordinator,
 )
 
-PLATFORM = [Platform.CLIMATE]
+PLATFORMS = [Platform.CLIMATE, Platform.SWITCH]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ActronAirConfigEntry) -> bool:
@@ -50,10 +50,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: ActronAirConfigEntry) ->
         system_coordinators=system_coordinators,
     )
 
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORM)
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
     return True
 
 
 async def async_unload_entry(hass: HomeAssistant, entry: ActronAirConfigEntry) -> bool:
     """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORM)
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/actron_air/climate.py

@@ -15,12 +15,10 @@ from homeassistant.components.climate import (
 )
 from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
 from homeassistant.core import HomeAssistant
-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 ActronAirConfigEntry, ActronAirSystemCoordinator
+from .entity import ActronAirAcEntity, ActronAirZoneEntity
 
 PARALLEL_UPDATES = 0
 
@@ -56,8 +54,7 @@ async def async_setup_entry(
 
     for coordinator in system_coordinators.values():
         status = coordinator.data
-        name = status.ac_system.system_name
-        entities.append(ActronSystemClimate(coordinator, name))
+        entities.append(ActronSystemClimate(coordinator))
 
         entities.extend(
             ActronZoneClimate(coordinator, zone)
@@ -68,10 +65,9 @@ async def async_setup_entry(
     async_add_entities(entities)
 
 
-class BaseClimateEntity(CoordinatorEntity[ActronAirSystemCoordinator], ClimateEntity):
+class ActronAirClimateEntity(ClimateEntity):
     """Base class for Actron Air climate entities."""
 
-    _attr_has_entity_name = True
     _attr_temperature_unit = UnitOfTemperature.CELSIUS
     _attr_supported_features = (
         ClimateEntityFeature.TARGET_TEMPERATURE
@@ -83,43 +79,17 @@ class BaseClimateEntity(CoordinatorEntity[ActronAirSystemCoordinator], ClimateEn
     _attr_fan_modes = list(FAN_MODE_MAPPING_ACTRONAIR_TO_HA.values())
     _attr_hvac_modes = list(HVAC_MODE_MAPPING_ACTRONAIR_TO_HA.values())
 
+
+class ActronSystemClimate(ActronAirAcEntity, ActronAirClimateEntity):
+    """Representation of the Actron Air system."""
+
     def __init__(
         self,
         coordinator: ActronAirSystemCoordinator,
-        name: str,
     ) -> None:
         """Initialize an Actron Air unit."""
         super().__init__(coordinator)
-        self._serial_number = coordinator.serial_number
-
-
-class ActronSystemClimate(BaseClimateEntity):
-    """Representation of the Actron Air system."""
-
-    _attr_supported_features = (
-        ClimateEntityFeature.TARGET_TEMPERATURE
-        | ClimateEntityFeature.FAN_MODE
-        | ClimateEntityFeature.TURN_ON
-        | ClimateEntityFeature.TURN_OFF
-    )
-
-    def __init__(
-        self,
-        coordinator: ActronAirSystemCoordinator,
-        name: str,
-    ) -> None:
-        """Initialize an Actron Air unit."""
-        super().__init__(coordinator, name)
-        serial_number = coordinator.serial_number
-        self._attr_unique_id = serial_number
-        self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, serial_number)},
-            name=self._status.ac_system.system_name,
-            manufacturer="Actron Air",
-            model_id=self._status.ac_system.master_wc_model,
-            sw_version=self._status.ac_system.master_wc_firmware_version,
-            serial_number=serial_number,
-        )
+        self._attr_unique_id = self._serial_number
 
     @property
     def min_temp(self) -> float:
@@ -148,7 +118,7 @@ class ActronSystemClimate(BaseClimateEntity):
     @property
     def fan_mode(self) -> str | None:
         """Return the current fan mode."""
-        fan_mode = self._status.user_aircon_settings.fan_mode
+        fan_mode = self._status.user_aircon_settings.base_fan_mode
         return FAN_MODE_MAPPING_ACTRONAIR_TO_HA.get(fan_mode)
 
     @property
@@ -168,7 +138,7 @@ class ActronSystemClimate(BaseClimateEntity):
 
     async def async_set_fan_mode(self, fan_mode: str) -> None:
         """Set a new fan mode."""
-        api_fan_mode = FAN_MODE_MAPPING_HA_TO_ACTRONAIR.get(fan_mode.lower())
+        api_fan_mode = FAN_MODE_MAPPING_HA_TO_ACTRONAIR.get(fan_mode)
         await self._status.user_aircon_settings.set_fan_mode(api_fan_mode)
 
     async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
@@ -182,7 +152,7 @@ class ActronSystemClimate(BaseClimateEntity):
         await self._status.user_aircon_settings.set_temperature(temperature=temp)
 
 
-class ActronZoneClimate(BaseClimateEntity):
+class ActronZoneClimate(ActronAirZoneEntity, ActronAirClimateEntity):
     """Representation of a zone within the Actron Air system."""
 
     _attr_supported_features = (
@@ -197,18 +167,8 @@ class ActronZoneClimate(BaseClimateEntity):
         zone: ActronAirZone,
     ) -> None:
         """Initialize an Actron Air unit."""
-        super().__init__(coordinator, zone.title)
-        serial_number = coordinator.serial_number
-        self._zone_id: int = zone.zone_id
-        self._attr_unique_id: str = f"{serial_number}_zone_{zone.zone_id}"
-        self._attr_device_info: DeviceInfo = DeviceInfo(
-            identifiers={(DOMAIN, self._attr_unique_id)},
-            name=zone.title,
-            manufacturer="Actron Air",
-            model="Zone",
-            suggested_area=zone.title,
-            via_device=(DOMAIN, serial_number),
-        )
+        super().__init__(coordinator, zone)
+        self._attr_unique_id: str = self._zone_identifier
 
     @property
     def min_temp(self) -> float:
@@ -256,4 +216,4 @@ class ActronZoneClimate(BaseClimateEntity):
 
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set the temperature."""
-        await self._zone.set_temperature(temperature=kwargs["temperature"])
+        await self._zone.set_temperature(temperature=kwargs.get(ATTR_TEMPERATURE))

homeassistant/components/actron_air/coordinator.py

@@ -8,6 +8,7 @@ from datetime import timedelta
 from actron_neo_api import (
     ActronAirACSystem,
     ActronAirAPI,
+    ActronAirAPIError,
     ActronAirAuthError,
     ActronAirStatus,
 )
@@ -15,7 +16,7 @@ from actron_neo_api import (
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 from homeassistant.util import dt as dt_util
 
 from .const import _LOGGER, DOMAIN
@@ -70,6 +71,12 @@ class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirACSystem]):
                 translation_domain=DOMAIN,
                 translation_key="auth_error",
             ) from err
+        except ActronAirAPIError as err:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="update_error",
+                translation_placeholders={"error": repr(err)},
+            ) from err
 
         self.status = self.api.state_manager.get_status(self.serial_number)
         self.last_seen = dt_util.utcnow()

homeassistant/components/actron_air/entity.py

@@ -0,0 +1,63 @@
+"""Base entity classes for Actron Air integration."""
+
+from actron_neo_api import ActronAirZone
+
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import ActronAirSystemCoordinator
+
+
+class ActronAirEntity(CoordinatorEntity[ActronAirSystemCoordinator]):
+    """Base class for Actron Air entities."""
+
+    _attr_has_entity_name = True
+
+    def __init__(self, coordinator: ActronAirSystemCoordinator) -> None:
+        """Initialize the entity."""
+        super().__init__(coordinator)
+        self._serial_number = coordinator.serial_number
+
+    @property
+    def available(self) -> bool:
+        """Return True if entity is available."""
+        return not self.coordinator.is_device_stale()
+
+
+class ActronAirAcEntity(ActronAirEntity):
+    """Base class for Actron Air entities."""
+
+    def __init__(self, coordinator: ActronAirSystemCoordinator) -> None:
+        """Initialize the entity."""
+        super().__init__(coordinator)
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, self._serial_number)},
+            name=coordinator.data.ac_system.system_name,
+            manufacturer="Actron Air",
+            model_id=coordinator.data.ac_system.master_wc_model,
+            sw_version=coordinator.data.ac_system.master_wc_firmware_version,
+            serial_number=self._serial_number,
+        )
+
+
+class ActronAirZoneEntity(ActronAirEntity):
+    """Base class for Actron Air zone entities."""
+
+    def __init__(
+        self,
+        coordinator: ActronAirSystemCoordinator,
+        zone: ActronAirZone,
+    ) -> None:
+        """Initialize the entity."""
+        super().__init__(coordinator)
+        self._zone_id: int = zone.zone_id
+        self._zone_identifier = f"{self._serial_number}_zone_{zone.zone_id}"
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, self._zone_identifier)},
+            name=zone.title,
+            manufacturer="Actron Air",
+            model="Zone",
+            suggested_area=zone.title,
+            via_device=(DOMAIN, self._serial_number),
+        )

homeassistant/components/actron_air/icons.json

@@ -0,0 +1,30 @@
+{
+  "entity": {
+    "switch": {
+      "away_mode": {
+        "default": "mdi:home-export-outline",
+        "state": {
+          "off": "mdi:home-import-outline"
+        }
+      },
+      "continuous_fan": {
+        "default": "mdi:fan",
+        "state": {
+          "off": "mdi:fan-off"
+        }
+      },
+      "quiet_mode": {
+        "default": "mdi:volume-low",
+        "state": {
+          "off": "mdi:volume-high"
+        }
+      },
+      "turbo_mode": {
+        "default": "mdi:fan-plus",
+        "state": {
+          "off": "mdi:fan"
+        }
+      }
+    }
+  }
+}

homeassistant/components/actron_air/manifest.json

@@ -13,5 +13,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "quality_scale": "bronze",
-  "requirements": ["actron-neo-api==0.2.0"]
+  "requirements": ["actron-neo-api==0.4.1"]
 }

homeassistant/components/actron_air/strings.json

@@ -32,9 +32,28 @@
       }
     }
   },
+  "entity": {
+    "switch": {
+      "away_mode": {
+        "name": "Away mode"
+      },
+      "continuous_fan": {
+        "name": "Continuous fan"
+      },
+      "quiet_mode": {
+        "name": "Quiet mode"
+      },
+      "turbo_mode": {
+        "name": "Turbo mode"
+      }
+    }
+  },
   "exceptions": {
     "auth_error": {
       "message": "Authentication failed, please reauthenticate"
+    },
+    "update_error": {
+      "message": "An error occurred while retrieving data from the Actron Air API: {error}"
     }
   }
 }

homeassistant/components/actron_air/switch.py

@@ -0,0 +1,102 @@
+"""Switch platform for Actron Air integration."""
+
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from typing import Any
+
+from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
+from homeassistant.const import EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import ActronAirConfigEntry, ActronAirSystemCoordinator
+from .entity import ActronAirAcEntity
+
+PARALLEL_UPDATES = 0
+
+
+@dataclass(frozen=True, kw_only=True)
+class ActronAirSwitchEntityDescription(SwitchEntityDescription):
+    """Class describing Actron Air switch entities."""
+
+    is_on_fn: Callable[[ActronAirSystemCoordinator], bool]
+    set_fn: Callable[[ActronAirSystemCoordinator, bool], Awaitable[None]]
+    is_supported_fn: Callable[[ActronAirSystemCoordinator], bool] = lambda _: True
+
+
+SWITCHES: tuple[ActronAirSwitchEntityDescription, ...] = (
+    ActronAirSwitchEntityDescription(
+        key="away_mode",
+        translation_key="away_mode",
+        is_on_fn=lambda coordinator: coordinator.data.user_aircon_settings.away_mode,
+        set_fn=lambda coordinator,
+        enabled: coordinator.data.user_aircon_settings.set_away_mode(enabled),
+    ),
+    ActronAirSwitchEntityDescription(
+        key="continuous_fan",
+        translation_key="continuous_fan",
+        is_on_fn=lambda coordinator: coordinator.data.user_aircon_settings.continuous_fan_enabled,
+        set_fn=lambda coordinator,
+        enabled: coordinator.data.user_aircon_settings.set_continuous_mode(enabled),
+    ),
+    ActronAirSwitchEntityDescription(
+        key="quiet_mode",
+        translation_key="quiet_mode",
+        is_on_fn=lambda coordinator: coordinator.data.user_aircon_settings.quiet_mode_enabled,
+        set_fn=lambda coordinator,
+        enabled: coordinator.data.user_aircon_settings.set_quiet_mode(enabled),
+    ),
+    ActronAirSwitchEntityDescription(
+        key="turbo_mode",
+        translation_key="turbo_mode",
+        is_on_fn=lambda coordinator: coordinator.data.user_aircon_settings.turbo_enabled,
+        set_fn=lambda coordinator,
+        enabled: coordinator.data.user_aircon_settings.set_turbo_mode(enabled),
+        is_supported_fn=lambda coordinator: coordinator.data.user_aircon_settings.turbo_supported,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: ActronAirConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Actron Air switch entities."""
+    system_coordinators = entry.runtime_data.system_coordinators
+    async_add_entities(
+        ActronAirSwitch(coordinator, description)
+        for coordinator in system_coordinators.values()
+        for description in SWITCHES
+        if description.is_supported_fn(coordinator)
+    )
+
+
+class ActronAirSwitch(ActronAirAcEntity, SwitchEntity):
+    """Actron Air switch."""
+
+    _attr_entity_category = EntityCategory.CONFIG
+    entity_description: ActronAirSwitchEntityDescription
+
+    def __init__(
+        self,
+        coordinator: ActronAirSystemCoordinator,
+        description: ActronAirSwitchEntityDescription,
+    ) -> None:
+        """Initialize the switch."""
+        super().__init__(coordinator)
+        self.entity_description = description
+        self._attr_unique_id = f"{coordinator.serial_number}_{description.key}"
+
+    @property
+    def is_on(self) -> bool:
+        """Return true if the switch is on."""
+        return self.entity_description.is_on_fn(self.coordinator)
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Turn the switch on."""
+        await self.entity_description.set_fn(self.coordinator, True)
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn the switch off."""
+        await self.entity_description.set_fn(self.coordinator, False)

homeassistant/components/adax/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/adax",
   "iot_class": "local_polling",
   "loggers": ["adax", "adax_local"],
-  "requirements": ["adax==0.4.0", "Adax-local==0.2.0"]
+  "requirements": ["adax==0.4.0", "Adax-local==0.3.0"]
 }

homeassistant/components/airobot/__init__.py

@@ -7,7 +7,12 @@ from homeassistant.core import HomeAssistant
 
 from .coordinator import AirobotConfigEntry, AirobotDataUpdateCoordinator
 
-PLATFORMS: list[Platform] = [Platform.CLIMATE, Platform.SENSOR]
+PLATFORMS: list[Platform] = [
+    Platform.BUTTON,
+    Platform.CLIMATE,
+    Platform.NUMBER,
+    Platform.SENSOR,
+]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: AirobotConfigEntry) -> bool:

homeassistant/components/airobot/button.py

@@ -0,0 +1,96 @@
+"""Button platform for Airobot integration."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass
+from typing import Any
+
+from pyairobotrest.exceptions import (
+    AirobotConnectionError,
+    AirobotError,
+    AirobotTimeoutError,
+)
+
+from homeassistant.components.button import (
+    ButtonDeviceClass,
+    ButtonEntity,
+    ButtonEntityDescription,
+)
+from homeassistant.const import EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .const import DOMAIN
+from .coordinator import AirobotConfigEntry, AirobotDataUpdateCoordinator
+from .entity import AirobotEntity
+
+PARALLEL_UPDATES = 0
+
+
+@dataclass(frozen=True, kw_only=True)
+class AirobotButtonEntityDescription(ButtonEntityDescription):
+    """Describes Airobot button entity."""
+
+    press_fn: Callable[[AirobotDataUpdateCoordinator], Coroutine[Any, Any, None]]
+
+
+BUTTON_TYPES: tuple[AirobotButtonEntityDescription, ...] = (
+    AirobotButtonEntityDescription(
+        key="restart",
+        device_class=ButtonDeviceClass.RESTART,
+        entity_category=EntityCategory.CONFIG,
+        press_fn=lambda coordinator: coordinator.client.reboot_thermostat(),
+    ),
+    AirobotButtonEntityDescription(
+        key="recalibrate_co2",
+        translation_key="recalibrate_co2",
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+        press_fn=lambda coordinator: coordinator.client.recalibrate_co2_sensor(),
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: AirobotConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Airobot button entities."""
+    coordinator = entry.runtime_data
+
+    async_add_entities(
+        AirobotButton(coordinator, description) for description in BUTTON_TYPES
+    )
+
+
+class AirobotButton(AirobotEntity, ButtonEntity):
+    """Representation of an Airobot button."""
+
+    entity_description: AirobotButtonEntityDescription
+
+    def __init__(
+        self,
+        coordinator: AirobotDataUpdateCoordinator,
+        description: AirobotButtonEntityDescription,
+    ) -> None:
+        """Initialize the button."""
+        super().__init__(coordinator)
+        self.entity_description = description
+        self._attr_unique_id = f"{coordinator.data.status.device_id}_{description.key}"
+
+    async def async_press(self) -> None:
+        """Handle the button press."""
+        try:
+            await self.entity_description.press_fn(self.coordinator)
+        except (AirobotConnectionError, AirobotTimeoutError):
+            # Connection errors during reboot are expected as device restarts
+            pass
+        except AirobotError as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="button_press_failed",
+                translation_placeholders={"button": self.entity_description.key},
+            ) from err

homeassistant/components/airobot/config_flow.py

@@ -175,6 +175,42 @@ class AirobotConfigFlow(BaseConfigFlow, domain=DOMAIN):
             step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
         )
 
+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reconfiguration of the integration."""
+        errors: dict[str, str] = {}
+        reconfigure_entry = self._get_reconfigure_entry()
+
+        if user_input is not None:
+            try:
+                info = await validate_input(self.hass, user_input)
+            except CannotConnect:
+                errors["base"] = "cannot_connect"
+            except InvalidAuth:
+                errors["base"] = "invalid_auth"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                # Verify the device ID matches the existing config entry
+                await self.async_set_unique_id(info.device_id)
+                self._abort_if_unique_id_mismatch(reason="wrong_device")
+
+                return self.async_update_reload_and_abort(
+                    reconfigure_entry,
+                    data_updates=user_input,
+                    title=info.title,
+                )
+
+        return self.async_show_form(
+            step_id="reconfigure",
+            data_schema=self.add_suggested_values_to_schema(
+                STEP_USER_DATA_SCHEMA, reconfigure_entry.data
+            ),
+            errors=errors,
+        )
+
     async def async_step_reauth(
         self, entry_data: Mapping[str, Any]
     ) -> ConfigFlowResult:

homeassistant/components/airobot/icons.json

@@ -0,0 +1,14 @@
+{
+  "entity": {
+    "button": {
+      "recalibrate_co2": {
+        "default": "mdi:molecule-co2"
+      }
+    },
+    "number": {
+      "hysteresis_band": {
+        "default": "mdi:delta"
+      }
+    }
+  }
+}

homeassistant/components/airobot/manifest.json

@@ -12,6 +12,6 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["pyairobotrest"],
-  "quality_scale": "silver",
-  "requirements": ["pyairobotrest==0.1.0"]
+  "quality_scale": "gold",
+  "requirements": ["pyairobotrest==0.2.0"]
 }

homeassistant/components/airobot/number.py

@@ -0,0 +1,99 @@
+"""Number platform for Airobot thermostat."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+
+from pyairobotrest.const import HYSTERESIS_BAND_MAX, HYSTERESIS_BAND_MIN
+from pyairobotrest.exceptions import AirobotError
+
+from homeassistant.components.number import (
+    NumberDeviceClass,
+    NumberEntity,
+    NumberEntityDescription,
+)
+from homeassistant.const import EntityCategory, UnitOfTemperature
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ServiceValidationError
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import AirobotConfigEntry
+from .const import DOMAIN
+from .coordinator import AirobotDataUpdateCoordinator
+from .entity import AirobotEntity
+
+PARALLEL_UPDATES = 0
+
+
+@dataclass(frozen=True, kw_only=True)
+class AirobotNumberEntityDescription(NumberEntityDescription):
+    """Describes Airobot number entity."""
+
+    value_fn: Callable[[AirobotDataUpdateCoordinator], float]
+    set_value_fn: Callable[[AirobotDataUpdateCoordinator, float], Awaitable[None]]
+
+
+NUMBERS: tuple[AirobotNumberEntityDescription, ...] = (
+    AirobotNumberEntityDescription(
+        key="hysteresis_band",
+        translation_key="hysteresis_band",
+        device_class=NumberDeviceClass.TEMPERATURE,
+        entity_category=EntityCategory.CONFIG,
+        entity_registry_enabled_default=False,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        native_min_value=HYSTERESIS_BAND_MIN / 10.0,
+        native_max_value=HYSTERESIS_BAND_MAX / 10.0,
+        native_step=0.1,
+        value_fn=lambda coordinator: coordinator.data.settings.hysteresis_band,
+        set_value_fn=lambda coordinator, value: coordinator.client.set_hysteresis_band(
+            value
+        ),
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: AirobotConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Airobot number platform."""
+    coordinator = entry.runtime_data
+    async_add_entities(
+        AirobotNumber(coordinator, description) for description in NUMBERS
+    )
+
+
+class AirobotNumber(AirobotEntity, NumberEntity):
+    """Representation of an Airobot number entity."""
+
+    entity_description: AirobotNumberEntityDescription
+
+    def __init__(
+        self,
+        coordinator: AirobotDataUpdateCoordinator,
+        description: AirobotNumberEntityDescription,
+    ) -> None:
+        """Initialize the number entity."""
+        super().__init__(coordinator)
+        self.entity_description = description
+        self._attr_unique_id = f"{coordinator.data.status.device_id}_{description.key}"
+
+    @property
+    def native_value(self) -> float:
+        """Return the current value."""
+        return self.entity_description.value_fn(self.coordinator)
+
+    async def async_set_native_value(self, value: float) -> None:
+        """Set the value."""
+        try:
+            await self.entity_description.set_value_fn(self.coordinator, value)
+        except AirobotError as err:
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="set_value_failed",
+                translation_placeholders={"error": str(err)},
+            ) from err
+        else:
+            await self.coordinator.async_request_refresh()

homeassistant/components/airobot/quality_scale.yaml

@@ -43,12 +43,12 @@ rules:
   discovery-update-info: done
   discovery: done
   docs-data-update: done
-  docs-examples: todo
+  docs-examples: done
   docs-known-limitations: done
   docs-supported-devices: done
   docs-supported-functions: done
   docs-troubleshooting: done
-  docs-use-cases: todo
+  docs-use-cases: done
   dynamic-devices:
     status: exempt
     comment: Single device integration, no dynamic device discovery needed.
@@ -57,8 +57,8 @@ rules:
   entity-disabled-by-default: done
   entity-translations: done
   exception-translations: done
-  icon-translations: todo
-  reconfiguration-flow: todo
+  icon-translations: done
+  reconfiguration-flow: done
   repair-issues:
     status: exempt
     comment: This integration doesn't have any cases where raising an issue is needed.

homeassistant/components/airobot/strings.json

@@ -2,7 +2,9 @@
   "config": {
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
+      "wrong_device": "Device ID does not match the existing configuration. Please use the correct device credentials."
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -28,6 +30,19 @@
         },
         "description": "The authentication for Airobot thermostat at {host} (Device ID: {username}) has expired. Please enter the password to reauthenticate. Find the password in the thermostat settings menu under Connectivity → Mobile app."
       },
+      "reconfigure": {
+        "data": {
+          "host": "[%key:common::config_flow::data::host%]",
+          "password": "[%key:common::config_flow::data::password%]",
+          "username": "Device ID"
+        },
+        "data_description": {
+          "host": "[%key:component::airobot::config::step::user::data_description::host%]",
+          "password": "[%key:component::airobot::config::step::user::data_description::password%]",
+          "username": "[%key:component::airobot::config::step::user::data_description::username%]"
+        },
+        "description": "Update your Airobot thermostat connection details. Note: The Device ID must remain the same as the original configuration."
+      },
       "user": {
         "data": {
           "host": "[%key:common::config_flow::data::host%]",
@@ -44,6 +59,16 @@
     }
   },
   "entity": {
+    "button": {
+      "recalibrate_co2": {
+        "name": "Recalibrate CO2 sensor"
+      }
+    },
+    "number": {
+      "hysteresis_band": {
+        "name": "Hysteresis band"
+      }
+    },
     "sensor": {
       "air_temperature": {
         "name": "Air temperature"
@@ -66,6 +91,9 @@
     "authentication_failed": {
       "message": "Authentication failed, please reauthenticate."
     },
+    "button_press_failed": {
+      "message": "Failed to press {button} button."
+    },
     "connection_failed": {
       "message": "Failed to communicate with device."
     },
@@ -74,6 +102,9 @@
     },
     "set_temperature_failed": {
       "message": "Failed to set temperature to {temperature}."
+    },
+    "set_value_failed": {
+      "message": "Failed to set value: {error}"
     }
   }
 }

homeassistant/components/airos/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "quality_scale": "silver",
-  "requirements": ["airos==0.6.0"]
+  "requirements": ["airos==0.6.1"]
 }

homeassistant/components/airpatrol/climate.py

@@ -88,21 +88,11 @@ class AirPatrolClimate(AirPatrolEntity, ClimateEntity):
         super().__init__(coordinator, unit_id)
         self._attr_unique_id = f"{coordinator.config_entry.unique_id}-{unit_id}"
 
-    @property
-    def climate_data(self) -> dict[str, Any]:
-        """Return the climate data."""
-        return self.device_data.get("climate") or {}
-
     @property
     def params(self) -> dict[str, Any]:
         """Return the current parameters for the climate entity."""
         return self.climate_data.get("ParametersData") or {}
 
-    @property
-    def available(self) -> bool:
-        """Return if entity is available."""
-        return super().available and bool(self.climate_data)
-
     @property
     def current_humidity(self) -> float | None:
         """Return the current humidity."""

homeassistant/components/airpatrol/const.py

@@ -10,7 +10,7 @@ from homeassistant.const import Platform
 DOMAIN = "airpatrol"
 
 LOGGER = logging.getLogger(__package__)
-PLATFORMS = [Platform.CLIMATE]
+PLATFORMS = [Platform.CLIMATE, Platform.SENSOR]
 SCAN_INTERVAL = timedelta(minutes=1)
 
 AIRPATROL_ERRORS = (AirPatrolAuthenticationError, AirPatrolError)

homeassistant/components/airpatrol/entity.py

@@ -38,7 +38,17 @@ class AirPatrolEntity(CoordinatorEntity[AirPatrolDataUpdateCoordinator]):
         """Return the device data."""
         return self.coordinator.data[self._unit_id]
 
+    @property
+    def climate_data(self) -> dict[str, Any]:
+        """Return the climate data for this unit."""
+        return self.device_data["climate"]
+
     @property
     def available(self) -> bool:
         """Return if entity is available."""
-        return super().available and self._unit_id in self.coordinator.data
+        return (
+            super().available
+            and self._unit_id in self.coordinator.data
+            and "climate" in self.device_data
+            and self.climate_data is not None
+        )

homeassistant/components/airpatrol/sensor.py

@@ -0,0 +1,89 @@
+"""Sensors for AirPatrol integration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+    SensorStateClass,
+)
+from homeassistant.const import PERCENTAGE, UnitOfTemperature
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import AirPatrolConfigEntry
+from .coordinator import AirPatrolDataUpdateCoordinator
+from .entity import AirPatrolEntity
+
+PARALLEL_UPDATES = 0
+
+
+@dataclass(frozen=True, kw_only=True)
+class AirPatrolSensorEntityDescription(SensorEntityDescription):
+    """Describes AirPatrol sensor entity."""
+
+    data_field: str
+
+
+SENSOR_DESCRIPTIONS = (
+    AirPatrolSensorEntityDescription(
+        key="temperature",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        data_field="RoomTemp",
+    ),
+    AirPatrolSensorEntityDescription(
+        key="humidity",
+        device_class=SensorDeviceClass.HUMIDITY,
+        state_class=SensorStateClass.MEASUREMENT,
+        native_unit_of_measurement=PERCENTAGE,
+        data_field="RoomHumidity",
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: AirPatrolConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up AirPatrol sensors."""
+    coordinator = config_entry.runtime_data
+    units = coordinator.data
+
+    async_add_entities(
+        AirPatrolSensor(coordinator, unit_id, description)
+        for unit_id, unit in units.items()
+        for description in SENSOR_DESCRIPTIONS
+        if "climate" in unit and unit["climate"] is not None
+    )
+
+
+class AirPatrolSensor(AirPatrolEntity, SensorEntity):
+    """AirPatrol sensor entity."""
+
+    entity_description: AirPatrolSensorEntityDescription
+
+    def __init__(
+        self,
+        coordinator: AirPatrolDataUpdateCoordinator,
+        unit_id: str,
+        description: AirPatrolSensorEntityDescription,
+    ) -> None:
+        """Initialize AirPatrol sensor."""
+        super().__init__(coordinator, unit_id)
+        self.entity_description = description
+        self._attr_unique_id = (
+            f"{coordinator.config_entry.unique_id}-{unit_id}-{description.key}"
+        )
+
+    @property
+    def native_value(self) -> float | None:
+        """Return the state of the sensor."""
+        if value := self.climate_data.get(self.entity_description.data_field):
+            return float(value)
+        return None

homeassistant/components/airzone/entity.py

@@ -85,6 +85,22 @@ class AirzoneSystemEntity(AirzoneEntity):
                 value = system[key]
         return value
 
+    async def _async_update_sys_params(self, params: dict[str, Any]) -> None:
+        """Send system parameters to API."""
+        _params = {
+            API_SYSTEM_ID: self.system_id,
+            **params,
+        }
+        _LOGGER.debug("update_sys_params=%s", _params)
+        try:
+            await self.coordinator.airzone.set_sys_parameters(_params)
+        except AirzoneError as error:
+            raise HomeAssistantError(
+                f"Failed to set system {self.entity_id}: {error}"
+            ) from error
+
+        self.coordinator.async_set_updated_data(self.coordinator.airzone.data())
+
 
 class AirzoneHotWaterEntity(AirzoneEntity):
     """Define an Airzone Hot Water entity."""

homeassistant/components/airzone/manifest.json

@@ -12,5 +12,5 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["aioairzone"],
-  "requirements": ["aioairzone==1.0.4"]
+  "requirements": ["aioairzone==1.0.5"]
 }

homeassistant/components/airzone/select.py

@@ -20,6 +20,7 @@ from aioairzone.const import (
     AZD_MODES,
     AZD_Q_ADAPT,
     AZD_SLEEP,
+    AZD_SYSTEMS,
     AZD_ZONES,
 )
 
@@ -30,7 +31,7 @@ from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .coordinator import AirzoneConfigEntry, AirzoneUpdateCoordinator
-from .entity import AirzoneEntity, AirzoneZoneEntity
+from .entity import AirzoneEntity, AirzoneSystemEntity, AirzoneZoneEntity
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -85,14 +86,7 @@ def main_zone_options(
     return [k for k, v in options.items() if v in modes]
 
 
-MAIN_ZONE_SELECT_TYPES: Final[tuple[AirzoneSelectDescription, ...]] = (
-    AirzoneSelectDescription(
-        api_param=API_MODE,
-        key=AZD_MODE,
-        options_dict=MODE_DICT,
-        options_fn=main_zone_options,
-        translation_key="modes",
-    ),
+SYSTEM_SELECT_TYPES: Final[tuple[AirzoneSelectDescription, ...]] = (
     AirzoneSelectDescription(
         api_param=API_Q_ADAPT,
         entity_category=EntityCategory.CONFIG,
@@ -104,6 +98,17 @@ MAIN_ZONE_SELECT_TYPES: Final[tuple[AirzoneSelectDescription, ...]] = (
 )
 
 
+MAIN_ZONE_SELECT_TYPES: Final[tuple[AirzoneSelectDescription, ...]] = (
+    AirzoneSelectDescription(
+        api_param=API_MODE,
+        key=AZD_MODE,
+        options_dict=MODE_DICT,
+        options_fn=main_zone_options,
+        translation_key="modes",
+    ),
+)
+
+
 ZONE_SELECT_TYPES: Final[tuple[AirzoneSelectDescription, ...]] = (
     AirzoneSelectDescription(
         api_param=API_COLD_ANGLE,
@@ -140,16 +145,37 @@ async def async_setup_entry(
     """Add Airzone select from a config_entry."""
     coordinator = entry.runtime_data
 
+    added_systems: set[str] = set()
     added_zones: set[str] = set()
 
     def _async_entity_listener() -> None:
         """Handle additions of select."""
 
+        entities: list[AirzoneBaseSelect] = []
+
+        systems_data = coordinator.data.get(AZD_SYSTEMS, {})
+        received_systems = set(systems_data)
+        new_systems = received_systems - added_systems
+        if new_systems:
+            entities.extend(
+                AirzoneSystemSelect(
+                    coordinator,
+                    description,
+                    entry,
+                    system_id,
+                    systems_data.get(system_id),
+                )
+                for system_id in new_systems
+                for description in SYSTEM_SELECT_TYPES
+                if description.key in systems_data.get(system_id)
+            )
+            added_systems.update(new_systems)
+
         zones_data = coordinator.data.get(AZD_ZONES, {})
         received_zones = set(zones_data)
         new_zones = received_zones - added_zones
         if new_zones:
-            entities: list[AirzoneZoneSelect] = [
+            entities.extend(
                 AirzoneZoneSelect(
                     coordinator,
                     description,
@@ -161,8 +187,8 @@ async def async_setup_entry(
                 for description in MAIN_ZONE_SELECT_TYPES
                 if description.key in zones_data.get(system_zone_id)
                 and zones_data.get(system_zone_id).get(AZD_MASTER) is True
-            ]
-            entities += [
+            )
+            entities.extend(
                 AirzoneZoneSelect(
                     coordinator,
                     description,
@@ -173,10 +199,11 @@ async def async_setup_entry(
                 for system_zone_id in new_zones
                 for description in ZONE_SELECT_TYPES
                 if description.key in zones_data.get(system_zone_id)
-            ]
-            async_add_entities(entities)
+            )
             added_zones.update(new_zones)
 
+        async_add_entities(entities)
+
     entry.async_on_unload(coordinator.async_add_listener(_async_entity_listener))
     _async_entity_listener()
 
@@ -203,6 +230,38 @@ class AirzoneBaseSelect(AirzoneEntity, SelectEntity):
         self._attr_current_option = self._get_current_option()
 
 
+class AirzoneSystemSelect(AirzoneSystemEntity, AirzoneBaseSelect):
+    """Define an Airzone System select."""
+
+    def __init__(
+        self,
+        coordinator: AirzoneUpdateCoordinator,
+        description: AirzoneSelectDescription,
+        entry: ConfigEntry,
+        system_id: str,
+        system_data: dict[str, Any],
+    ) -> None:
+        """Initialize."""
+        super().__init__(coordinator, entry, system_data)
+
+        self._attr_unique_id = f"{self._attr_unique_id}_{system_id}_{description.key}"
+        self.entity_description = description
+
+        self._attr_options = self.entity_description.options_fn(
+            system_data, description.options_dict
+        )
+
+        self.values_dict = {v: k for k, v in description.options_dict.items()}
+
+        self._async_update_attrs()
+
+    async def async_select_option(self, option: str) -> None:
+        """Change the selected option."""
+        param = self.entity_description.api_param
+        value = self.entity_description.options_dict[option]
+        await self._async_update_sys_params({param: value})
+
+
 class AirzoneZoneSelect(AirzoneZoneEntity, AirzoneBaseSelect):
     """Define an Airzone Zone select."""
 

homeassistant/components/alarm_control_panel/trigger.py

@@ -45,7 +45,7 @@ def make_entity_state_trigger_required_features(
         """Trigger for entity state changes."""
 
         _domain = domain
-        _to_state = to_state
+        _to_states = {to_state}
         _required_features = required_features
 
     return CustomTrigger

homeassistant/components/alexa_devices/manifest.json

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

homeassistant/components/anglian_water/config_flow.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import logging
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from aiohttp import CookieJar
 from pyanglianwater import AnglianWater
@@ -30,14 +30,11 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
         vol.Required(CONF_PASSWORD): selector.TextSelector(
             selector.TextSelectorConfig(type=selector.TextSelectorType.PASSWORD)
         ),
-        vol.Required(CONF_ACCOUNT_NUMBER): selector.TextSelector(),
     }
 )
 
 
-async def validate_credentials(
-    auth: MSOB2CAuth, account_number: str
-) -> str | MSOB2CAuth:
+async def validate_credentials(auth: MSOB2CAuth) -> str | MSOB2CAuth:
     """Validate the provided credentials."""
     try:
         await auth.send_login_request()
@@ -46,6 +43,33 @@ async def validate_credentials(
     except Exception:
         _LOGGER.exception("Unexpected exception")
         return "unknown"
+    return auth
+
+
+def humanize_account_data(account: dict) -> str:
+    """Convert an account data into a human-readable format."""
+    if account["address"]["company_name"] != "":
+        return f"{account['account_number']} - {account['address']['company_name']}"
+    if account["address"]["building_name"] != "":
+        return f"{account['account_number']} - {account['address']['building_name']}"
+    return f"{account['account_number']} - {account['address']['postcode']}"
+
+
+async def get_accounts(auth: MSOB2CAuth) -> list[selector.SelectOptionDict]:
+    """Retrieve the list of accounts associated with the authenticated user."""
+    _aw = AnglianWater(authenticator=auth)
+    accounts = await _aw.api.get_associated_accounts()
+    return [
+        selector.SelectOptionDict(
+            value=str(account["account_number"]),
+            label=humanize_account_data(account),
+        )
+        for account in accounts["result"]["active"]
+    ]
+
+
+async def validate_account(auth: MSOB2CAuth, account_number: str) -> str | MSOB2CAuth:
+    """Validate the provided account number."""
     _aw = AnglianWater(authenticator=auth)
     try:
         await _aw.validate_smart_meter(account_number)
@@ -57,36 +81,91 @@ async def validate_credentials(
 class AnglianWaterConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Anglian Water."""
 
+    def __init__(self) -> None:
+        """Initialize the config flow."""
+        self.authenticator: MSOB2CAuth | None = None
+        self.accounts: list[selector.SelectOptionDict] = []
+        self.user_input: dict[str, Any] | None = None
+
     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:
-            validation_response = await validate_credentials(
-                MSOB2CAuth(
-                    username=user_input[CONF_USERNAME],
-                    password=user_input[CONF_PASSWORD],
-                    session=async_create_clientsession(
-                        self.hass,
-                        cookie_jar=CookieJar(quote_cookie=False),
-                    ),
+            self.authenticator = MSOB2CAuth(
+                username=user_input[CONF_USERNAME],
+                password=user_input[CONF_PASSWORD],
+                session=async_create_clientsession(
+                    self.hass,
+                    cookie_jar=CookieJar(quote_cookie=False),
                 ),
-                user_input[CONF_ACCOUNT_NUMBER],
             )
+            validation_response = await validate_credentials(self.authenticator)
             if isinstance(validation_response, str):
                 errors["base"] = validation_response
             else:
-                await self.async_set_unique_id(user_input[CONF_ACCOUNT_NUMBER])
-                self._abort_if_unique_id_configured()
-                return self.async_create_entry(
-                    title=user_input[CONF_ACCOUNT_NUMBER],
-                    data={
-                        **user_input,
-                        CONF_ACCESS_TOKEN: validation_response.refresh_token,
-                    },
+                self.accounts = await get_accounts(self.authenticator)
+                if len(self.accounts) > 1:
+                    self.user_input = user_input
+                    return await self.async_step_select_account()
+                account_number = self.accounts[0]["value"]
+                self.user_input = user_input
+                return await self.async_step_complete(
+                    {
+                        CONF_ACCOUNT_NUMBER: account_number,
+                    }
                 )
 
         return self.async_show_form(
             step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
         )
+
+    async def async_step_select_account(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the account selection step."""
+        errors = {}
+        if user_input is not None:
+            if TYPE_CHECKING:
+                assert self.authenticator
+            validation_result = await validate_account(
+                self.authenticator,
+                user_input[CONF_ACCOUNT_NUMBER],
+            )
+            if isinstance(validation_result, str):
+                errors["base"] = validation_result
+            else:
+                return await self.async_step_complete(user_input)
+        return self.async_show_form(
+            step_id="select_account",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_ACCOUNT_NUMBER): selector.SelectSelector(
+                        selector.SelectSelectorConfig(
+                            options=self.accounts,
+                            multiple=False,
+                            mode=selector.SelectSelectorMode.DROPDOWN,
+                        )
+                    )
+                }
+            ),
+            errors=errors,
+        )
+
+    async def async_step_complete(self, user_input: dict[str, Any]) -> ConfigFlowResult:
+        """Handle the final configuration step."""
+        await self.async_set_unique_id(user_input[CONF_ACCOUNT_NUMBER])
+        self._abort_if_unique_id_configured()
+        if TYPE_CHECKING:
+            assert self.authenticator
+            assert self.user_input
+        config_entry_data = {
+            **self.user_input,
+            CONF_ACCOUNT_NUMBER: user_input[CONF_ACCOUNT_NUMBER],
+            CONF_ACCESS_TOKEN: self.authenticator.refresh_token,
+        }
+        return self.async_create_entry(
+            title=user_input[CONF_ACCOUNT_NUMBER],
+            data=config_entry_data,
+        )

homeassistant/components/anglian_water/coordinator.py

@@ -4,13 +4,28 @@ from __future__ import annotations
 
 from datetime import timedelta
 import logging
+from typing import Any
 
 from pyanglianwater import AnglianWater
 from pyanglianwater.exceptions import ExpiredAccessTokenError, UnknownEndpointError
 
+from homeassistant.components.recorder import get_instance
+from homeassistant.components.recorder.models import (
+    StatisticData,
+    StatisticMeanType,
+    StatisticMetaData,
+)
+from homeassistant.components.recorder.statistics import (
+    async_add_external_statistics,
+    get_last_statistics,
+    statistics_during_period,
+)
 from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import UnitOfVolume
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+from homeassistant.util import dt as dt_util
+from homeassistant.util.unit_conversion import VolumeConverter
 
 from .const import CONF_ACCOUNT_NUMBER, DOMAIN
 
@@ -44,6 +59,107 @@ class AnglianWaterUpdateCoordinator(DataUpdateCoordinator[None]):
     async def _async_update_data(self) -> None:
         """Update data from Anglian Water's API."""
         try:
-            return await self.api.update(self.config_entry.data[CONF_ACCOUNT_NUMBER])
+            await self.api.update(self.config_entry.data[CONF_ACCOUNT_NUMBER])
+            await self._insert_statistics()
         except (ExpiredAccessTokenError, UnknownEndpointError) as err:
             raise UpdateFailed from err
+
+    async def _insert_statistics(self) -> None:
+        """Insert statistics for water meters into Home Assistant."""
+        for meter in self.api.meters.values():
+            id_prefix = (
+                f"{self.config_entry.data[CONF_ACCOUNT_NUMBER]}_{meter.serial_number}"
+            )
+            usage_statistic_id = f"{DOMAIN}:{id_prefix}_usage".lower()
+            _LOGGER.debug("Updating statistics for meter %s", meter.serial_number)
+            name_prefix = (
+                f"Anglian Water {self.config_entry.data[CONF_ACCOUNT_NUMBER]} "
+                f"{meter.serial_number}"
+            )
+            usage_metadata = StatisticMetaData(
+                mean_type=StatisticMeanType.NONE,
+                has_sum=True,
+                name=f"{name_prefix} Usage",
+                source=DOMAIN,
+                statistic_id=usage_statistic_id,
+                unit_class=VolumeConverter.UNIT_CLASS,
+                unit_of_measurement=UnitOfVolume.CUBIC_METERS,
+            )
+            last_stat = await get_instance(self.hass).async_add_executor_job(
+                get_last_statistics, self.hass, 1, usage_statistic_id, True, set()
+            )
+            if not last_stat:
+                _LOGGER.debug("Updating statistics for the first time")
+                usage_sum = 0.0
+                last_stats_time = None
+            else:
+                if not meter.readings or len(meter.readings) == 0:
+                    _LOGGER.debug("No recent usage statistics found, skipping update")
+                    continue
+                # Anglian Water stats are hourly, the read_at time is the time that the meter took the reading
+                # We remove 1 hour from this so that the data is shown in the correct hour on the dashboards
+                parsed_read_at = dt_util.parse_datetime(meter.readings[0]["read_at"])
+                if not parsed_read_at:
+                    _LOGGER.debug(
+                        "Could not parse read_at time %s, skipping update",
+                        meter.readings[0]["read_at"],
+                    )
+                    continue
+                start = dt_util.as_local(parsed_read_at) - timedelta(hours=1)
+                _LOGGER.debug("Getting statistics at %s", start)
+                for end in (start + timedelta(seconds=1), None):
+                    stats = await get_instance(self.hass).async_add_executor_job(
+                        statistics_during_period,
+                        self.hass,
+                        start,
+                        end,
+                        {
+                            usage_statistic_id,
+                        },
+                        "hour",
+                        None,
+                        {"sum"},
+                    )
+                    if stats:
+                        break
+                    if end:
+                        _LOGGER.debug(
+                            "Not found, trying to find oldest statistic after %s",
+                            start,
+                        )
+                assert stats
+
+                def _safe_get_sum(records: list[Any]) -> float:
+                    if records and "sum" in records[0]:
+                        return float(records[0]["sum"])
+                    return 0.0
+
+                usage_sum = _safe_get_sum(stats.get(usage_statistic_id, []))
+                last_stats_time = stats[usage_statistic_id][0]["start"]
+
+            usage_statistics = []
+
+            for read in meter.readings:
+                parsed_read_at = dt_util.parse_datetime(read["read_at"])
+                if not parsed_read_at:
+                    _LOGGER.debug(
+                        "Could not parse read_at time %s, skipping reading",
+                        read["read_at"],
+                    )
+                    continue
+                start = dt_util.as_local(parsed_read_at) - timedelta(hours=1)
+                if last_stats_time is not None and start.timestamp() <= last_stats_time:
+                    continue
+                usage_state = max(0, read["consumption"] / 1000)
+                usage_sum = max(0, read["read"])
+                usage_statistics.append(
+                    StatisticData(
+                        start=start,
+                        state=usage_state,
+                        sum=usage_sum,
+                    )
+                )
+            _LOGGER.debug(
+                "Adding %s statistics for %s", len(usage_statistics), usage_statistic_id
+            )
+            async_add_external_statistics(self.hass, usage_metadata, usage_statistics)

homeassistant/components/anglian_water/manifest.json

@@ -1,6 +1,7 @@
 {
   "domain": "anglian_water",
   "name": "Anglian Water",
+  "after_dependencies": ["recorder"],
   "codeowners": ["@pantherale0"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/anglian_water",

homeassistant/components/anglian_water/strings.json

@@ -10,14 +10,21 @@
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "step": {
+      "select_account": {
+        "data": {
+          "account_number": "Billing account number"
+        },
+        "data_description": {
+          "account_number": "Select the billing account you wish to use."
+        },
+        "description": "Multiple active billing accounts were found with your credentials. Please select the account you wish to use. If this is unexpected, contact Anglian Water to confirm your active accounts."
+      },
       "user": {
         "data": {
-          "account_number": "Billing Account Number",
           "password": "[%key:common::config_flow::data::password%]",
           "username": "[%key:common::config_flow::data::username%]"
         },
         "data_description": {
-          "account_number": "Your account number found on your latest bill.",
           "password": "Your password",
           "username": "Username or email used to log in to the Anglian Water website."
         },

homeassistant/components/anthropic/entity.py

@@ -69,6 +69,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import device_registry as dr, llm
 from homeassistant.helpers.entity import Entity
+from homeassistant.helpers.json import json_dumps
 from homeassistant.util import slugify
 
 from . import AnthropicConfigEntry
@@ -193,7 +194,7 @@ def _convert_content(
                 tool_result_block = ToolResultBlockParam(
                     type="tool_result",
                     tool_use_id=content.tool_call_id,
-                    content=json.dumps(content.tool_result),
+                    content=json_dumps(content.tool_result),
                 )
                 external_tool = False
             if not messages or messages[-1]["role"] != (

homeassistant/components/apcupsd/sensor.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 import logging
 
+import dateutil
+
 from homeassistant.components.automation import automations_with_entity
 from homeassistant.components.script import scripts_with_entity
 from homeassistant.components.sensor import (
@@ -179,6 +181,7 @@ SENSORS: dict[str, SensorEntityDescription] = {
     LAST_S_TEST: SensorEntityDescription(
         key=LAST_S_TEST,
         translation_key="last_self_test",
+        device_class=SensorDeviceClass.TIMESTAMP,
     ),
     "lastxfer": SensorEntityDescription(
         key="lastxfer",
@@ -232,6 +235,7 @@ SENSORS: dict[str, SensorEntityDescription] = {
     "masterupd": SensorEntityDescription(
         key="masterupd",
         translation_key="master_update",
+        device_class=SensorDeviceClass.TIMESTAMP,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "maxlinev": SensorEntityDescription(
@@ -365,6 +369,7 @@ SENSORS: dict[str, SensorEntityDescription] = {
     "starttime": SensorEntityDescription(
         key="starttime",
         translation_key="startup_time",
+        device_class=SensorDeviceClass.TIMESTAMP,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "statflag": SensorEntityDescription(
@@ -416,16 +421,19 @@ SENSORS: dict[str, SensorEntityDescription] = {
     "xoffbat": SensorEntityDescription(
         key="xoffbat",
         translation_key="transfer_from_battery",
+        device_class=SensorDeviceClass.TIMESTAMP,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "xoffbatt": SensorEntityDescription(
         key="xoffbatt",
         translation_key="transfer_from_battery",
+        device_class=SensorDeviceClass.TIMESTAMP,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "xonbatt": SensorEntityDescription(
         key="xonbatt",
         translation_key="transfer_to_battery",
+        device_class=SensorDeviceClass.TIMESTAMP,
         entity_category=EntityCategory.DIAGNOSTIC,
     ),
 }
@@ -529,7 +537,13 @@ class APCUPSdSensor(APCUPSdEntity, SensorEntity):
             self._attr_native_value = None
             return
 
-        self._attr_native_value, inferred_unit = infer_unit(self.coordinator.data[key])
+        data = self.coordinator.data[key]
+
+        if self.entity_description.device_class == SensorDeviceClass.TIMESTAMP:
+            self._attr_native_value = dateutil.parser.parse(data)
+            return
+
+        self._attr_native_value, inferred_unit = infer_unit(data)
         if not self.native_unit_of_measurement:
             self._attr_native_unit_of_measurement = inferred_unit
 

homeassistant/components/assist_pipeline/audio_enhancer.py

@@ -3,9 +3,8 @@
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 import logging
-import math
 
-from pysilero_vad import SileroVoiceActivityDetector
+from pymicro_vad import MicroVad
 from pyspeex_noise import AudioProcessor
 
 from .const import BYTES_PER_CHUNK
@@ -43,8 +42,8 @@ class AudioEnhancer(ABC):
         """Enhance chunk of PCM audio @ 16Khz with 16-bit mono samples."""
 
 
-class SileroVadSpeexEnhancer(AudioEnhancer):
-    """Audio enhancer that runs Silero VAD and speex."""
+class MicroVadSpeexEnhancer(AudioEnhancer):
+    """Audio enhancer that runs microVAD and speex."""
 
     def __init__(
         self, auto_gain: int, noise_suppression: int, is_vad_enabled: bool
@@ -70,49 +69,21 @@ class SileroVadSpeexEnhancer(AudioEnhancer):
                 self.noise_suppression,
             )
 
-        self.vad: SileroVoiceActivityDetector | None = None
-
-        # We get 10ms chunks but Silero works on 32ms chunks, so we have to
-        # buffer audio. The previous speech probability is used until enough
-        # audio has been buffered.
-        self._vad_buffer: bytearray | None = None
-        self._vad_buffer_chunks = 0
-        self._vad_buffer_chunk_idx = 0
-        self._last_speech_probability: float | None = None
+        self.vad: MicroVad | None = None
 
         if self.is_vad_enabled:
-            self.vad = SileroVoiceActivityDetector()
-
-            # VAD buffer is a multiple of 10ms, but Silero VAD needs 32ms.
-            self._vad_buffer_chunks = int(
-                math.ceil(self.vad.chunk_bytes() / BYTES_PER_CHUNK)
-            )
-            self._vad_leftover_bytes = self.vad.chunk_bytes() - BYTES_PER_CHUNK
-            self._vad_buffer = bytearray(self.vad.chunk_bytes())
-            _LOGGER.debug("Initialized Silero VAD")
+            self.vad = MicroVad()
+            _LOGGER.debug("Initialized microVAD")
 
     def enhance_chunk(self, audio: bytes, timestamp_ms: int) -> EnhancedAudioChunk:
         """Enhance 10ms chunk of PCM audio @ 16Khz with 16-bit mono samples."""
+        speech_probability: float | None = None
+
         assert len(audio) == BYTES_PER_CHUNK
 
         if self.vad is not None:
             # Run VAD
-            assert self._vad_buffer is not None
-            start_idx = self._vad_buffer_chunk_idx * BYTES_PER_CHUNK
-            self._vad_buffer[start_idx : start_idx + BYTES_PER_CHUNK] = audio
-
-            self._vad_buffer_chunk_idx += 1
-            if self._vad_buffer_chunk_idx >= self._vad_buffer_chunks:
-                # We have enough data to run Silero VAD (32 ms)
-                self._last_speech_probability = self.vad.process_chunk(
-                    self._vad_buffer[: self.vad.chunk_bytes()]
-                )
-
-                # Copy leftover audio that wasn't processed to start
-                self._vad_buffer[: self._vad_leftover_bytes] = self._vad_buffer[
-                    -self._vad_leftover_bytes :
-                ]
-                self._vad_buffer_chunk_idx = 0
+            speech_probability = self.vad.Process10ms(audio)
 
         if self.audio_processor is not None:
             # Run noise suppression and auto gain
@@ -121,5 +92,5 @@ class SileroVadSpeexEnhancer(AudioEnhancer):
         return EnhancedAudioChunk(
             audio=audio,
             timestamp_ms=timestamp_ms,
-            speech_probability=self._last_speech_probability,
+            speech_probability=speech_probability,
         )

homeassistant/components/assist_pipeline/manifest.json

@@ -8,5 +8,5 @@
   "integration_type": "system",
   "iot_class": "local_push",
   "quality_scale": "internal",
-  "requirements": ["pysilero-vad==3.0.1", "pyspeex-noise==1.0.2"]
+  "requirements": ["pymicro-vad==1.0.1", "pyspeex-noise==1.0.2"]
 }

homeassistant/components/assist_pipeline/pipeline.py

@@ -55,7 +55,7 @@ from homeassistant.util import (
 from homeassistant.util.hass_dict import HassKey
 from homeassistant.util.limited_size_dict import LimitedSizeDict
 
-from .audio_enhancer import AudioEnhancer, EnhancedAudioChunk, SileroVadSpeexEnhancer
+from .audio_enhancer import AudioEnhancer, EnhancedAudioChunk, MicroVadSpeexEnhancer
 from .const import (
     ACKNOWLEDGE_PATH,
     BYTES_PER_CHUNK,
@@ -633,7 +633,7 @@ class PipelineRun:
         # Initialize with audio settings
         if self.audio_settings.needs_processor and (self.audio_enhancer is None):
             # Default audio enhancer
-            self.audio_enhancer = SileroVadSpeexEnhancer(
+            self.audio_enhancer = MicroVadSpeexEnhancer(
                 self.audio_settings.auto_gain_dbfs,
                 self.audio_settings.noise_suppression_level,
                 self.audio_settings.is_vad_enabled,

homeassistant/components/august/manifest.json

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

homeassistant/components/automation/__init__.py

@@ -7,7 +7,7 @@ import asyncio
 from collections.abc import Callable, Mapping
 from dataclasses import dataclass
 import logging
-from typing import Any, Protocol, cast
+from typing import Any, Literal, Protocol, cast
 
 from propcache.api import cached_property
 import voluptuous as vol
@@ -16,7 +16,10 @@ from homeassistant.components import labs, websocket_api
 from homeassistant.components.blueprint import CONF_USE_BLUEPRINT
 from homeassistant.components.labs import async_listen as async_labs_listen
 from homeassistant.const import (
+    ATTR_AREA_ID,
     ATTR_ENTITY_ID,
+    ATTR_FLOOR_ID,
+    ATTR_LABEL_ID,
     ATTR_MODE,
     ATTR_NAME,
     CONF_ACTIONS,
@@ -27,8 +30,10 @@ from homeassistant.const import (
     CONF_EVENT_DATA,
     CONF_ID,
     CONF_MODE,
+    CONF_OPTIONS,
     CONF_PATH,
     CONF_PLATFORM,
+    CONF_TARGET,
     CONF_TRIGGERS,
     CONF_VARIABLES,
     CONF_ZONE,
@@ -118,6 +123,7 @@ SERVICE_TRIGGER = "trigger"
 NEW_TRIGGERS_CONDITIONS_FEATURE_FLAG = "new_triggers_conditions"
 
 _EXPERIMENTAL_CONDITION_PLATFORMS = {
+    "fan",
     "light",
 }
 
@@ -130,9 +136,14 @@ _EXPERIMENTAL_TRIGGER_PLATFORMS = {
     "cover",
     "device_tracker",
     "fan",
+    "humidifier",
     "lawn_mower",
     "light",
+    "lock",
     "media_player",
+    "person",
+    "scene",
+    "siren",
     "switch",
     "text",
     "update",
@@ -583,20 +594,32 @@ class AutomationEntity(BaseAutomationEntity, RestoreEntity):
         """Return True if entity is on."""
         return self._async_detach_triggers is not None or self._is_enabled
 
-    @property
+    @cached_property
     def referenced_labels(self) -> set[str]:
         """Return a set of referenced labels."""
-        return self.action_script.referenced_labels
+        referenced = self.action_script.referenced_labels
 
-    @property
+        for conf in self._trigger_config:
+            referenced |= set(_get_targets_from_trigger_config(conf, ATTR_LABEL_ID))
+        return referenced
+
+    @cached_property
     def referenced_floors(self) -> set[str]:
         """Return a set of referenced floors."""
-        return self.action_script.referenced_floors
+        referenced = self.action_script.referenced_floors
+
+        for conf in self._trigger_config:
+            referenced |= set(_get_targets_from_trigger_config(conf, ATTR_FLOOR_ID))
+        return referenced
 
     @cached_property
     def referenced_areas(self) -> set[str]:
         """Return a set of referenced areas."""
-        return self.action_script.referenced_areas
+        referenced = self.action_script.referenced_areas
+
+        for conf in self._trigger_config:
+            referenced |= set(_get_targets_from_trigger_config(conf, ATTR_AREA_ID))
+        return referenced
 
     @property
     def referenced_blueprint(self) -> str | None:
@@ -1204,6 +1227,9 @@ def _trigger_extract_devices(trigger_conf: dict) -> list[str]:
     if trigger_conf[CONF_PLATFORM] == "tag" and CONF_DEVICE_ID in trigger_conf:
         return trigger_conf[CONF_DEVICE_ID]  # type: ignore[no-any-return]
 
+    if target_devices := _get_targets_from_trigger_config(trigger_conf, CONF_DEVICE_ID):
+        return target_devices
+
     return []
 
 
@@ -1214,7 +1240,7 @@ def _trigger_extract_entities(trigger_conf: dict) -> list[str]:
         return trigger_conf[CONF_ENTITY_ID]  # type: ignore[no-any-return]
 
     if trigger_conf[CONF_PLATFORM] == "calendar":
-        return [trigger_conf[CONF_ENTITY_ID]]
+        return [trigger_conf[CONF_OPTIONS][CONF_ENTITY_ID]]
 
     if trigger_conf[CONF_PLATFORM] == "zone":
         return trigger_conf[CONF_ENTITY_ID] + [trigger_conf[CONF_ZONE]]  # type: ignore[no-any-return]
@@ -1234,9 +1260,28 @@ def _trigger_extract_entities(trigger_conf: dict) -> list[str]:
     ):
         return [trigger_conf[CONF_EVENT_DATA][CONF_ENTITY_ID]]
 
+    if target_entities := _get_targets_from_trigger_config(
+        trigger_conf, CONF_ENTITY_ID
+    ):
+        return target_entities
+
     return []
 
 
+@callback
+def _get_targets_from_trigger_config(
+    config: dict,
+    target: Literal["entity_id", "device_id", "area_id", "floor_id", "label_id"],
+) -> list[str]:
+    """Extract targets from a target config."""
+    if not (target_conf := config.get(CONF_TARGET)):
+        return []
+    if not (targets := target_conf.get(target)):
+        return []
+
+    return [targets] if isinstance(targets, str) else targets
+
+
 @websocket_api.websocket_command({"type": "automation/config", "entity_id": str})
 def websocket_config(
     hass: HomeAssistant,

homeassistant/components/axis/manifest.json

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

homeassistant/components/azure_data_explorer/client.py

@@ -80,7 +80,7 @@ class AzureDataExplorerClient:
     def test_connection(self) -> None:
         """Test connection, will throw Exception if it cannot connect."""
 
-        query = f"{self._table} | take 1"
+        query = f"['{self._table}'] | take 1"
 
         self.query_client.execute_query(self._database, query)
 

homeassistant/components/azure_data_explorer/config_flow.py

@@ -45,7 +45,7 @@ class ADXConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
 
     VERSION = 1
 
-    async def validate_input(self, data: dict[str, Any]) -> dict[str, Any] | None:
+    async def validate_input(self, data: dict[str, Any]) -> dict[str, str]:
         """Validate the user input allows us to connect.
 
         Data has the keys from STEP_USER_DATA_SCHEMA with values provided by the user.
@@ -54,36 +54,40 @@ class ADXConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
 
         try:
             await self.hass.async_add_executor_job(client.test_connection)
-
-        except KustoAuthenticationError as exp:
-            _LOGGER.error(exp)
+        except KustoAuthenticationError as err:
+            _LOGGER.error("Authentication failed: %s", err)
             return {"base": "invalid_auth"}
-
-        except KustoServiceError as exp:
-            _LOGGER.error(exp)
+        except KustoServiceError as err:
+            _LOGGER.error("Could not connect: %s", err)
             return {"base": "cannot_connect"}
 
-        return None
+        return {}
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle the initial step."""
 
-        errors: dict = {}
-        if user_input:
-            errors = await self.validate_input(user_input)  # type: ignore[assignment]
+        errors: dict[str, str] = {}
+        data_schema = STEP_USER_DATA_SCHEMA
+
+        if user_input is not None:
+            errors = await self.validate_input(user_input)
             if not errors:
                 return self.async_create_entry(
                     data=user_input,
-                    title=user_input[CONF_ADX_CLUSTER_INGEST_URI].replace(
-                        "https://", ""
-                    ),
+                    title=f"{user_input[CONF_ADX_CLUSTER_INGEST_URI].replace('https://', '')} / {user_input[CONF_ADX_DATABASE_NAME]} ({user_input[CONF_ADX_TABLE_NAME]})",
                     options=DEFAULT_OPTIONS,
                 )
+
+            # Keep previously entered values when we re-show the form after an error.
+            data_schema = self.add_suggested_values_to_schema(
+                STEP_USER_DATA_SCHEMA, user_input
+            )
+
         return self.async_show_form(
             step_id="user",
-            data_schema=STEP_USER_DATA_SCHEMA,
+            data_schema=data_schema,
             errors=errors,
             last_step=True,
         )

homeassistant/components/azure_data_explorer/strings.json

@@ -20,6 +20,7 @@
           "use_queued_ingestion": "Use queued ingestion"
         },
         "data_description": {
+          "authority_id": "In Azure portal this is also known as Directory (tenant) ID",
           "cluster_ingest_uri": "Ingestion URI of the cluster",
           "use_queued_ingestion": "Must be enabled when using ADX free cluster"
         },

homeassistant/components/azure_service_bus/notify.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import json
 import logging
+from typing import Any
 
 from azure.servicebus import ServiceBusMessage
 from azure.servicebus.aio import ServiceBusClient, ServiceBusSender
@@ -92,7 +93,7 @@ class ServiceBusNotificationService(BaseNotificationService):
         """Initialize the service."""
         self._client = client
 
-    async def async_send_message(self, message, **kwargs):
+    async def async_send_message(self, message: str, **kwargs: Any) -> None:
         """Send a message."""
         dto = {ATTR_ASB_MESSAGE: message}
 

homeassistant/components/backblaze_b2/__init__.py

@@ -6,13 +6,15 @@ from datetime import timedelta
 import logging
 from typing import Any
 
-from b2sdk.v2 import B2Api, Bucket, InMemoryAccountInfo, exception
+from b2sdk.v2 import Bucket, exception
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers.event import async_track_time_interval
 
+# Import from b2_client to ensure timeout configuration is applied
+from .b2_client import B2Api, InMemoryAccountInfo
 from .const import (
     BACKBLAZE_REALM,
     CONF_APPLICATION_KEY,
@@ -72,7 +74,11 @@ async def async_setup_entry(hass: HomeAssistant, entry: BackblazeConfigEntry) ->
             translation_domain=DOMAIN,
             translation_key="invalid_bucket_name",
         ) from err
-    except exception.ConnectionReset as err:
+    except (
+        exception.B2ConnectionError,
+        exception.B2RequestTimeout,
+        exception.ConnectionReset,
+    ) as err:
         raise ConfigEntryNotReady(
             translation_domain=DOMAIN,
             translation_key="cannot_connect",

homeassistant/components/backblaze_b2/b2_client.py

@@ -0,0 +1,39 @@
+"""Backblaze B2 client with extended timeouts.
+
+The b2sdk library uses class-level timeout attributes. To avoid modifying
+global library state, we subclass the relevant classes to provide extended
+timeouts suitable for backup operations involving large files.
+"""
+
+from b2sdk.v2 import B2Api as BaseB2Api, InMemoryAccountInfo
+from b2sdk.v2.b2http import B2Http as BaseB2Http
+from b2sdk.v2.session import B2Session as BaseB2Session
+
+# Extended timeouts for Home Assistant backup operations
+# Default CONNECTION_TIMEOUT is 46 seconds, which can be too short for slow connections
+CONNECTION_TIMEOUT = 120  # 2 minutes
+
+# Default TIMEOUT_FOR_UPLOAD is 128 seconds, which is too short for large backups
+TIMEOUT_FOR_UPLOAD = 43200  # 12 hours
+
+
+class B2Http(BaseB2Http):  # type: ignore[misc]
+    """B2Http with extended timeouts for backup operations."""
+
+    CONNECTION_TIMEOUT = CONNECTION_TIMEOUT
+    TIMEOUT_FOR_UPLOAD = TIMEOUT_FOR_UPLOAD
+
+
+class B2Session(BaseB2Session):  # type: ignore[misc]
+    """B2Session using custom B2Http with extended timeouts."""
+
+    B2HTTP_CLASS = B2Http
+
+
+class B2Api(BaseB2Api):  # type: ignore[misc]
+    """B2Api using custom session with extended timeouts."""
+
+    SESSION_CLASS = B2Session
+
+
+__all__ = ["B2Api", "InMemoryAccountInfo"]

homeassistant/components/backblaze_b2/backup.py

@@ -36,6 +36,10 @@ _LOGGER = logging.getLogger(__name__)
 # Cache TTL for backup list (in seconds)
 CACHE_TTL = 300
 
+# Timeout for upload operations (in seconds)
+# This prevents uploads from hanging indefinitely
+UPLOAD_TIMEOUT = 43200  # 12 hours (matches B2 HTTP timeout)
+
 
 def suggested_filenames(backup: AgentBackup) -> tuple[str, str]:
     """Return the suggested filenames for the backup and metadata files."""
@@ -329,13 +333,28 @@ class BackblazeBackupAgent(BackupAgent):
         _LOGGER.debug("Uploading backup file %s with streaming", filename)
         try:
             content_type, _ = mimetypes.guess_type(filename)
-            file_version = await self._hass.async_add_executor_job(
-                self._upload_unbound_stream_sync,
-                reader,
-                filename,
-                content_type or "application/x-tar",
-                file_info,
+            file_version = await asyncio.wait_for(
+                self._hass.async_add_executor_job(
+                    self._upload_unbound_stream_sync,
+                    reader,
+                    filename,
+                    content_type or "application/x-tar",
+                    file_info,
+                ),
+                timeout=UPLOAD_TIMEOUT,
             )
+        except TimeoutError:
+            _LOGGER.error(
+                "Upload of %s timed out after %s seconds", filename, UPLOAD_TIMEOUT
+            )
+            reader.abort()
+            raise BackupAgentError(
+                f"Upload timed out after {UPLOAD_TIMEOUT} seconds"
+            ) from None
+        except asyncio.CancelledError:
+            _LOGGER.warning("Upload of %s was cancelled", filename)
+            reader.abort()
+            raise
         finally:
             reader.close()
 

homeassistant/components/backblaze_b2/config_flow.py

@@ -6,7 +6,7 @@ from collections.abc import Mapping
 import logging
 from typing import Any
 
-from b2sdk.v2 import B2Api, InMemoryAccountInfo, exception
+from b2sdk.v2 import exception
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
@@ -17,6 +17,8 @@ from homeassistant.helpers.selector import (
     TextSelectorType,
 )
 
+# Import from b2_client to ensure timeout configuration is applied
+from .b2_client import B2Api, InMemoryAccountInfo
 from .const import (
     BACKBLAZE_REALM,
     CONF_APPLICATION_KEY,
@@ -172,8 +174,12 @@ class BackblazeConfigFlow(ConfigFlow, domain=DOMAIN):
                 "Backblaze B2 bucket '%s' does not exist", user_input[CONF_BUCKET]
             )
             errors[CONF_BUCKET] = "invalid_bucket_name"
-        except exception.ConnectionReset:
-            _LOGGER.error("Failed to connect to Backblaze B2. Connection reset")
+        except (
+            exception.B2ConnectionError,
+            exception.B2RequestTimeout,
+            exception.ConnectionReset,
+        ) as err:
+            _LOGGER.error("Failed to connect to Backblaze B2: %s", err)
             errors["base"] = "cannot_connect"
         except exception.MissingAccountData:
             # This generally indicates an issue with how InMemoryAccountInfo is used

homeassistant/components/backblaze_b2/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_push",
   "loggers": ["b2sdk"],
   "quality_scale": "bronze",
-  "requirements": ["b2sdk==2.8.1"]
+  "requirements": ["b2sdk==2.10.1"]
 }

homeassistant/components/bang_olufsen/__init__.py

@@ -34,7 +34,12 @@ class BeoData:
 
 type BeoConfigEntry = ConfigEntry[BeoData]
 
-PLATFORMS = [Platform.EVENT, Platform.MEDIA_PLAYER]
+PLATFORMS = [
+    Platform.BINARY_SENSOR,
+    Platform.EVENT,
+    Platform.MEDIA_PLAYER,
+    Platform.SENSOR,
+]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: BeoConfigEntry) -> bool:

homeassistant/components/bang_olufsen/binary_sensor.py

@@ -0,0 +1,63 @@
+"""Binary Sensor entities for the Bang & Olufsen integration."""
+
+from __future__ import annotations
+
+from mozart_api.models import BatteryState
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDeviceClass,
+    BinarySensorEntity,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import BeoConfigEntry
+from .const import CONNECTION_STATUS, DOMAIN, WebsocketNotification
+from .entity import BeoEntity
+from .util import supports_battery
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: BeoConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Binary Sensor entities from config entry."""
+    if await supports_battery(config_entry.runtime_data.client):
+        async_add_entities(new_entities=[BeoBinarySensorBatteryCharging(config_entry)])
+
+
+class BeoBinarySensorBatteryCharging(BinarySensorEntity, BeoEntity):
+    """Battery charging Binary Sensor."""
+
+    _attr_device_class = BinarySensorDeviceClass.BATTERY_CHARGING
+    _attr_is_on = False
+
+    def __init__(self, config_entry: BeoConfigEntry) -> None:
+        """Init the battery charging Binary Sensor."""
+        super().__init__(config_entry, config_entry.runtime_data.client)
+
+        self._attr_unique_id = f"{self._unique_id}_charging"
+
+    async def async_added_to_hass(self) -> None:
+        """Turn on the dispatchers."""
+        self.async_on_remove(
+            async_dispatcher_connect(
+                self.hass,
+                f"{DOMAIN}_{self._unique_id}_{CONNECTION_STATUS}",
+                self._async_update_connection_state,
+            )
+        )
+        self.async_on_remove(
+            async_dispatcher_connect(
+                self.hass,
+                f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.BATTERY}",
+                self._update_battery_charging,
+            )
+        )
+
+    async def _update_battery_charging(self, data: BatteryState) -> None:
+        """Update battery charging."""
+        self._attr_is_on = bool(data.is_charging)
+        self.async_write_ha_state()

homeassistant/components/bang_olufsen/const.py

@@ -115,6 +115,7 @@ class WebsocketNotification(StrEnum):
     """Enum for WebSocket notification types."""
 
     ACTIVE_LISTENING_MODE = "active_listening_mode"
+    BATTERY = "battery"
     BEO_REMOTE_BUTTON = "beo_remote_button"
     BUTTON = "button"
     PLAYBACK_ERROR = "playback_error"

homeassistant/components/bang_olufsen/diagnostics.py

@@ -4,15 +4,17 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
+from homeassistant.components.binary_sensor import DOMAIN as BINARY_SENSOR_DOMAIN
 from homeassistant.components.event import DOMAIN as EVENT_DOMAIN
 from homeassistant.components.media_player import DOMAIN as MEDIA_PLAYER_DOMAIN
+from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
 from homeassistant.const import CONF_MODEL
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
 
 from . import BeoConfigEntry
 from .const import DOMAIN
-from .util import get_device_buttons
+from .util import get_device_buttons, get_remote_keys, get_remotes
 
 
 async def async_get_config_entry_diagnostics(
@@ -53,4 +55,58 @@ async def async_get_config_entry_diagnostics(
                 state_dict.pop("context")
                 data[f"{device_button}_event"] = state_dict
 
+    # Get remotes
+    for remote in await get_remotes(config_entry.runtime_data.client):
+        # Get Battery Sensor states
+        if entity_id := entity_registry.async_get_entity_id(
+            SENSOR_DOMAIN,
+            DOMAIN,
+            f"{remote.serial_number}_{config_entry.unique_id}_remote_battery_level",
+        ):
+            if state := hass.states.get(entity_id):
+                state_dict = dict(state.as_dict())
+
+                # Remove context as it is not relevant
+                state_dict.pop("context")
+                data[f"remote_{remote.serial_number}_battery_level"] = state_dict
+
+        # Get key Event entity states (if enabled)
+        for key_type in get_remote_keys():
+            if entity_id := entity_registry.async_get_entity_id(
+                EVENT_DOMAIN,
+                DOMAIN,
+                f"{remote.serial_number}_{config_entry.unique_id}_{key_type}",
+            ):
+                if state := hass.states.get(entity_id):
+                    state_dict = dict(state.as_dict())
+
+                    # Remove context as it is not relevant
+                    state_dict.pop("context")
+                    data[f"remote_{remote.serial_number}_{key_type}_event"] = state_dict
+
+        # Add remote Mozart model
+        data[f"remote_{remote.serial_number}"] = dict(remote)
+
+    # Get Mozart battery entity
+    if entity_id := entity_registry.async_get_entity_id(
+        SENSOR_DOMAIN, DOMAIN, f"{config_entry.unique_id}_battery_level"
+    ):
+        if state := hass.states.get(entity_id):
+            state_dict = dict(state.as_dict())
+
+            # Remove context as it is not relevant
+            state_dict.pop("context")
+            data["battery_level"] = state_dict
+
+    # Get Mozart battery charging entity
+    if entity_id := entity_registry.async_get_entity_id(
+        BINARY_SENSOR_DOMAIN, DOMAIN, f"{config_entry.unique_id}_charging"
+    ):
+        if state := hass.states.get(entity_id):
+            state_dict = dict(state.as_dict())
+
+            # Remove context as it is not relevant
+            state_dict.pop("context")
+            data["charging"] = state_dict
+
     return data

homeassistant/components/bang_olufsen/event.py

@@ -16,11 +16,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import BeoConfigEntry
 from .const import (
-    BEO_REMOTE_CONTROL_KEYS,
     BEO_REMOTE_KEY_EVENTS,
-    BEO_REMOTE_KEYS,
-    BEO_REMOTE_SUBMENU_CONTROL,
-    BEO_REMOTE_SUBMENU_LIGHT,
     CONNECTION_STATUS,
     DEVICE_BUTTON_EVENTS,
     DOMAIN,
@@ -29,7 +25,7 @@ from .const import (
     WebsocketNotification,
 )
 from .entity import BeoEntity
-from .util import get_device_buttons, get_remotes
+from .util import get_device_buttons, get_remote_keys, get_remotes
 
 PARALLEL_UPDATES = 0
 
@@ -40,38 +36,19 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Event entities from config entry."""
-    entities: list[BeoEvent] = []
-
-    async_add_entities(
+    entities: list[BeoEvent] = [
         BeoButtonEvent(config_entry, button_type)
         for button_type in get_device_buttons(config_entry.data[CONF_MODEL])
-    )
+    ]
 
     # Check for connected Beoremote One
     remotes = await get_remotes(config_entry.runtime_data.client)
 
     for remote in remotes:
-        # Add Light keys
         entities.extend(
             [
-                BeoRemoteKeyEvent(
-                    config_entry,
-                    remote,
-                    f"{BEO_REMOTE_SUBMENU_LIGHT}/{key_type}",
-                )
-                for key_type in BEO_REMOTE_KEYS
-            ]
-        )
-
-        # Add Control keys
-        entities.extend(
-            [
-                BeoRemoteKeyEvent(
-                    config_entry,
-                    remote,
-                    f"{BEO_REMOTE_SUBMENU_CONTROL}/{key_type}",
-                )
-                for key_type in (*BEO_REMOTE_KEYS, *BEO_REMOTE_CONTROL_KEYS)
+                BeoRemoteKeyEvent(config_entry, remote, key_type)
+                for key_type in get_remote_keys()
             ]
         )
 

homeassistant/components/bang_olufsen/sensor.py

@@ -0,0 +1,139 @@
+"""Sensor entities for the Bang & Olufsen integration."""
+
+from __future__ import annotations
+
+import contextlib
+from datetime import timedelta
+
+from aiohttp import ClientConnectorError
+from mozart_api.exceptions import ApiException
+from mozart_api.models import BatteryState, PairedRemote
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorStateClass,
+)
+from homeassistant.const import PERCENTAGE
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import BeoConfigEntry
+from .const import CONNECTION_STATUS, DOMAIN, WebsocketNotification
+from .entity import BeoEntity
+from .util import get_remotes, supports_battery
+
+SCAN_INTERVAL = timedelta(minutes=15)
+
+PARALLEL_UPDATES = 0
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: BeoConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Sensor entities from config entry."""
+    entities: list[BeoSensor] = []
+
+    # Check for Mozart device with battery
+    if await supports_battery(config_entry.runtime_data.client):
+        entities.append(BeoSensorBatteryLevel(config_entry))
+
+    # Add any Beoremote One remotes
+    entities.extend(
+        [
+            BeoSensorRemoteBatteryLevel(config_entry, remote)
+            for remote in (await get_remotes(config_entry.runtime_data.client))
+        ]
+    )
+
+    async_add_entities(entities, update_before_add=True)
+
+
+class BeoSensor(SensorEntity, BeoEntity):
+    """Base Bang & Olufsen Sensor."""
+
+    def __init__(self, config_entry: BeoConfigEntry) -> None:
+        """Initialize Sensor."""
+        super().__init__(config_entry, config_entry.runtime_data.client)
+
+
+class BeoSensorBatteryLevel(BeoSensor):
+    """Battery level Sensor for Mozart devices."""
+
+    _attr_device_class = SensorDeviceClass.BATTERY
+    _attr_native_unit_of_measurement = PERCENTAGE
+    _attr_state_class = SensorStateClass.MEASUREMENT
+
+    def __init__(self, config_entry: BeoConfigEntry) -> None:
+        """Init the battery level Sensor."""
+        super().__init__(config_entry)
+
+        self._attr_unique_id = f"{self._unique_id}_battery_level"
+
+    async def async_added_to_hass(self) -> None:
+        """Turn on the dispatchers."""
+        self.async_on_remove(
+            async_dispatcher_connect(
+                self.hass,
+                f"{DOMAIN}_{self._unique_id}_{CONNECTION_STATUS}",
+                self._async_update_connection_state,
+            )
+        )
+        self.async_on_remove(
+            async_dispatcher_connect(
+                self.hass,
+                f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.BATTERY}",
+                self._update_battery,
+            )
+        )
+
+    async def _update_battery(self, data: BatteryState) -> None:
+        """Update sensor value."""
+        self._attr_native_value = data.battery_level
+        self.async_write_ha_state()
+
+
+class BeoSensorRemoteBatteryLevel(BeoSensor):
+    """Battery level Sensor for the Beoremote One."""
+
+    _attr_device_class = SensorDeviceClass.BATTERY
+    _attr_native_unit_of_measurement = PERCENTAGE
+    _attr_should_poll = True
+    _attr_state_class = SensorStateClass.MEASUREMENT
+
+    def __init__(self, config_entry: BeoConfigEntry, remote: PairedRemote) -> None:
+        """Init the battery level Sensor."""
+        super().__init__(config_entry)
+        # Serial number is not None, as the remote object is provided by get_remotes
+        assert remote.serial_number
+
+        self._attr_unique_id = (
+            f"{remote.serial_number}_{self._unique_id}_remote_battery_level"
+        )
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, f"{remote.serial_number}_{self._unique_id}")}
+        )
+        self._attr_native_value = remote.battery_level
+        self._remote = remote
+
+    async def async_added_to_hass(self) -> None:
+        """Turn on the dispatchers."""
+        self.async_on_remove(
+            async_dispatcher_connect(
+                self.hass,
+                f"{DOMAIN}_{self._unique_id}_{CONNECTION_STATUS}",
+                self._async_update_connection_state,
+            )
+        )
+
+    async def async_update(self) -> None:
+        """Poll battery status."""
+        with contextlib.suppress(ApiException, ClientConnectorError, TimeoutError):
+            for remote in await get_remotes(self._client):
+                if remote.serial_number == self._remote.serial_number:
+                    self._attr_native_value = remote.battery_level
+                    break

homeassistant/components/bang_olufsen/util.py

@@ -11,7 +11,16 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.device_registry import DeviceEntry
 
-from .const import DEVICE_BUTTONS, DOMAIN, BeoButtons, BeoModel
+from .const import (
+    BEO_REMOTE_CONTROL_KEYS,
+    BEO_REMOTE_KEYS,
+    BEO_REMOTE_SUBMENU_CONTROL,
+    BEO_REMOTE_SUBMENU_LIGHT,
+    DEVICE_BUTTONS,
+    DOMAIN,
+    BeoButtons,
+    BeoModel,
+)
 
 
 def get_device(hass: HomeAssistant, unique_id: str) -> DeviceEntry:
@@ -64,3 +73,21 @@ def get_device_buttons(model: BeoModel) -> list[str]:
         buttons.remove(BeoButtons.BLUETOOTH)
 
     return buttons
+
+
+def get_remote_keys() -> list[str]:
+    """Get remote keys for the Beoremote One. Formatted for Home Assistant use."""
+    return [
+        *[f"{BEO_REMOTE_SUBMENU_LIGHT}/{key_type}" for key_type in BEO_REMOTE_KEYS],
+        *[
+            f"{BEO_REMOTE_SUBMENU_CONTROL}/{key_type}"
+            for key_type in (*BEO_REMOTE_KEYS, *BEO_REMOTE_CONTROL_KEYS)
+        ],
+    ]
+
+
+async def supports_battery(client: MozartClient) -> bool:
+    """Get if a Mozart device has a battery."""
+    battery_state = await client.get_battery_state()
+
+    return battery_state.state != "BatteryNotPresent"

homeassistant/components/bang_olufsen/websocket.py

@@ -6,6 +6,7 @@ import logging
 from typing import TYPE_CHECKING
 
 from mozart_api.models import (
+    BatteryState,
     BeoRemoteButton,
     ButtonEvent,
     ListeningModeProps,
@@ -60,6 +61,7 @@ class BeoWebsocket(BeoBase):
         self._client.get_active_listening_mode_notifications(
             self.on_active_listening_mode
         )
+        self._client.get_battery_notifications(self.on_battery_notification)
         self._client.get_beo_remote_button_notifications(
             self.on_beo_remote_button_notification
         )
@@ -115,6 +117,14 @@ class BeoWebsocket(BeoBase):
             notification,
         )
 
+    def on_battery_notification(self, notification: BatteryState) -> None:
+        """Send battery dispatch."""
+        async_dispatcher_send(
+            self.hass,
+            f"{DOMAIN}_{self._unique_id}_{WebsocketNotification.BATTERY}",
+            notification,
+        )
+
     def on_beo_remote_button_notification(self, notification: BeoRemoteButton) -> None:
         """Send beo_remote_button dispatch."""
         if TYPE_CHECKING:

homeassistant/components/binary_sensor/trigger.py

@@ -47,7 +47,7 @@ def make_binary_sensor_trigger(
         """Trigger for entity state changes."""
 
         _device_class = device_class
-        _to_state = to_state
+        _to_states = {to_state}
 
     return CustomTrigger
 

homeassistant/components/blackbird/manifest.json

@@ -2,7 +2,6 @@
   "domain": "blackbird",
   "name": "Monoprice Blackbird Matrix Switch",
   "codeowners": [],
-  "disabled": "This integration is disabled because it references pyserial-asyncio, which does blocking I/O in the asyncio loop and is not maintained.",
   "documentation": "https://www.home-assistant.io/integrations/blackbird",
   "iot_class": "local_polling",
   "loggers": ["pyblackbird"],

homeassistant/components/bluesound/__init__.py

@@ -2,16 +2,25 @@
 
 from pyblu import Player
 from pyblu.errors import PlayerUnreachableError
+import voluptuous as vol
 
+from homeassistant.components.media_player import DOMAIN as MEDIA_PLAYER_DOMAIN
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, CONF_PORT, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
-from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers import config_validation as cv, service
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.typing import ConfigType
 
-from .const import DOMAIN
+from .const import (
+    ATTR_MASTER,
+    DOMAIN,
+    SERVICE_CLEAR_TIMER,
+    SERVICE_JOIN,
+    SERVICE_SET_TIMER,
+    SERVICE_UNJOIN,
+)
 from .coordinator import (
     BluesoundConfigEntry,
     BluesoundCoordinator,
@@ -28,6 +37,38 @@ PLATFORMS = [
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the Bluesound."""
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_SET_TIMER,
+        entity_domain=MEDIA_PLAYER_DOMAIN,
+        schema=None,
+        func="async_increase_timer",
+    )
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_CLEAR_TIMER,
+        entity_domain=MEDIA_PLAYER_DOMAIN,
+        schema=None,
+        func="async_clear_timer",
+    )
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_JOIN,
+        entity_domain=MEDIA_PLAYER_DOMAIN,
+        schema={vol.Required(ATTR_MASTER): cv.entity_id},
+        func="async_bluesound_join",
+    )
+    service.async_register_platform_entity_service(
+        hass,
+        DOMAIN,
+        SERVICE_UNJOIN,
+        entity_domain=MEDIA_PLAYER_DOMAIN,
+        schema=None,
+        func="async_bluesound_unjoin",
+    )
     return True
 
 

homeassistant/components/bluesound/const.py

@@ -4,3 +4,8 @@ DOMAIN = "bluesound"
 INTEGRATION_TITLE = "Bluesound"
 ATTR_BLUESOUND_GROUP = "bluesound_group"
 ATTR_MASTER = "master"
+
+SERVICE_CLEAR_TIMER = "clear_sleep_timer"
+SERVICE_JOIN = "join"
+SERVICE_SET_TIMER = "set_sleep_timer"
+SERVICE_UNJOIN = "unjoin"

homeassistant/components/bluesound/media_player.py

@@ -8,7 +8,6 @@ import logging
 from typing import TYPE_CHECKING, Any
 
 from pyblu import Input, Player, Preset, Status, SyncStatus
-import voluptuous as vol
 
 from homeassistant.components import media_source
 from homeassistant.components.media_player import (
@@ -22,11 +21,7 @@ from homeassistant.components.media_player import (
 from homeassistant.const import CONF_HOST, CONF_PORT
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import ServiceValidationError
-from homeassistant.helpers import (
-    config_validation as cv,
-    entity_platform,
-    issue_registry as ir,
-)
+from homeassistant.helpers import entity_registry as er, issue_registry as ir
 from homeassistant.helpers.device_registry import (
     CONNECTION_NETWORK_MAC,
     DeviceInfo,
@@ -40,9 +35,22 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 from homeassistant.util import dt as dt_util, slugify
 
-from .const import ATTR_BLUESOUND_GROUP, ATTR_MASTER, DOMAIN
+from .const import (
+    ATTR_BLUESOUND_GROUP,
+    ATTR_MASTER,
+    DOMAIN,
+    SERVICE_CLEAR_TIMER,
+    SERVICE_JOIN,
+    SERVICE_SET_TIMER,
+    SERVICE_UNJOIN,
+)
 from .coordinator import BluesoundCoordinator
-from .utils import dispatcher_join_signal, dispatcher_unjoin_signal, format_unique_id
+from .utils import (
+    dispatcher_join_signal,
+    dispatcher_unjoin_signal,
+    format_unique_id,
+    id_to_paired_player,
+)
 
 if TYPE_CHECKING:
     from . import BluesoundConfigEntry
@@ -54,11 +62,6 @@ SCAN_INTERVAL = timedelta(minutes=15)
 DATA_BLUESOUND = DOMAIN
 DEFAULT_PORT = 11000
 
-SERVICE_CLEAR_TIMER = "clear_sleep_timer"
-SERVICE_JOIN = "join"
-SERVICE_SET_TIMER = "set_sleep_timer"
-SERVICE_UNJOIN = "unjoin"
-
 POLL_TIMEOUT = 120
 
 
@@ -75,18 +78,6 @@ async def async_setup_entry(
         config_entry.runtime_data.player,
     )
 
-    platform = entity_platform.async_get_current_platform()
-    platform.async_register_entity_service(
-        SERVICE_SET_TIMER, None, "async_increase_timer"
-    )
-    platform.async_register_entity_service(
-        SERVICE_CLEAR_TIMER, None, "async_clear_timer"
-    )
-    platform.async_register_entity_service(
-        SERVICE_JOIN, {vol.Required(ATTR_MASTER): cv.entity_id}, "async_join"
-    )
-    platform.async_register_entity_service(SERVICE_UNJOIN, None, "async_unjoin")
-
     async_add_entities([bluesound_player], update_before_add=True)
 
 
@@ -120,6 +111,7 @@ class BluesoundPlayer(CoordinatorEntity[BluesoundCoordinator], MediaPlayerEntity
         self._presets: list[Preset] = coordinator.data.presets
         self._group_name: str | None = None
         self._group_list: list[str] = []
+        self._group_members: list[str] | None = None
         self._bluesound_device_name = sync_status.name
         self._player = player
         self._last_status_update = dt_util.utcnow()
@@ -180,6 +172,7 @@ class BluesoundPlayer(CoordinatorEntity[BluesoundCoordinator], MediaPlayerEntity
         self._last_status_update = dt_util.utcnow()
 
         self._group_list = self.rebuild_bluesound_group()
+        self._group_members = self.rebuild_group_members()
 
         self.async_write_ha_state()
 
@@ -365,11 +358,13 @@ class BluesoundPlayer(CoordinatorEntity[BluesoundCoordinator], MediaPlayerEntity
                 MediaPlayerEntityFeature.VOLUME_STEP
                 | MediaPlayerEntityFeature.VOLUME_SET
                 | MediaPlayerEntityFeature.VOLUME_MUTE
+                | MediaPlayerEntityFeature.GROUPING
             )
 
         supported = (
             MediaPlayerEntityFeature.CLEAR_PLAYLIST
             | MediaPlayerEntityFeature.BROWSE_MEDIA
+            | MediaPlayerEntityFeature.GROUPING
         )
 
         if not self._status.indexing:
@@ -421,8 +416,57 @@ class BluesoundPlayer(CoordinatorEntity[BluesoundCoordinator], MediaPlayerEntity
 
         return shuffle
 
-    async def async_join(self, master: str) -> None:
+    @property
+    def group_members(self) -> list[str] | None:
+        """Get list of group members. Leader is always first."""
+        return self._group_members
+
+    async def async_join_players(self, group_members: list[str]) -> None:
+        """Join `group_members` as a player group with the current player."""
+        if self.entity_id in group_members:
+            raise ServiceValidationError("Cannot join player to itself")
+
+        entity_ids_with_sync_status = self._entity_ids_with_sync_status()
+
+        paired_players = []
+        for group_member in group_members:
+            sync_status = entity_ids_with_sync_status.get(group_member)
+            if sync_status is None:
+                continue
+            paired_player = id_to_paired_player(sync_status.id)
+            if paired_player:
+                paired_players.append(paired_player)
+
+        if paired_players:
+            await self._player.add_followers(paired_players)
+
+    async def async_unjoin_player(self) -> None:
+        """Remove this player from any group."""
+        if self._sync_status.leader is not None:
+            leader_id = f"{self._sync_status.leader.ip}:{self._sync_status.leader.port}"
+            async_dispatcher_send(
+                self.hass, dispatcher_unjoin_signal(leader_id), self.host, self.port
+            )
+
+        if self._sync_status.followers is not None:
+            await self._player.remove_follower(self.host, self.port)
+
+    async def async_bluesound_join(self, master: str) -> None:
         """Join the player to a group."""
+        ir.async_create_issue(
+            self.hass,
+            DOMAIN,
+            f"deprecated_service_{SERVICE_JOIN}",
+            is_fixable=False,
+            breaks_in_ha_version="2026.7.0",
+            issue_domain=DOMAIN,
+            severity=ir.IssueSeverity.WARNING,
+            translation_key="deprecated_service_join",
+            translation_placeholders={
+                "name": slugify(self.sync_status.name),
+            },
+        )
+
         if master == self.entity_id:
             raise ServiceValidationError("Cannot join player to itself")
 
@@ -431,18 +475,24 @@ class BluesoundPlayer(CoordinatorEntity[BluesoundCoordinator], MediaPlayerEntity
             self.hass, dispatcher_join_signal(master), self.host, self.port
         )
 
-    async def async_unjoin(self) -> None:
+    async def async_bluesound_unjoin(self) -> None:
         """Unjoin the player from a group."""
-        if self._sync_status.leader is None:
-            return
-
-        leader_id = f"{self._sync_status.leader.ip}:{self._sync_status.leader.port}"
-
-        _LOGGER.debug("Trying to unjoin player: %s", self.id)
-        async_dispatcher_send(
-            self.hass, dispatcher_unjoin_signal(leader_id), self.host, self.port
+        ir.async_create_issue(
+            self.hass,
+            DOMAIN,
+            f"deprecated_service_{SERVICE_UNJOIN}",
+            is_fixable=False,
+            breaks_in_ha_version="2026.7.0",
+            issue_domain=DOMAIN,
+            severity=ir.IssueSeverity.WARNING,
+            translation_key="deprecated_service_unjoin",
+            translation_placeholders={
+                "name": slugify(self.sync_status.name),
+            },
         )
 
+        await self.async_unjoin_player()
+
     @property
     def extra_state_attributes(self) -> dict[str, Any] | None:
         """List members in group."""
@@ -488,6 +538,63 @@ class BluesoundPlayer(CoordinatorEntity[BluesoundCoordinator], MediaPlayerEntity
         follower_names.insert(0, leader_sync_status.name)
         return follower_names
 
+    def rebuild_group_members(self) -> list[str] | None:
+        """Get list of group members. Leader is always first."""
+        if self.sync_status.leader is None and self.sync_status.followers is None:
+            return None
+
+        entity_ids_with_sync_status = self._entity_ids_with_sync_status()
+
+        leader_entity_id = None
+        followers = None
+        if self.sync_status.followers is not None:
+            leader_entity_id = self.entity_id
+            followers = self.sync_status.followers
+        elif self.sync_status.leader is not None:
+            leader_id = f"{self.sync_status.leader.ip}:{self.sync_status.leader.port}"
+            for entity_id, sync_status in entity_ids_with_sync_status.items():
+                if sync_status.id == leader_id:
+                    leader_entity_id = entity_id
+                    followers = sync_status.followers
+                    break
+
+        if leader_entity_id is None or followers is None:
+            return None
+
+        grouped_entity_ids = [leader_entity_id]
+        for follower in followers:
+            follower_id = f"{follower.ip}:{follower.port}"
+            entity_ids = [
+                entity_id
+                for entity_id, sync_status in entity_ids_with_sync_status.items()
+                if sync_status.id == follower_id
+            ]
+            match entity_ids:
+                case [entity_id]:
+                    grouped_entity_ids.append(entity_id)
+
+        return grouped_entity_ids
+
+    def _entity_ids_with_sync_status(self) -> dict[str, SyncStatus]:
+        result = {}
+
+        entity_registry = er.async_get(self.hass)
+
+        config_entries: list[BluesoundConfigEntry] = (
+            self.hass.config_entries.async_entries(DOMAIN)
+        )
+        for config_entry in config_entries:
+            entity_entries = er.async_entries_for_config_entry(
+                entity_registry, config_entry.entry_id
+            )
+            for entity_entry in entity_entries:
+                if entity_entry.domain == "media_player":
+                    result[entity_entry.entity_id] = (
+                        config_entry.runtime_data.coordinator.data.sync_status
+                    )
+
+        return result
+
     async def async_add_follower(self, host: str, port: int) -> None:
         """Add follower to leader."""
         await self._player.add_follower(host, port)

homeassistant/components/bluesound/strings.json

@@ -41,9 +41,17 @@
       "description": "Use `button.{name}_clear_sleep_timer` instead.\n\nPlease replace this action and adjust your automations and scripts.",
       "title": "Detected use of deprecated action bluesound.clear_sleep_timer"
     },
+    "deprecated_service_join": {
+      "description": "Use the `media_player.join` action instead.\n\nPlease replace this action and adjust your automations and scripts.",
+      "title": "Detected use of deprecated action bluesound.join"
+    },
     "deprecated_service_set_sleep_timer": {
       "description": "Use `button.{name}_set_sleep_timer` instead.\n\nPlease replace this action and adjust your automations and scripts.",
       "title": "Detected use of deprecated action bluesound.set_sleep_timer"
+    },
+    "deprecated_service_unjoin": {
+      "description": "Use the `media_player.unjoin` action instead.\n\nPlease replace this action and adjust your automations and scripts.",
+      "title": "Detected use of deprecated action bluesound.unjoin"
     }
   },
   "services": {

homeassistant/components/bluesound/utils.py

@@ -1,5 +1,7 @@
 """Utility functions for the Bluesound component."""
 
+from pyblu import PairedPlayer
+
 from homeassistant.helpers.device_registry import format_mac
 
 
@@ -19,3 +21,12 @@ def dispatcher_unjoin_signal(leader_id: str) -> str:
     Id is ip_address:port. This can be obtained from sync_status.id.
     """
     return f"bluesound_unjoin_{leader_id}"
+
+
+def id_to_paired_player(id: str) -> PairedPlayer | None:
+    """Try to convert id in format 'ip:port' to PairedPlayer. Returns None if unable to do so."""
+    match id.rsplit(":", 1):
+        case [str() as ip, str() as port] if port.isdigit():
+            return PairedPlayer(ip, int(port))
+        case _:
+            return None

homeassistant/components/braviatv/__init__.py

@@ -11,6 +11,7 @@ from homeassistant.const import CONF_HOST, CONF_MAC, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.aiohttp_client import async_create_clientsession
 
+from .const import CONF_USE_SSL
 from .coordinator import BraviaTVConfigEntry, BraviaTVCoordinator
 
 PLATFORMS: Final[list[Platform]] = [
@@ -26,11 +27,12 @@ async def async_setup_entry(
     """Set up a config entry."""
     host = config_entry.data[CONF_HOST]
     mac = config_entry.data[CONF_MAC]
+    ssl = config_entry.data.get(CONF_USE_SSL, False)
 
     session = async_create_clientsession(
         hass, cookie_jar=CookieJar(unsafe=True, quote_cookie=False)
     )
-    client = BraviaClient(host, mac, session=session)
+    client = BraviaClient(host, mac, session=session, ssl=ssl)
     coordinator = BraviaTVCoordinator(
         hass=hass,
         config_entry=config_entry,

homeassistant/components/braviatv/config_flow.py

@@ -28,6 +28,7 @@ from .const import (
     ATTR_MODEL,
     CONF_NICKNAME,
     CONF_USE_PSK,
+    CONF_USE_SSL,
     DOMAIN,
     NICKNAME_PREFIX,
 )
@@ -46,11 +47,12 @@ class BraviaTVConfigFlow(ConfigFlow, domain=DOMAIN):
     def create_client(self) -> None:
         """Create Bravia TV client from config."""
         host = self.device_config[CONF_HOST]
+        ssl = self.device_config[CONF_USE_SSL]
         session = async_create_clientsession(
             self.hass,
             cookie_jar=CookieJar(unsafe=True, quote_cookie=False),
         )
-        self.client = BraviaClient(host=host, session=session)
+        self.client = BraviaClient(host=host, session=session, ssl=ssl)
 
     async def gen_instance_ids(self) -> tuple[str, str]:
         """Generate client_id and nickname."""
@@ -123,10 +125,10 @@ class BraviaTVConfigFlow(ConfigFlow, domain=DOMAIN):
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle authorize step."""
-        self.create_client()
-
         if user_input is not None:
             self.device_config[CONF_USE_PSK] = user_input[CONF_USE_PSK]
+            self.device_config[CONF_USE_SSL] = user_input[CONF_USE_SSL]
+            self.create_client()
             if user_input[CONF_USE_PSK]:
                 return await self.async_step_psk()
             return await self.async_step_pin()
@@ -136,6 +138,7 @@ class BraviaTVConfigFlow(ConfigFlow, domain=DOMAIN):
             data_schema=vol.Schema(
                 {
                     vol.Required(CONF_USE_PSK, default=False): bool,
+                    vol.Required(CONF_USE_SSL, default=False): bool,
                 }
             ),
         )

homeassistant/components/braviatv/const.py

@@ -12,6 +12,7 @@ ATTR_MODEL: Final = "model"
 
 CONF_NICKNAME: Final = "nickname"
 CONF_USE_PSK: Final = "use_psk"
+CONF_USE_SSL: Final = "use_ssl"
 
 DOMAIN: Final = "braviatv"
 LEGACY_CLIENT_ID: Final = "HomeAssistant"

homeassistant/components/braviatv/coordinator.py

@@ -22,7 +22,7 @@ from homeassistant.components.media_player import MediaType
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_CLIENT_ID, CONF_PIN
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed
+from homeassistant.exceptions import ConfigEntryAuthFailed, HomeAssistantError
 from homeassistant.helpers.debounce import Debouncer
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
@@ -56,8 +56,31 @@ def catch_braviatv_errors[_BraviaTVCoordinatorT: BraviaTVCoordinator, **_P](
         """Catch Bravia errors and log message."""
         try:
             await func(self, *args, **kwargs)
+        except BraviaNotFound as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="command_error_not_found",
+                translation_placeholders={
+                    "device": self.config_entry.title,
+                },
+            ) from err
+        except (BraviaConnectionError, BraviaConnectionTimeout, BraviaTurnedOff) as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="command_error_offline",
+                translation_placeholders={
+                    "device": self.config_entry.title,
+                },
+            ) from err
         except BraviaError as err:
-            _LOGGER.error("Command error: %s", err)
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="command_error",
+                translation_placeholders={
+                    "device": self.config_entry.title,
+                    "error": repr(err),
+                },
+            ) from err
         await self.async_request_refresh()
 
     return wrapper
@@ -165,17 +188,35 @@ class BraviaTVCoordinator(DataUpdateCoordinator[None]):
             if self.skipped_updates < 10:
                 self.connected = False
                 self.skipped_updates += 1
-                _LOGGER.debug("Update skipped, Bravia API service is reloading")
+                _LOGGER.debug(
+                    "Update for %s skipped: the Bravia API service is reloading",
+                    self.config_entry.title,
+                )
                 return
-            raise UpdateFailed("Error communicating with device") from err
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="update_error_not_found",
+                translation_placeholders={
+                    "device": self.config_entry.title,
+                },
+            ) from err
         except (BraviaConnectionError, BraviaConnectionTimeout, BraviaTurnedOff):
             self.is_on = False
             self.connected = False
-            _LOGGER.debug("Update skipped, Bravia TV is off")
+            _LOGGER.debug(
+                "Update for %s skipped: the TV is turned off", self.config_entry.title
+            )
         except BraviaError as err:
             self.is_on = False
             self.connected = False
-            raise UpdateFailed("Error communicating with device") from err
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="update_error",
+                translation_placeholders={
+                    "device": self.config_entry.title,
+                    "error": repr(err),
+                },
+            ) from err
 
     async def async_update_volume(self) -> None:
         """Update volume information."""

homeassistant/components/braviatv/manifest.json

@@ -7,7 +7,7 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["pybravia"],
-  "requirements": ["pybravia==0.3.4"],
+  "requirements": ["pybravia==0.4.1"],
   "ssdp": [
     {
       "manufacturer": "Sony Corporation",

homeassistant/components/braviatv/strings.json

@@ -15,9 +15,10 @@
     "step": {
       "authorize": {
         "data": {
-          "use_psk": "Use PSK authentication"
+          "use_psk": "Use PSK authentication",
+          "use_ssl": "Use SSL connection"
         },
-        "description": "Make sure that «Control remotely» is enabled on your TV, go to: \nSettings -> Network -> Remote device settings -> Control remotely. \n\nThere are two authorization methods: PIN code or PSK (Pre-Shared Key). \nAuthorization via PSK is recommended as more stable.",
+        "description": "Make sure that «Control remotely» is enabled on your TV. Go to: \nSettings -> Network -> Remote device settings -> Control remotely. \n\nThere are two authorization methods: PIN code or PSK (Pre-Shared Key). \nAuthorization via PSK is recommended, as it is more stable. \n\nUse an SSL connection only if your TV supports this connection type.",
         "title": "Authorize Sony Bravia TV"
       },
       "confirm": {
@@ -54,5 +55,22 @@
         "name": "Terminate apps"
       }
     }
+  },
+  "exceptions": {
+    "command_error": {
+      "message": "Error sending command to {device}: {error}"
+    },
+    "command_error_not_found": {
+      "message": "Error sending command to {device}: the Bravia API service is reloading"
+    },
+    "command_error_offline": {
+      "message": "Error sending command to {device}: the TV is turned off"
+    },
+    "update_error": {
+      "message": "Error updating data for {device}: {error}"
+    },
+    "update_error_not_found": {
+      "message": "Error updating data for {device}: the Bravia API service is stuck"
+    }
   }
 }

homeassistant/components/bsblan/__init__.py

@@ -1,5 +1,6 @@
 """The BSB-Lan integration."""
 
+import asyncio
 import dataclasses
 
 from bsblan import (
@@ -27,13 +28,18 @@ from homeassistant.exceptions import (
     ConfigEntryError,
     ConfigEntryNotReady,
 )
+from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.typing import ConfigType
 
 from .const import CONF_PASSKEY, DOMAIN
 from .coordinator import BSBLanFastCoordinator, BSBLanSlowCoordinator
+from .services import async_setup_services
 
 PLATFORMS = [Platform.CLIMATE, Platform.SENSOR, Platform.WATER_HEATER]
 
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+
 type BSBLanConfigEntry = ConfigEntry[BSBLanData]
 
 
@@ -49,6 +55,12 @@ class BSBLanData:
     static: StaticState
 
 
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the BSB-Lan integration."""
+    async_setup_services(hass)
+    return True
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: BSBLanConfigEntry) -> bool:
     """Set up BSB-Lan from a config entry."""
 
@@ -66,12 +78,16 @@ async def async_setup_entry(hass: HomeAssistant, entry: BSBLanConfigEntry) -> bo
     bsblan = BSBLAN(config, session)
 
     try:
-        # Initialize the client first - this sets up internal caches and validates the connection
+        # Initialize the client first - this sets up internal caches and validates
+        # the connection by fetching firmware version
         await bsblan.initialize()
-        # Fetch all required device metadata
-        device = await bsblan.device()
-        info = await bsblan.info()
-        static = await bsblan.static_values()
+
+        # Fetch device metadata in parallel for faster startup
+        device, info, static = await asyncio.gather(
+            bsblan.device(),
+            bsblan.info(),
+            bsblan.static_values(),
+        )
     except BSBLANConnectionError as err:
         raise ConfigEntryNotReady(
             translation_domain=DOMAIN,
@@ -99,10 +115,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: BSBLanConfigEntry) -> bo
     fast_coordinator = BSBLanFastCoordinator(hass, entry, bsblan)
     slow_coordinator = BSBLanSlowCoordinator(hass, entry, bsblan)
 
-    # Perform first refresh of both coordinators
+    # Perform first refresh of fast coordinator (required for entities)
     await fast_coordinator.async_config_entry_first_refresh()
 
-    # Try to refresh slow coordinator, but don't fail if DHW is not available
+    # Refresh slow coordinator - don't fail if DHW is not available
     # This allows the integration to work even if the device doesn't support DHW
     await slow_coordinator.async_refresh()
 

homeassistant/components/bsblan/climate.py

@@ -111,11 +111,17 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):
             return None
         return self.coordinator.data.state.target_temperature.value
 
+    @property
+    def _hvac_mode_value(self) -> int | str | None:
+        """Return the raw hvac_mode value from the coordinator."""
+        if (hvac_mode := self.coordinator.data.state.hvac_mode) is None:
+            return None
+        return hvac_mode.value
+
     @property
     def hvac_mode(self) -> HVACMode | None:
         """Return hvac operation ie. heat, cool mode."""
-        hvac_mode_value = self.coordinator.data.state.hvac_mode.value
-        if hvac_mode_value is None:
+        if (hvac_mode_value := self._hvac_mode_value) is None:
             return None
         # BSB-Lan returns integer values: 0=off, 1=auto, 2=eco, 3=heat
         if isinstance(hvac_mode_value, int):
@@ -125,9 +131,8 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):
     @property
     def preset_mode(self) -> str | None:
         """Return the current preset mode."""
-        hvac_mode_value = self.coordinator.data.state.hvac_mode.value
         # BSB-Lan mode 2 is eco/reduced mode
-        if hvac_mode_value == 2:
+        if self._hvac_mode_value == 2:
             return PRESET_ECO
         return PRESET_NONE
 

homeassistant/components/bsblan/coordinator.py

@@ -2,7 +2,6 @@
 
 from dataclasses import dataclass
 from datetime import timedelta
-from random import randint
 
 from bsblan import (
     BSBLAN,
@@ -23,6 +22,17 @@ from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, Upda
 
 from .const import DOMAIN, LOGGER, SCAN_INTERVAL_FAST, SCAN_INTERVAL_SLOW
 
+# Filter lists for optimized API calls - only fetch parameters we actually use
+# This significantly reduces response time (~0.2s per parameter saved)
+STATE_INCLUDE = ["current_temperature", "target_temperature", "hvac_mode"]
+SENSOR_INCLUDE = ["current_temperature", "outside_temperature"]
+DHW_STATE_INCLUDE = [
+    "operating_mode",
+    "nominal_setpoint",
+    "dhw_actual_value_top_temperature",
+]
+DHW_CONFIG_INCLUDE = ["reduced_setpoint", "nominal_setpoint_max"]
+
 
 @dataclass
 class BSBLanFastData:
@@ -80,26 +90,18 @@ class BSBLanFastCoordinator(BSBLanCoordinator[BSBLanFastData]):
             config_entry,
             client,
             name=f"{DOMAIN}_fast_{config_entry.data[CONF_HOST]}",
-            update_interval=self._get_update_interval(),
+            update_interval=SCAN_INTERVAL_FAST,
         )
 
-    def _get_update_interval(self) -> timedelta:
-        """Get the update interval with a random offset.
-
-        Add a random number of seconds to avoid timeouts when
-        the BSB-Lan device is already/still busy retrieving data,
-        e.g. for MQTT or internal logging.
-        """
-        return SCAN_INTERVAL_FAST + timedelta(seconds=randint(1, 8))
-
     async def _async_update_data(self) -> BSBLanFastData:
         """Fetch fast-changing data from the BSB-Lan device."""
         try:
             # Client is already initialized in async_setup_entry
-            # Fetch fast-changing data (state, sensor, DHW state)
-            state = await self.client.state()
-            sensor = await self.client.sensor()
-            dhw = await self.client.hot_water_state()
+            # Use include filtering to only fetch parameters we actually use
+            # This reduces response time significantly (~0.2s per parameter)
+            state = await self.client.state(include=STATE_INCLUDE)
+            sensor = await self.client.sensor(include=SENSOR_INCLUDE)
+            dhw = await self.client.hot_water_state(include=DHW_STATE_INCLUDE)
 
         except BSBLANAuthError as err:
             raise ConfigEntryAuthFailed(
@@ -111,9 +113,6 @@ class BSBLanFastCoordinator(BSBLanCoordinator[BSBLanFastData]):
                 f"Error while establishing connection with BSB-Lan device at {host}"
             ) from err
 
-        # Update the interval with random jitter for next update
-        self.update_interval = self._get_update_interval()
-
         return BSBLanFastData(
             state=state,
             sensor=sensor,
@@ -143,8 +142,8 @@ class BSBLanSlowCoordinator(BSBLanCoordinator[BSBLanSlowData]):
         """Fetch slow-changing data from the BSB-Lan device."""
         try:
             # Client is already initialized in async_setup_entry
-            # Fetch slow-changing configuration data
-            dhw_config = await self.client.hot_water_config()
+            # Use include filtering to only fetch parameters we actually use
+            dhw_config = await self.client.hot_water_config(include=DHW_CONFIG_INCLUDE)
             dhw_schedule = await self.client.hot_water_schedule()
 
         except AttributeError:

homeassistant/components/bsblan/entity.py

@@ -29,7 +29,11 @@ class BSBLanEntityBase[_T: BSBLanCoordinator](CoordinatorEntity[_T]):
             connections={(CONNECTION_NETWORK_MAC, format_mac(mac))},
             name=data.device.name,
             manufacturer="BSBLAN Inc.",
-            model=data.info.device_identification.value,
+            model=(
+                data.info.device_identification.value
+                if data.info.device_identification
+                else None
+            ),
             sw_version=data.device.version,
             configuration_url=f"http://{host}",
         )

homeassistant/components/bsblan/icons.json

@@ -0,0 +1,10 @@
+{
+  "services": {
+    "set_hot_water_schedule": {
+      "service": "mdi:calendar-clock"
+    },
+    "sync_time": {
+      "service": "mdi:timer-sync-outline"
+    }
+  }
+}

homeassistant/components/bsblan/manifest.json

@@ -7,7 +7,7 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["bsblan"],
-  "requirements": ["python-bsblan==3.1.4"],
+  "requirements": ["python-bsblan==4.1.0"],
   "zeroconf": [
     {
       "name": "bsb-lan*",

homeassistant/components/bsblan/services.py

@@ -0,0 +1,291 @@
+"""Support for BSB-Lan services."""
+
+from __future__ import annotations
+
+from datetime import time
+import logging
+from typing import TYPE_CHECKING
+
+from bsblan import BSBLANError, DaySchedule, DHWSchedule, TimeSlot
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigEntryState
+from homeassistant.core import HomeAssistant, ServiceCall, callback
+from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
+from homeassistant.helpers import config_validation as cv, device_registry as dr
+from homeassistant.util import dt as dt_util
+
+from .const import DOMAIN
+
+if TYPE_CHECKING:
+    from . import BSBLanConfigEntry
+
+LOGGER = logging.getLogger(__name__)
+
+ATTR_DEVICE_ID = "device_id"
+ATTR_MONDAY_SLOTS = "monday_slots"
+ATTR_TUESDAY_SLOTS = "tuesday_slots"
+ATTR_WEDNESDAY_SLOTS = "wednesday_slots"
+ATTR_THURSDAY_SLOTS = "thursday_slots"
+ATTR_FRIDAY_SLOTS = "friday_slots"
+ATTR_SATURDAY_SLOTS = "saturday_slots"
+ATTR_SUNDAY_SLOTS = "sunday_slots"
+
+# Service names
+SERVICE_SET_HOT_WATER_SCHEDULE = "set_hot_water_schedule"
+SERVICE_SYNC_TIME = "sync_time"
+
+
+# Schema for a single time slot
+_SLOT_SCHEMA = vol.Schema(
+    {
+        vol.Required("start_time"): cv.time,
+        vol.Required("end_time"): cv.time,
+    }
+)
+
+
+SERVICE_SET_HOT_WATER_SCHEDULE_SCHEMA = vol.Schema(
+    {
+        vol.Required(ATTR_DEVICE_ID): cv.string,
+        vol.Optional(ATTR_MONDAY_SLOTS): vol.All(cv.ensure_list, [_SLOT_SCHEMA]),
+        vol.Optional(ATTR_TUESDAY_SLOTS): vol.All(cv.ensure_list, [_SLOT_SCHEMA]),
+        vol.Optional(ATTR_WEDNESDAY_SLOTS): vol.All(cv.ensure_list, [_SLOT_SCHEMA]),
+        vol.Optional(ATTR_THURSDAY_SLOTS): vol.All(cv.ensure_list, [_SLOT_SCHEMA]),
+        vol.Optional(ATTR_FRIDAY_SLOTS): vol.All(cv.ensure_list, [_SLOT_SCHEMA]),
+        vol.Optional(ATTR_SATURDAY_SLOTS): vol.All(cv.ensure_list, [_SLOT_SCHEMA]),
+        vol.Optional(ATTR_SUNDAY_SLOTS): vol.All(cv.ensure_list, [_SLOT_SCHEMA]),
+    }
+)
+
+
+def _convert_time_slots_to_day_schedule(
+    slots: list[dict[str, time]] | None,
+) -> DaySchedule | None:
+    """Convert list of time slot dicts to a DaySchedule object.
+
+    Example: [{"start_time": time(6, 0), "end_time": time(8, 0)},
+              {"start_time": time(17, 0), "end_time": time(21, 0)}]
+    becomes: DaySchedule with two TimeSlot objects
+
+    None returns None (don't modify this day).
+    Empty list returns DaySchedule with empty slots (clear this day).
+    """
+    if slots is None:
+        return None
+
+    if not slots:
+        return DaySchedule(slots=[])
+
+    time_slots = []
+    for slot in slots:
+        start_time = slot["start_time"]
+        end_time = slot["end_time"]
+
+        # Validate that end time is after start time
+        if end_time <= start_time:
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="end_time_before_start_time",
+                translation_placeholders={
+                    "start_time": start_time.strftime("%H:%M"),
+                    "end_time": end_time.strftime("%H:%M"),
+                },
+            )
+
+        time_slots.append(TimeSlot(start=start_time, end=end_time))
+        LOGGER.debug(
+            "Created time slot: %s-%s",
+            start_time.strftime("%H:%M"),
+            end_time.strftime("%H:%M"),
+        )
+
+    LOGGER.debug("Created DaySchedule with %d slots", len(time_slots))
+    return DaySchedule(slots=time_slots)
+
+
+async def set_hot_water_schedule(service_call: ServiceCall) -> None:
+    """Set hot water heating schedule."""
+    device_id = service_call.data[ATTR_DEVICE_ID]
+
+    # Get the device and config entry
+    device_registry = dr.async_get(service_call.hass)
+    device_entry = device_registry.async_get(device_id)
+
+    if device_entry is None:
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="invalid_device_id",
+            translation_placeholders={"device_id": device_id},
+        )
+
+    # Find the config entry for this device
+    matching_entries: list[BSBLanConfigEntry] = [
+        entry
+        for entry in service_call.hass.config_entries.async_entries(DOMAIN)
+        if entry.entry_id in device_entry.config_entries
+    ]
+
+    if not matching_entries:
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="no_config_entry_for_device",
+            translation_placeholders={"device_id": device_entry.name or device_id},
+        )
+
+    entry = matching_entries[0]
+
+    # Verify the config entry is loaded
+    if entry.state is not ConfigEntryState.LOADED:
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="config_entry_not_loaded",
+            translation_placeholders={"device_name": device_entry.name or device_id},
+        )
+
+    client = entry.runtime_data.client
+
+    # Convert time slots to DaySchedule objects
+    monday = _convert_time_slots_to_day_schedule(
+        service_call.data.get(ATTR_MONDAY_SLOTS)
+    )
+    tuesday = _convert_time_slots_to_day_schedule(
+        service_call.data.get(ATTR_TUESDAY_SLOTS)
+    )
+    wednesday = _convert_time_slots_to_day_schedule(
+        service_call.data.get(ATTR_WEDNESDAY_SLOTS)
+    )
+    thursday = _convert_time_slots_to_day_schedule(
+        service_call.data.get(ATTR_THURSDAY_SLOTS)
+    )
+    friday = _convert_time_slots_to_day_schedule(
+        service_call.data.get(ATTR_FRIDAY_SLOTS)
+    )
+    saturday = _convert_time_slots_to_day_schedule(
+        service_call.data.get(ATTR_SATURDAY_SLOTS)
+    )
+    sunday = _convert_time_slots_to_day_schedule(
+        service_call.data.get(ATTR_SUNDAY_SLOTS)
+    )
+
+    # Create the DHWSchedule object
+    dhw_schedule = DHWSchedule(
+        monday=monday,
+        tuesday=tuesday,
+        wednesday=wednesday,
+        thursday=thursday,
+        friday=friday,
+        saturday=saturday,
+        sunday=sunday,
+    )
+
+    LOGGER.debug(
+        "Setting hot water schedule - Monday: %s, Tuesday: %s, Wednesday: %s, "
+        "Thursday: %s, Friday: %s, Saturday: %s, Sunday: %s",
+        monday,
+        tuesday,
+        wednesday,
+        thursday,
+        friday,
+        saturday,
+        sunday,
+    )
+
+    try:
+        # Call the BSB-Lan API to set the schedule
+        await client.set_hot_water_schedule(dhw_schedule)
+    except BSBLANError as err:
+        raise HomeAssistantError(
+            translation_domain=DOMAIN,
+            translation_key="set_schedule_failed",
+            translation_placeholders={"error": str(err)},
+        ) from err
+
+    # Refresh the slow coordinator to get the updated schedule
+    await entry.runtime_data.slow_coordinator.async_request_refresh()
+
+
+async def async_sync_time(service_call: ServiceCall) -> None:
+    """Synchronize BSB-LAN device time with Home Assistant."""
+    device_id: str = service_call.data[ATTR_DEVICE_ID]
+
+    # Get the device and config entry
+    device_registry = dr.async_get(service_call.hass)
+    device_entry = device_registry.async_get(device_id)
+
+    if device_entry is None:
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="invalid_device_id",
+            translation_placeholders={"device_id": device_id},
+        )
+
+    # Find the config entry for this device
+    matching_entries: list[BSBLanConfigEntry] = [
+        entry
+        for entry in service_call.hass.config_entries.async_entries(DOMAIN)
+        if entry.entry_id in device_entry.config_entries
+    ]
+
+    if not matching_entries:
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="no_config_entry_for_device",
+            translation_placeholders={"device_id": device_entry.name or device_id},
+        )
+
+    entry = matching_entries[0]
+
+    # Verify the config entry is loaded
+    if entry.state is not ConfigEntryState.LOADED:
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="config_entry_not_loaded",
+            translation_placeholders={"device_name": device_entry.name or device_id},
+        )
+
+    client = entry.runtime_data.client
+
+    try:
+        # Get current device time
+        device_time = await client.time()
+        current_time = dt_util.now()
+        current_time_str = current_time.strftime("%d.%m.%Y %H:%M:%S")
+
+        # Only sync if device time differs from HA time
+        if device_time.time.value != current_time_str:
+            await client.set_time(current_time_str)
+    except BSBLANError as err:
+        raise HomeAssistantError(
+            translation_domain=DOMAIN,
+            translation_key="sync_time_failed",
+            translation_placeholders={
+                "device_name": device_entry.name or device_id,
+                "error": str(err),
+            },
+        ) from err
+
+
+SYNC_TIME_SCHEMA = vol.Schema(
+    {
+        vol.Required(ATTR_DEVICE_ID): cv.string,
+    }
+)
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Register the BSB-Lan services."""
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_SET_HOT_WATER_SCHEDULE,
+        set_hot_water_schedule,
+        schema=SERVICE_SET_HOT_WATER_SCHEDULE_SCHEMA,
+    )
+
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_SYNC_TIME,
+        async_sync_time,
+        schema=SYNC_TIME_SCHEMA,
+    )

homeassistant/components/bsblan/services.yaml

@@ -0,0 +1,122 @@
+sync_time:
+  fields:
+    device_id:
+      required: true
+      example: "abc123device456"
+      selector:
+        device:
+          integration: bsblan
+
+set_hot_water_schedule:
+  fields:
+    device_id:
+      required: true
+      example: "abc123device456"
+      selector:
+        device:
+          integration: bsblan
+    monday_slots:
+      selector:
+        object:
+          multiple: true
+          label_field: start_time
+          description_field: end_time
+          fields:
+            start_time:
+              required: true
+              selector:
+                time:
+            end_time:
+              required: true
+              selector:
+                time:
+    tuesday_slots:
+      selector:
+        object:
+          multiple: true
+          label_field: start_time
+          description_field: end_time
+          fields:
+            start_time:
+              required: true
+              selector:
+                time:
+            end_time:
+              required: true
+              selector:
+                time:
+    wednesday_slots:
+      selector:
+        object:
+          multiple: true
+          label_field: start_time
+          description_field: end_time
+          fields:
+            start_time:
+              required: true
+              selector:
+                time:
+            end_time:
+              required: true
+              selector:
+                time:
+    thursday_slots:
+      selector:
+        object:
+          multiple: true
+          label_field: start_time
+          description_field: end_time
+          fields:
+            start_time:
+              required: true
+              selector:
+                time:
+            end_time:
+              required: true
+              selector:
+                time:
+    friday_slots:
+      selector:
+        object:
+          multiple: true
+          label_field: start_time
+          description_field: end_time
+          fields:
+            start_time:
+              required: true
+              selector:
+                time:
+            end_time:
+              required: true
+              selector:
+                time:
+    saturday_slots:
+      selector:
+        object:
+          multiple: true
+          label_field: start_time
+          description_field: end_time
+          fields:
+            start_time:
+              required: true
+              selector:
+                time:
+            end_time:
+              required: true
+              selector:
+                time:
+    sunday_slots:
+      selector:
+        object:
+          multiple: true
+          label_field: start_time
+          description_field: end_time
+          fields:
+            start_time:
+              required: true
+              selector:
+                time:
+            end_time:
+              required: true
+              selector:
+                time:

homeassistant/components/bsblan/strings.json

@@ -70,6 +70,18 @@
     }
   },
   "exceptions": {
+    "config_entry_not_loaded": {
+      "message": "The device `{device_name}` is not currently loaded or available"
+    },
+    "end_time_before_start_time": {
+      "message": "End time ({end_time}) must be after start time ({start_time})"
+    },
+    "invalid_device_id": {
+      "message": "Invalid device ID: {device_id}"
+    },
+    "no_config_entry_for_device": {
+      "message": "No configuration entry found for device: {device_id}"
+    },
     "set_data_error": {
       "message": "An error occurred while sending the data to the BSB-Lan device"
     },
@@ -79,6 +91,9 @@
     "set_preset_mode_error": {
       "message": "Can't set preset mode to {preset_mode} when HVAC mode is not set to auto"
     },
+    "set_schedule_failed": {
+      "message": "Failed to set hot water schedule: {error}"
+    },
     "set_temperature_error": {
       "message": "An error occurred while setting the temperature"
     },
@@ -90,6 +105,59 @@
     },
     "setup_general_error": {
       "message": "An unknown error occurred while retrieving static device data"
+    },
+    "sync_time_failed": {
+      "message": "Failed to sync time for {device_name}: {error}"
+    }
+  },
+  "services": {
+    "set_hot_water_schedule": {
+      "description": "Set the hot water heating schedule for a BSB-LAN device.",
+      "fields": {
+        "device_id": {
+          "description": "The BSB-LAN device to configure.",
+          "name": "Device"
+        },
+        "friday_slots": {
+          "description": "Time periods for Friday. Add multiple slots for different heating periods throughout the day.",
+          "name": "Friday time slots"
+        },
+        "monday_slots": {
+          "description": "Time periods for Monday. Add multiple slots for different heating periods throughout the day.",
+          "name": "Monday time slots"
+        },
+        "saturday_slots": {
+          "description": "Time periods for Saturday. Add multiple slots for different heating periods throughout the day.",
+          "name": "Saturday time slots"
+        },
+        "sunday_slots": {
+          "description": "Time periods for Sunday. Add multiple slots for different heating periods throughout the day.",
+          "name": "Sunday time slots"
+        },
+        "thursday_slots": {
+          "description": "Time periods for Thursday. Add multiple slots for different heating periods throughout the day.",
+          "name": "Thursday time slots"
+        },
+        "tuesday_slots": {
+          "description": "Time periods for Tuesday. Add multiple slots for different heating periods throughout the day.",
+          "name": "Tuesday time slots"
+        },
+        "wednesday_slots": {
+          "description": "Time periods for Wednesday. Add multiple slots for different heating periods throughout the day.",
+          "name": "Wednesday time slots"
+        }
+      },
+      "name": "Set hot water schedule"
+    },
+    "sync_time": {
+      "description": "Synchronize Home Assistant time to the BSB-Lan device. Only updates if device time differs from Home Assistant time.",
+      "fields": {
+        "device_id": {
+          "description": "The BSB-LAN device to sync time for.",
+          "name": "Device"
+        }
+      },
+      "name": "Sync time"
     }
   }
 }

homeassistant/components/bthome/manifest.json

@@ -20,5 +20,5 @@
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/bthome",
   "iot_class": "local_push",
-  "requirements": ["bthome-ble==3.15.0"]
+  "requirements": ["bthome-ble==3.16.0"]
 }

homeassistant/components/calendar/icons.json

@@ -15,5 +15,13 @@
     "get_events": {
       "service": "mdi:calendar-month"
     }
+  },
+  "triggers": {
+    "event_ended": {
+      "trigger": "mdi:calendar-end"
+    },
+    "event_started": {
+      "trigger": "mdi:calendar-start"
+    }
   }
 }

homeassistant/components/calendar/strings.json

@@ -45,6 +45,14 @@
       "title": "Detected use of deprecated action calendar.list_events"
     }
   },
+  "selector": {
+    "trigger_offset_type": {
+      "options": {
+        "after": "After",
+        "before": "Before"
+      }
+    }
+  },
   "services": {
     "create_event": {
       "description": "Adds a new calendar event.",
@@ -103,5 +111,35 @@
       "name": "Get events"
     }
   },
-  "title": "Calendar"
+  "title": "Calendar",
+  "triggers": {
+    "event_ended": {
+      "description": "Triggers when a calendar event ends.",
+      "fields": {
+        "offset": {
+          "description": "Offset from the end of the event.",
+          "name": "Offset"
+        },
+        "offset_type": {
+          "description": "Whether to trigger before or after the end of the event, if an offset is defined.",
+          "name": "Offset type"
+        }
+      },
+      "name": "Calendar event ended"
+    },
+    "event_started": {
+      "description": "Triggers when a calendar event starts.",
+      "fields": {
+        "offset": {
+          "description": "Offset from the start of the event.",
+          "name": "Offset"
+        },
+        "offset_type": {
+          "description": "Whether to trigger before or after the start of the event, if an offset is defined.",
+          "name": "Offset type"
+        }
+      },
+      "name": "Calendar event started"
+    }
+  }
 }

homeassistant/components/calendar/trigger.py

@@ -2,24 +2,34 @@
 
 from __future__ import annotations
 
-from collections.abc import Awaitable, Callable, Coroutine
+import asyncio
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 import datetime
 import logging
-from typing import Any
+from typing import TYPE_CHECKING, Any, cast
 
 import voluptuous as vol
 
-from homeassistant.const import CONF_ENTITY_ID, CONF_EVENT, CONF_OFFSET, CONF_PLATFORM
-from homeassistant.core import CALLBACK_TYPE, HassJob, HomeAssistant, callback
+from homeassistant.const import (
+    ATTR_ENTITY_ID,
+    CONF_ENTITY_ID,
+    CONF_EVENT,
+    CONF_OFFSET,
+    CONF_OPTIONS,
+    CONF_TARGET,
+)
+from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback, split_entity_id
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.automation import move_top_level_schema_fields_to_options
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.event import (
     async_track_point_in_time,
     async_track_time_interval,
 )
-from homeassistant.helpers.trigger import TriggerActionType, TriggerInfo
+from homeassistant.helpers.target import TargetEntityChangeTracker, TargetSelection
+from homeassistant.helpers.trigger import Trigger, TriggerActionRunner, TriggerConfig
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util import dt as dt_util
 
@@ -32,12 +42,32 @@ EVENT_START = "start"
 EVENT_END = "end"
 UPDATE_INTERVAL = datetime.timedelta(minutes=15)
 
-TRIGGER_SCHEMA = cv.TRIGGER_BASE_SCHEMA.extend(
+CONF_OFFSET_TYPE = "offset_type"
+OFFSET_TYPE_BEFORE = "before"
+OFFSET_TYPE_AFTER = "after"
+
+
+_SINGLE_ENTITY_EVENT_OPTIONS_SCHEMA = {
+    vol.Required(CONF_ENTITY_ID): cv.entity_id,
+    vol.Optional(CONF_EVENT, default=EVENT_START): vol.In({EVENT_START, EVENT_END}),
+    vol.Optional(CONF_OFFSET, default=datetime.timedelta(0)): cv.time_period,
+}
+
+_SINGLE_ENTITY_EVENT_TRIGGER_SCHEMA = vol.Schema(
     {
-        vol.Required(CONF_PLATFORM): DOMAIN,
-        vol.Required(CONF_ENTITY_ID): cv.entity_id,
-        vol.Optional(CONF_EVENT, default=EVENT_START): vol.In({EVENT_START, EVENT_END}),
-        vol.Optional(CONF_OFFSET, default=datetime.timedelta(0)): cv.time_period,
+        vol.Required(CONF_OPTIONS): _SINGLE_ENTITY_EVENT_OPTIONS_SCHEMA,
+    },
+)
+
+_EVENT_TRIGGER_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_OPTIONS, default={}): {
+            vol.Required(CONF_OFFSET, default=datetime.timedelta(0)): cv.time_period,
+            vol.Required(CONF_OFFSET_TYPE, default=OFFSET_TYPE_BEFORE): vol.In(
+                {OFFSET_TYPE_BEFORE, OFFSET_TYPE_AFTER}
+            ),
+        },
+        vol.Required(CONF_TARGET): cv.TARGET_FIELDS,
     }
 )
 
@@ -50,6 +80,7 @@ class QueuedCalendarEvent:
 
     trigger_time: datetime.datetime
     event: CalendarEvent
+    entity_id: str
 
 
 @dataclass
@@ -89,7 +120,7 @@ class Timespan:
         return f"[{self.start}, {self.end})"
 
 
-type EventFetcher = Callable[[Timespan], Awaitable[list[CalendarEvent]]]
+type EventFetcher = Callable[[Timespan], Awaitable[list[tuple[str, CalendarEvent]]]]
 type QueuedEventFetcher = Callable[[Timespan], Awaitable[list[QueuedCalendarEvent]]]
 
 
@@ -105,15 +136,24 @@ def get_entity(hass: HomeAssistant, entity_id: str) -> CalendarEntity:
     return entity
 
 
-def event_fetcher(hass: HomeAssistant, entity_id: str) -> EventFetcher:
+def event_fetcher(hass: HomeAssistant, entity_ids: set[str]) -> EventFetcher:
     """Build an async_get_events wrapper to fetch events during a time span."""
 
-    async def async_get_events(timespan: Timespan) -> list[CalendarEvent]:
+    async def async_get_events(timespan: Timespan) -> list[tuple[str, CalendarEvent]]:
         """Return events active in the specified time span."""
-        entity = get_entity(hass, entity_id)
         # Expand by one second to make the end time exclusive
         end_time = timespan.end + datetime.timedelta(seconds=1)
-        return await entity.async_get_events(hass, timespan.start, end_time)
+
+        events: list[tuple[str, CalendarEvent]] = []
+        for entity_id in entity_ids:
+            entity = get_entity(hass, entity_id)
+            events.extend(
+                (entity_id, event)
+                for event in await entity.async_get_events(
+                    hass, timespan.start, end_time
+                )
+            )
+        return events
 
     return async_get_events
 
@@ -137,12 +177,11 @@ def queued_event_fetcher(
         # Example: For an EVENT_END trigger the event may start during this
         # time span, but need to be triggered later when the end happens.
         results = []
-        for trigger_time, event in zip(
-            map(get_trigger_time, active_events), active_events, strict=False
-        ):
+        for entity_id, event in active_events:
+            trigger_time = get_trigger_time(event)
             if trigger_time not in offset_timespan:
                 continue
-            results.append(QueuedCalendarEvent(trigger_time + offset, event))
+            results.append(QueuedCalendarEvent(trigger_time + offset, event, entity_id))
 
         _LOGGER.debug(
             "Scan events @ %s%s found %s eligible of %s active",
@@ -169,14 +208,14 @@ class CalendarEventListener:
     def __init__(
         self,
         hass: HomeAssistant,
-        job: HassJob[..., Coroutine[Any, Any, None] | Any],
-        trigger_data: dict[str, Any],
+        action_runner: TriggerActionRunner,
+        trigger_payload: dict[str, Any],
         fetcher: QueuedEventFetcher,
     ) -> None:
         """Initialize CalendarEventListener."""
         self._hass = hass
-        self._job = job
-        self._trigger_data = trigger_data
+        self._action_runner = action_runner
+        self._trigger_payload = trigger_payload
         self._unsub_event: CALLBACK_TYPE | None = None
         self._unsub_refresh: CALLBACK_TYPE | None = None
         self._fetcher = fetcher
@@ -233,15 +272,12 @@ class CalendarEventListener:
         while self._events and self._events[0].trigger_time <= now:
             queued_event = self._events.pop(0)
             _LOGGER.debug("Dispatching event: %s", queued_event.event)
-            self._hass.async_run_hass_job(
-                self._job,
-                {
-                    "trigger": {
-                        **self._trigger_data,
-                        "calendar_event": queued_event.event.as_dict(),
-                    }
-                },
-            )
+            payload = {
+                **self._trigger_payload,
+                ATTR_ENTITY_ID: queued_event.entity_id,
+                "calendar_event": queued_event.event.as_dict(),
+            }
+            self._action_runner(payload, "calendar event state change")
 
     async def _handle_refresh(self, now_utc: datetime.datetime) -> None:
         """Handle core config update."""
@@ -259,31 +295,195 @@ class CalendarEventListener:
         self._listen_next_calendar_event()
 
 
-async def async_attach_trigger(
-    hass: HomeAssistant,
-    config: ConfigType,
-    action: TriggerActionType,
-    trigger_info: TriggerInfo,
-) -> CALLBACK_TYPE:
-    """Attach trigger for the specified calendar."""
-    entity_id = config[CONF_ENTITY_ID]
-    event_type = config[CONF_EVENT]
-    offset = config[CONF_OFFSET]
+class TargetCalendarEventListener(TargetEntityChangeTracker):
+    """Helper class to listen to calendar events for target entity changes."""
 
-    # Validate the entity id is valid
-    get_entity(hass, entity_id)
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        target_selection: TargetSelection,
+        event_type: str,
+        offset: datetime.timedelta,
+        run_action: TriggerActionRunner,
+    ) -> None:
+        """Initialize the state change tracker."""
 
-    trigger_data = {
-        **trigger_info["trigger_data"],
-        "platform": DOMAIN,
-        "event": event_type,
-        "offset": offset,
-    }
-    listener = CalendarEventListener(
-        hass,
-        HassJob(action),
-        trigger_data,
-        queued_event_fetcher(event_fetcher(hass, entity_id), event_type, offset),
-    )
-    await listener.async_attach()
-    return listener.async_detach
+        def entity_filter(entities: set[str]) -> set[str]:
+            return {
+                entity_id
+                for entity_id in entities
+                if split_entity_id(entity_id)[0] == DOMAIN
+            }
+
+        super().__init__(hass, target_selection, entity_filter)
+        self._event_type = event_type
+        self._offset = offset
+        self._run_action = run_action
+        self._trigger_data = {
+            "event": event_type,
+            "offset": offset,
+        }
+
+        self._pending_listener_task: asyncio.Task[None] | None = None
+        self._calendar_event_listener: CalendarEventListener | None = None
+
+    @callback
+    def _handle_entities_update(self, tracked_entities: set[str]) -> None:
+        """Restart the listeners when the list of entities of the tracked targets is updated."""
+        if self._pending_listener_task:
+            self._pending_listener_task.cancel()
+        self._pending_listener_task = self._hass.async_create_task(
+            self._start_listening(tracked_entities)
+        )
+
+    async def _start_listening(self, tracked_entities: set[str]) -> None:
+        """Start listening for calendar events."""
+        _LOGGER.debug("Tracking events for calendars: %s", tracked_entities)
+        if self._calendar_event_listener:
+            self._calendar_event_listener.async_detach()
+        self._calendar_event_listener = CalendarEventListener(
+            self._hass,
+            self._run_action,
+            self._trigger_data,
+            queued_event_fetcher(
+                event_fetcher(self._hass, tracked_entities),
+                self._event_type,
+                self._offset,
+            ),
+        )
+        await self._calendar_event_listener.async_attach()
+
+    def _unsubscribe(self) -> None:
+        """Unsubscribe from all events."""
+        super()._unsubscribe()
+        if self._pending_listener_task:
+            self._pending_listener_task.cancel()
+            self._pending_listener_task = None
+        if self._calendar_event_listener:
+            self._calendar_event_listener.async_detach()
+            self._calendar_event_listener = None
+
+
+class SingleEntityEventTrigger(Trigger):
+    """Legacy single calendar entity event trigger."""
+
+    _options: dict[str, Any]
+
+    @classmethod
+    async def async_validate_complete_config(
+        cls, hass: HomeAssistant, complete_config: ConfigType
+    ) -> ConfigType:
+        """Validate complete config."""
+        complete_config = move_top_level_schema_fields_to_options(
+            complete_config, _SINGLE_ENTITY_EVENT_OPTIONS_SCHEMA
+        )
+        return await super().async_validate_complete_config(hass, complete_config)
+
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, _SINGLE_ENTITY_EVENT_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize trigger."""
+        super().__init__(hass, config)
+
+        if TYPE_CHECKING:
+            assert config.options is not None
+        self._options = config.options
+
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach a trigger."""
+
+        entity_id = self._options[CONF_ENTITY_ID]
+        event_type = self._options[CONF_EVENT]
+        offset = self._options[CONF_OFFSET]
+
+        # Validate the entity id is valid
+        get_entity(self._hass, entity_id)
+
+        trigger_data = {
+            "event": event_type,
+            "offset": offset,
+        }
+        listener = CalendarEventListener(
+            self._hass,
+            run_action,
+            trigger_data,
+            queued_event_fetcher(
+                event_fetcher(self._hass, {entity_id}), event_type, offset
+            ),
+        )
+        await listener.async_attach()
+        return listener.async_detach
+
+
+class EventTrigger(Trigger):
+    """Calendar event trigger."""
+
+    _options: dict[str, Any]
+    _event_type: str
+
+    @classmethod
+    async def async_validate_config(
+        cls, hass: HomeAssistant, config: ConfigType
+    ) -> ConfigType:
+        """Validate config."""
+        return cast(ConfigType, _EVENT_TRIGGER_SCHEMA(config))
+
+    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
+        """Initialize trigger."""
+        super().__init__(hass, config)
+
+        if TYPE_CHECKING:
+            assert config.target is not None
+            assert config.options is not None
+        self._target = config.target
+        self._options = config.options
+
+    async def async_attach_runner(
+        self, run_action: TriggerActionRunner
+    ) -> CALLBACK_TYPE:
+        """Attach a trigger."""
+
+        offset = self._options[CONF_OFFSET]
+        offset_type = self._options[CONF_OFFSET_TYPE]
+
+        if offset_type == OFFSET_TYPE_BEFORE:
+            offset = -offset
+
+        target_selection = TargetSelection(self._target)
+        if not target_selection.has_any_target:
+            raise HomeAssistantError(f"No target defined in {self._target}")
+        listener = TargetCalendarEventListener(
+            self._hass, target_selection, self._event_type, offset, run_action
+        )
+        return listener.async_setup()
+
+
+class EventStartedTrigger(EventTrigger):
+    """Calendar event started trigger."""
+
+    _event_type = EVENT_START
+
+
+class EventEndedTrigger(EventTrigger):
+    """Calendar event ended trigger."""
+
+    _event_type = EVENT_END
+
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "_": SingleEntityEventTrigger,
+    "event_started": EventStartedTrigger,
+    "event_ended": EventEndedTrigger,
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for calendars."""
+    return TRIGGERS

homeassistant/components/calendar/triggers.yaml

@@ -0,0 +1,27 @@
+.trigger_common: &trigger_common
+  target:
+    entity:
+      domain: calendar
+  fields:
+    offset:
+      required: true
+      default:
+        days: 0
+        hours: 0
+        minutes: 0
+        seconds: 0
+      selector:
+        duration:
+          enable_day: true
+    offset_type:
+      required: true
+      default: before
+      selector:
+        select:
+          translation_key: trigger_offset_type
+          options:
+            - before
+            - after
+
+event_started: *trigger_common
+event_ended: *trigger_common

homeassistant/components/cast/manifest.json

@@ -12,6 +12,7 @@
   "codeowners": ["@emontnemery"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/cast",
+  "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["casttube", "pychromecast"],
   "requirements": ["PyChromecast==14.0.9"],

homeassistant/components/cisco_webex_teams/notify.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import logging
+from typing import Any
 
 import voluptuous as vol
 from webexpythonsdk import ApiError, WebexAPI, exceptions
@@ -51,7 +52,7 @@ class CiscoWebexNotificationService(BaseNotificationService):
         self.room = room
         self.client = client
 
-    def send_message(self, message="", **kwargs):
+    def send_message(self, message: str = "", **kwargs: Any) -> None:
         """Send a message to a user."""
 
         title = ""

homeassistant/components/clicksend_tts/notify.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from http import HTTPStatus
 import json
 import logging
+from typing import Any
 
 import requests
 import voluptuous as vol
@@ -81,7 +82,7 @@ class ClicksendNotificationService(BaseNotificationService):
         self.language = config[CONF_LANGUAGE]
         self.voice = config[CONF_VOICE]
 
-    def send_message(self, message="", **kwargs):
+    def send_message(self, message: str = "", **kwargs: Any) -> None:
         """Send a voice call to a user."""
         data = {
             "messages": [