Use test helpers for acaia buttons (#130626 )

Add Python version to issue ID (#130611 )
Refactor translation checks (#130585 )
2024-11-14 16:34:17 +01:00 · 2024-11-14 16:31:33 +01:00 · 2024-11-14 16:26:05 +01:00 · 2024-11-14 16:17:08 +01:00 · 2024-11-14 15:38:38 +01:00 · 2024-11-14 15:27:10 +01:00
798 changed files with 23127 additions and 6546 deletions
--- a/.core_files.yaml
+++ b/.core_files.yaml
@ -79,6 +79,7 @@ components: &components
  - homeassistant/components/group/**
  - homeassistant/components/hassio/**
  - homeassistant/components/homeassistant/**
+  - homeassistant/components/homeassistant_hardware/**
  - homeassistant/components/http/**
  - homeassistant/components/image/**
  - homeassistant/components/input_boolean/**
--- a/.github/workflows/builder.yml
+++ b/.github/workflows/builder.yml
@ -10,7 +10,7 @@ on:

 env:
  BUILD_TYPE: core
-  DEFAULT_PYTHON: "3.12"
+  DEFAULT_PYTHON: "3.13"
  PIP_TIMEOUT: 60
  UV_HTTP_TIMEOUT: 60
  UV_SYSTEM_PYTHON: "true"
@ -531,7 +531,7 @@ jobs:

      - name: Generate artifact attestation
        if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
-        uses: actions/attest-build-provenance@1c608d11d69870c2092266b3f9a6f3abbf17002c # v1.4.3
+        uses: actions/attest-build-provenance@ef244123eb79f2f7a7e75d99086184180e6d0018 # v1.4.4
        with:
          subject-name: ${{ env.HASSFEST_IMAGE_NAME }}
          subject-digest: ${{ steps.push.outputs.digest }}
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@ -42,7 +42,7 @@ env:
  MYPY_CACHE_VERSION: 9
  HA_SHORT_VERSION: "2024.12"
  DEFAULT_PYTHON: "3.12"
-  ALL_PYTHON_VERSIONS: "['3.12']"
+  ALL_PYTHON_VERSIONS: "['3.12', '3.13']"
  # 10.3 is the oldest supported version
  # - 10.3.32 is the version currently shipped with Synology (as of 17 Feb 2022)
  # 10.6 is the current long-term-support
@ -622,13 +622,13 @@ jobs:
    steps:
      - name: Check out code from GitHub
        uses: actions/checkout@v4.2.2
-      - name: Set up Python ${{ env.DEFAULT_PYTHON }}
+      - name: Set up Python ${{ matrix.python-version }}
        id: python
        uses: actions/setup-python@v5.3.0
        with:
-          python-version: ${{ env.DEFAULT_PYTHON }}
+          python-version: ${{ matrix.python-version }}
          check-latest: true
-      - name: Restore full Python ${{ env.DEFAULT_PYTHON }} virtual environment
+      - name: Restore full Python ${{ matrix.python-version }} virtual environment
        id: cache-venv
        uses: actions/cache/restore@v4.1.2
        with:
@ -819,11 +819,7 @@ jobs:
    needs:
      - info
      - base
-    strategy:
-      fail-fast: false
-      matrix:
-        python-version: ${{ fromJson(needs.info.outputs.python_versions) }}
-    name: Split tests for full run Python ${{ matrix.python-version }}
+    name: Split tests for full run
    steps:
      - name: Install additional OS dependencies
        run: |
@ -836,11 +832,11 @@ jobs:
            libgammu-dev
      - name: Check out code from GitHub
        uses: actions/checkout@v4.2.2
-      - name: Set up Python ${{ matrix.python-version }}
+      - name: Set up Python ${{ env.DEFAULT_PYTHON }}
        id: python
        uses: actions/setup-python@v5.3.0
        with:
-          python-version: ${{ matrix.python-version }}
+          python-version: ${{ env.DEFAULT_PYTHON }}
          check-latest: true
      - name: Restore base Python virtual environment
        id: cache-venv
@ -858,7 +854,7 @@ jobs:
      - name: Upload pytest_buckets
        uses: actions/upload-artifact@v4.4.3
        with:
-          name: pytest_buckets-${{ matrix.python-version }}
+          name: pytest_buckets
          path: pytest_buckets.txt
          overwrite: true

@ -923,7 +919,7 @@ jobs:
      - name: Download pytest_buckets
        uses: actions/download-artifact@v4.1.8
        with:
-          name: pytest_buckets-${{ matrix.python-version }}
+          name: pytest_buckets
      - name: Compile English translations
        run: |
          . venv/bin/activate
@ -949,6 +945,7 @@ jobs:
            --timeout=9 \
            --durations=10 \
            --numprocesses auto \
+            --snapshot-details \
            --dist=loadfile \
            ${cov_params[@]} \
            -o console_output_style=count \
@ -1071,6 +1068,7 @@ jobs:
            -qq \
            --timeout=20 \
            --numprocesses 1 \
+            --snapshot-details \
            ${cov_params[@]} \
            -o console_output_style=count \
            --durations=10 \
@ -1199,6 +1197,7 @@ jobs:
            -qq \
            --timeout=9 \
            --numprocesses 1 \
+            --snapshot-details \
            ${cov_params[@]} \
            -o console_output_style=count \
            --durations=0 \
@ -1345,6 +1344,7 @@ jobs:
            -qq \
            --timeout=9 \
            --numprocesses auto \
+            --snapshot-details \
            ${cov_params[@]} \
            -o console_output_style=count \
            --durations=0 \
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@ -24,11 +24,11 @@ jobs:
        uses: actions/checkout@v4.2.2

      - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3.27.0
+        uses: github/codeql-action/init@v3.27.3
        with:
          languages: python

      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3.27.0
+        uses: github/codeql-action/analyze@v3.27.3
        with:
          category: "/language:python"
--- a/.github/workflows/wheels.yml
+++ b/.github/workflows/wheels.yml
@ -112,7 +112,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        abi: ["cp312"]
+        abi: ["cp312", "cp313"]
        arch: ${{ fromJson(needs.init.outputs.architectures) }}
    steps:
      - name: Checkout the repository
@ -135,14 +135,14 @@ jobs:
          sed -i "/uv/d" requirements_diff.txt

      - name: Build wheels
-        uses: home-assistant/wheels@2024.07.1
+        uses: home-assistant/wheels@2024.11.0
        with:
          abi: ${{ matrix.abi }}
          tag: musllinux_1_2
          arch: ${{ matrix.arch }}
          wheels-key: ${{ secrets.WHEELS_KEY }}
          env-file: true
-          apk: "libffi-dev;openssl-dev;yaml-dev;nasm"
+          apk: "libffi-dev;openssl-dev;yaml-dev;nasm;zlib-dev"
          skip-binary: aiohttp;multidict;yarl
          constraints: "homeassistant/package_constraints.txt"
          requirements-diff: "requirements_diff.txt"
@ -156,7 +156,7 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        abi: ["cp312"]
+        abi: ["cp312", "cp313"]
        arch: ${{ fromJson(needs.init.outputs.architectures) }}
    steps:
      - name: Checkout the repository
@ -198,6 +198,7 @@ jobs:
          split -l $(expr $(expr $(cat requirements_all.txt | wc -l) + 1) / 3) requirements_all_wheels_${{ matrix.arch }}.txt requirements_all.txt

      - name: Create requirements for cython<3
+        if: matrix.abi == 'cp312'
        run: |
          # Some dependencies still require 'cython<3'
          # and don't yet use isolated build environments.
@ -208,7 +209,8 @@ jobs:
          cat homeassistant/package_constraints.txt | grep 'pydantic==' >> requirements_old-cython.txt

      - name: Build wheels (old cython)
-        uses: home-assistant/wheels@2024.07.1
+        uses: home-assistant/wheels@2024.11.0
+        if: matrix.abi == 'cp312'
        with:
          abi: ${{ matrix.abi }}
          tag: musllinux_1_2
@ -223,43 +225,43 @@ jobs:
          pip: "'cython<3'"

      - name: Build wheels (part 1)
-        uses: home-assistant/wheels@2024.07.1
+        uses: home-assistant/wheels@2024.11.0
        with:
          abi: ${{ matrix.abi }}
          tag: musllinux_1_2
          arch: ${{ matrix.arch }}
          wheels-key: ${{ secrets.WHEELS_KEY }}
          env-file: true
-          apk: "bluez-dev;libffi-dev;openssl-dev;glib-dev;eudev-dev;libxml2-dev;libxslt-dev;libpng-dev;libjpeg-turbo-dev;tiff-dev;cups-dev;gmp-dev;mpfr-dev;mpc1-dev;ffmpeg-dev;gammu-dev;yaml-dev;openblas-dev;fftw-dev;lapack-dev;gfortran;blas-dev;eigen-dev;freetype-dev;glew-dev;harfbuzz-dev;hdf5-dev;libdc1394-dev;libtbb-dev;mesa-dev;openexr-dev;openjpeg-dev;uchardet-dev;nasm"
-          skip-binary: aiohttp;charset-normalizer;grpcio;multidict;SQLAlchemy;propcache;protobuf;pydantic;pymicro-vad;yarl
+          apk: "bluez-dev;libffi-dev;openssl-dev;glib-dev;eudev-dev;libxml2-dev;libxslt-dev;libpng-dev;libjpeg-turbo-dev;tiff-dev;cups-dev;gmp-dev;mpfr-dev;mpc1-dev;ffmpeg-dev;gammu-dev;yaml-dev;openblas-dev;fftw-dev;lapack-dev;gfortran;blas-dev;eigen-dev;freetype-dev;glew-dev;harfbuzz-dev;hdf5-dev;libdc1394-dev;libtbb-dev;mesa-dev;openexr-dev;openjpeg-dev;uchardet-dev;nasm;zlib-dev"
+          skip-binary: aiohttp;charset-normalizer;grpcio;multidict;SQLAlchemy;propcache;protobuf;pymicro-vad;yarl
          constraints: "homeassistant/package_constraints.txt"
          requirements-diff: "requirements_diff.txt"
          requirements: "requirements_all.txtaa"

      - name: Build wheels (part 2)
-        uses: home-assistant/wheels@2024.07.1
+        uses: home-assistant/wheels@2024.11.0
        with:
          abi: ${{ matrix.abi }}
          tag: musllinux_1_2
          arch: ${{ matrix.arch }}
          wheels-key: ${{ secrets.WHEELS_KEY }}
          env-file: true
-          apk: "bluez-dev;libffi-dev;openssl-dev;glib-dev;eudev-dev;libxml2-dev;libxslt-dev;libpng-dev;libjpeg-turbo-dev;tiff-dev;cups-dev;gmp-dev;mpfr-dev;mpc1-dev;ffmpeg-dev;gammu-dev;yaml-dev;openblas-dev;fftw-dev;lapack-dev;gfortran;blas-dev;eigen-dev;freetype-dev;glew-dev;harfbuzz-dev;hdf5-dev;libdc1394-dev;libtbb-dev;mesa-dev;openexr-dev;openjpeg-dev;uchardet-dev;nasm"
-          skip-binary: aiohttp;charset-normalizer;grpcio;multidict;SQLAlchemy;propcache;protobuf;pydantic;pymicro-vad;yarl
+          apk: "bluez-dev;libffi-dev;openssl-dev;glib-dev;eudev-dev;libxml2-dev;libxslt-dev;libpng-dev;libjpeg-turbo-dev;tiff-dev;cups-dev;gmp-dev;mpfr-dev;mpc1-dev;ffmpeg-dev;gammu-dev;yaml-dev;openblas-dev;fftw-dev;lapack-dev;gfortran;blas-dev;eigen-dev;freetype-dev;glew-dev;harfbuzz-dev;hdf5-dev;libdc1394-dev;libtbb-dev;mesa-dev;openexr-dev;openjpeg-dev;uchardet-dev;nasm;zlib-dev"
+          skip-binary: aiohttp;charset-normalizer;grpcio;multidict;SQLAlchemy;propcache;protobuf;pymicro-vad;yarl
          constraints: "homeassistant/package_constraints.txt"
          requirements-diff: "requirements_diff.txt"
          requirements: "requirements_all.txtab"

      - name: Build wheels (part 3)
-        uses: home-assistant/wheels@2024.07.1
+        uses: home-assistant/wheels@2024.11.0
        with:
          abi: ${{ matrix.abi }}
          tag: musllinux_1_2
          arch: ${{ matrix.arch }}
          wheels-key: ${{ secrets.WHEELS_KEY }}
          env-file: true
-          apk: "bluez-dev;libffi-dev;openssl-dev;glib-dev;eudev-dev;libxml2-dev;libxslt-dev;libpng-dev;libjpeg-turbo-dev;tiff-dev;cups-dev;gmp-dev;mpfr-dev;mpc1-dev;ffmpeg-dev;gammu-dev;yaml-dev;openblas-dev;fftw-dev;lapack-dev;gfortran;blas-dev;eigen-dev;freetype-dev;glew-dev;harfbuzz-dev;hdf5-dev;libdc1394-dev;libtbb-dev;mesa-dev;openexr-dev;openjpeg-dev;uchardet-dev;nasm"
-          skip-binary: aiohttp;charset-normalizer;grpcio;multidict;SQLAlchemy;propcache;protobuf;pydantic;pymicro-vad;yarl
+          apk: "bluez-dev;libffi-dev;openssl-dev;glib-dev;eudev-dev;libxml2-dev;libxslt-dev;libpng-dev;libjpeg-turbo-dev;tiff-dev;cups-dev;gmp-dev;mpfr-dev;mpc1-dev;ffmpeg-dev;gammu-dev;yaml-dev;openblas-dev;fftw-dev;lapack-dev;gfortran;blas-dev;eigen-dev;freetype-dev;glew-dev;harfbuzz-dev;hdf5-dev;libdc1394-dev;libtbb-dev;mesa-dev;openexr-dev;openjpeg-dev;uchardet-dev;nasm;zlib-dev"
+          skip-binary: aiohttp;charset-normalizer;grpcio;multidict;SQLAlchemy;propcache;protobuf;pymicro-vad;yarl
          constraints: "homeassistant/package_constraints.txt"
          requirements-diff: "requirements_diff.txt"
          requirements: "requirements_all.txtac"
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@ -1,6 +1,6 @@
 repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.7.2
+    rev: v0.7.3
    hooks:
      - id: ruff
        args:
@ -90,7 +90,7 @@ repos:
        pass_filenames: false
        language: script
        types: [text]
-        files: ^(script/hassfest/metadata\.py|homeassistant/const\.py$|pyproject\.toml)$
+        files: ^(script/hassfest/metadata\.py|homeassistant/const\.py$|pyproject\.toml|homeassistant/components/go2rtc/const\.py)$
      - id: hassfest-mypy-config
        name: hassfest-mypy-config
        entry: script/run-in-env.sh python3 -m script.hassfest -p mypy_config
--- a/.strict-typing
+++ b/.strict-typing
@ -330,6 +330,7 @@ homeassistant.components.mysensors.*
 homeassistant.components.myuplink.*
 homeassistant.components.nam.*
 homeassistant.components.nanoleaf.*
+homeassistant.components.nasweb.*
 homeassistant.components.neato.*
 homeassistant.components.nest.*
 homeassistant.components.netatmo.*
@ -339,6 +340,7 @@ homeassistant.components.nfandroidtv.*
 homeassistant.components.nightscout.*
 homeassistant.components.nissan_leaf.*
 homeassistant.components.no_ip.*
+homeassistant.components.nordpool.*
 homeassistant.components.notify.*
 homeassistant.components.notion.*
 homeassistant.components.number.*
--- a/16
+++ b/16
@ -40,6 +40,8 @@ build.json @home-assistant/supervisor
 # Integrations
 /homeassistant/components/abode/ @shred86
 /tests/components/abode/ @shred86
+/homeassistant/components/acaia/ @zweckj
+/tests/components/acaia/ @zweckj
 /homeassistant/components/accuweather/ @bieniu
 /tests/components/accuweather/ @bieniu
 /homeassistant/components/acmeda/ @atmurray
@ -496,8 +498,8 @@ build.json @home-assistant/supervisor
 /tests/components/freebox/ @hacf-fr @Quentame
 /homeassistant/components/freedompro/ @stefano055415
 /tests/components/freedompro/ @stefano055415
-/homeassistant/components/fritz/ @mammuth @AaronDavidSchneider @chemelli74 @mib1185
-/tests/components/fritz/ @mammuth @AaronDavidSchneider @chemelli74 @mib1185
+/homeassistant/components/fritz/ @AaronDavidSchneider @chemelli74 @mib1185
+/tests/components/fritz/ @AaronDavidSchneider @chemelli74 @mib1185
 /homeassistant/components/fritzbox/ @mib1185 @flabbamann
 /tests/components/fritzbox/ @mib1185 @flabbamann
 /homeassistant/components/fritzbox_callmonitor/ @cdce8p
@ -970,6 +972,8 @@ build.json @home-assistant/supervisor
 /tests/components/nam/ @bieniu
 /homeassistant/components/nanoleaf/ @milanmeu @joostlek
 /tests/components/nanoleaf/ @milanmeu @joostlek
+/homeassistant/components/nasweb/ @nasWebio
+/tests/components/nasweb/ @nasWebio
 /homeassistant/components/neato/ @Santobert
 /tests/components/neato/ @Santobert
 /homeassistant/components/nederlandse_spoorwegen/ @YarmoM
@ -1010,6 +1014,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/noaa_tides/ @jdelaney72
 /homeassistant/components/nobo_hub/ @echoromeo @oyvindwe
 /tests/components/nobo_hub/ @echoromeo @oyvindwe
+/homeassistant/components/nordpool/ @gjohansson-ST
+/tests/components/nordpool/ @gjohansson-ST
 /homeassistant/components/notify/ @home-assistant/core
 /tests/components/notify/ @home-assistant/core
 /homeassistant/components/notify_events/ @matrozov @papajojo
@ -1340,6 +1346,8 @@ build.json @home-assistant/supervisor
 /tests/components/siren/ @home-assistant/core @raman325
 /homeassistant/components/sisyphus/ @jkeljo
 /homeassistant/components/sky_hub/ @rogerselwyn
+/homeassistant/components/sky_remote/ @dunnmj @saty9
+/tests/components/sky_remote/ @dunnmj @saty9
 /homeassistant/components/skybell/ @tkdrob
 /tests/components/skybell/ @tkdrob
 /homeassistant/components/slack/ @tkdrob @fletcherau
@ -1481,8 +1489,8 @@ build.json @home-assistant/supervisor
 /tests/components/tedee/ @patrickhilker @zweckj
 /homeassistant/components/tellduslive/ @fredrike
 /tests/components/tellduslive/ @fredrike
-/homeassistant/components/template/ @PhracturedBlue @tetienne @home-assistant/core
-/tests/components/template/ @PhracturedBlue @tetienne @home-assistant/core
+/homeassistant/components/template/ @PhracturedBlue @home-assistant/core
+/tests/components/template/ @PhracturedBlue @home-assistant/core
 /homeassistant/components/tesla_fleet/ @Bre77
 /tests/components/tesla_fleet/ @Bre77
 /homeassistant/components/tesla_wall_connector/ @einarhauks
--- a/7
+++ b/7
@ -7,12 +7,13 @@ FROM ${BUILD_FROM}
 # Synchronize with homeassistant/core.py:async_stop
 ENV \
    S6_SERVICES_GRACETIME=240000 \
-    UV_SYSTEM_PYTHON=true
+    UV_SYSTEM_PYTHON=true \
+    UV_NO_CACHE=true

 ARG QEMU_CPU

 # Install uv
-RUN pip3 install uv==0.4.28
+RUN pip3 install uv==0.5.0

 WORKDIR /usr/src

@ -54,7 +55,7 @@ RUN \
        "armv7") go2rtc_suffix='arm' ;; \
        *) go2rtc_suffix=${BUILD_ARCH} ;; \
    esac \
-    && curl -L https://github.com/AlexxIT/go2rtc/releases/download/v1.9.6/go2rtc_linux_${go2rtc_suffix} --output /bin/go2rtc \
+    && curl -L https://github.com/AlexxIT/go2rtc/releases/download/v1.9.7/go2rtc_linux_${go2rtc_suffix} --output /bin/go2rtc \
    && chmod +x /bin/go2rtc \
    # Verify go2rtc can be executed
    && go2rtc --version
--- a/Dockerfile.dev
+++ b/Dockerfile.dev
@ -35,6 +35,9 @@ RUN \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

+# Add go2rtc binary
+COPY --from=ghcr.io/alexxit/go2rtc:latest /usr/local/bin/go2rtc /bin/go2rtc
+
 # Install uv
 RUN pip3 install uv

--- a/build.yaml
+++ b/build.yaml
@ -1,10 +1,10 @@
 image: ghcr.io/home-assistant/{arch}-homeassistant
 build_from:
-  aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2024.06.1
-  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2024.06.1
-  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2024.06.1
-  amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2024.06.1
-  i386: ghcr.io/home-assistant/i386-homeassistant-base:2024.06.1
+  aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2024.11.0
+  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2024.11.0
+  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2024.11.0
+  amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2024.11.0
+  i386: ghcr.io/home-assistant/i386-homeassistant-base:2024.11.0
 codenotary:
  signer: notary@home-assistant.io
  base_image: notary@home-assistant.io
--- a/homeassistant/backup_restore.py
+++ b/homeassistant/backup_restore.py
@ -30,11 +30,11 @@ def restore_backup_file_content(config_dir: Path) -> RestoreBackupFileContent |
    """Return the contents of the restore backup file."""
    instruction_path = config_dir.joinpath(RESTORE_BACKUP_FILE)
    try:
-        instruction_content = instruction_path.read_text(encoding="utf-8")
+        instruction_content = json.loads(instruction_path.read_text(encoding="utf-8"))
        return RestoreBackupFileContent(
-            backup_file_path=Path(instruction_content.split(";")[0])
+            backup_file_path=Path(instruction_content["path"])
        )
-    except FileNotFoundError:
+    except (FileNotFoundError, json.JSONDecodeError):
        return None


--- a/homeassistant/bootstrap.py
+++ b/homeassistant/bootstrap.py
@ -515,7 +515,7 @@ async def async_from_config_dict(
        issue_registry.async_create_issue(
            hass,
            core.DOMAIN,
-            "python_version",
+            f"python_version_{required_python_version}",
            is_fixable=False,
            severity=issue_registry.IssueSeverity.WARNING,
            breaks_in_ha_version=REQUIRED_NEXT_PYTHON_HA_RELEASE,
--- a/homeassistant/brands/sky.json
+++ b/homeassistant/brands/sky.json
@ -0,0 +1,5 @@
+{
+  "domain": "sky",
+  "name": "Sky",
+  "integrations": ["sky_hub", "sky_remote"]
+}
--- a/homeassistant/components/acaia/init.py
+++ b/homeassistant/components/acaia/init.py
@ -0,0 +1,29 @@
+"""Initialize the Acaia component."""
+
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+
+from .coordinator import AcaiaConfigEntry, AcaiaCoordinator
+
+PLATFORMS = [
+    Platform.BUTTON,
+]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: AcaiaConfigEntry) -> bool:
+    """Set up acaia as config entry."""
+
+    coordinator = AcaiaCoordinator(hass, entry)
+    await coordinator.async_config_entry_first_refresh()
+
+    entry.runtime_data = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: AcaiaConfigEntry) -> bool:
+    """Unload a config entry."""
+
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
--- a/homeassistant/components/acaia/button.py
+++ b/homeassistant/components/acaia/button.py
@ -0,0 +1,61 @@
+"""Button entities for Acaia scales."""
+
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass
+from typing import Any
+
+from aioacaia.acaiascale import AcaiaScale
+
+from homeassistant.components.button import ButtonEntity, ButtonEntityDescription
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+
+from .coordinator import AcaiaConfigEntry
+from .entity import AcaiaEntity
+
+
+@dataclass(kw_only=True, frozen=True)
+class AcaiaButtonEntityDescription(ButtonEntityDescription):
+    """Description for acaia button entities."""
+
+    press_fn: Callable[[AcaiaScale], Coroutine[Any, Any, None]]
+
+
+BUTTONS: tuple[AcaiaButtonEntityDescription, ...] = (
+    AcaiaButtonEntityDescription(
+        key="tare",
+        translation_key="tare",
+        press_fn=lambda scale: scale.tare(),
+    ),
+    AcaiaButtonEntityDescription(
+        key="reset_timer",
+        translation_key="reset_timer",
+        press_fn=lambda scale: scale.reset_timer(),
+    ),
+    AcaiaButtonEntityDescription(
+        key="start_stop",
+        translation_key="start_stop",
+        press_fn=lambda scale: scale.start_stop_timer(),
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: AcaiaConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
+    """Set up button entities and services."""
+
+    coordinator = entry.runtime_data
+    async_add_entities(AcaiaButton(coordinator, description) for description in BUTTONS)
+
+
+class AcaiaButton(AcaiaEntity, ButtonEntity):
+    """Representation of an Acaia button."""
+
+    entity_description: AcaiaButtonEntityDescription
+
+    async def async_press(self) -> None:
+        """Handle the button press."""
+        await self.entity_description.press_fn(self._scale)
--- a/homeassistant/components/acaia/config_flow.py
+++ b/homeassistant/components/acaia/config_flow.py
@ -0,0 +1,149 @@
+"""Config flow for Acaia integration."""
+
+import logging
+from typing import Any
+
+from aioacaia.exceptions import AcaiaDeviceNotFound, AcaiaError, AcaiaUnknownDevice
+from aioacaia.helpers import is_new_scale
+import voluptuous as vol
+
+from homeassistant.components.bluetooth import (
+    BluetoothServiceInfoBleak,
+    async_discovered_service_info,
+)
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_ADDRESS, CONF_NAME
+from homeassistant.helpers.device_registry import format_mac
+from homeassistant.helpers.selector import (
+    SelectOptionDict,
+    SelectSelector,
+    SelectSelectorConfig,
+    SelectSelectorMode,
+)
+
+from .const import CONF_IS_NEW_STYLE_SCALE, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class AcaiaConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for acaia."""
+
+    def __init__(self) -> None:
+        """Initialize the config flow."""
+        self._discovered: dict[str, Any] = {}
+        self._discovered_devices: dict[str, str] = {}
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle a flow initialized by the user."""
+
+        errors: dict[str, str] = {}
+
+        if user_input is not None:
+            mac = format_mac(user_input[CONF_ADDRESS])
+            try:
+                is_new_style_scale = await is_new_scale(mac)
+            except AcaiaDeviceNotFound:
+                errors["base"] = "device_not_found"
+            except AcaiaError:
+                _LOGGER.exception("Error occurred while connecting to the scale")
+                errors["base"] = "unknown"
+            except AcaiaUnknownDevice:
+                return self.async_abort(reason="unsupported_device")
+            else:
+                await self.async_set_unique_id(mac)
+                self._abort_if_unique_id_configured()
+
+            if not errors:
+                return self.async_create_entry(
+                    title=self._discovered_devices[user_input[CONF_ADDRESS]],
+                    data={
+                        CONF_ADDRESS: mac,
+                        CONF_IS_NEW_STYLE_SCALE: is_new_style_scale,
+                    },
+                )
+
+        for device in async_discovered_service_info(self.hass):
+            self._discovered_devices[device.address] = device.name
+
+        if not self._discovered_devices:
+            return self.async_abort(reason="no_devices_found")
+
+        options = [
+            SelectOptionDict(
+                value=device_mac,
+                label=f"{device_name} ({device_mac})",
+            )
+            for device_mac, device_name in self._discovered_devices.items()
+        ]
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_ADDRESS): SelectSelector(
+                        SelectSelectorConfig(
+                            options=options,
+                            mode=SelectSelectorMode.DROPDOWN,
+                        )
+                    )
+                }
+            ),
+            errors=errors,
+        )
+
+    async def async_step_bluetooth(
+        self, discovery_info: BluetoothServiceInfoBleak
+    ) -> ConfigFlowResult:
+        """Handle a discovered Bluetooth device."""
+
+        self._discovered[CONF_ADDRESS] = mac = format_mac(discovery_info.address)
+        self._discovered[CONF_NAME] = discovery_info.name
+
+        await self.async_set_unique_id(mac)
+        self._abort_if_unique_id_configured()
+
+        try:
+            self._discovered[CONF_IS_NEW_STYLE_SCALE] = await is_new_scale(
+                discovery_info.address
+            )
+        except AcaiaDeviceNotFound:
+            _LOGGER.debug("Device not found during discovery")
+            return self.async_abort(reason="device_not_found")
+        except AcaiaError:
+            _LOGGER.debug(
+                "Error occurred while connecting to the scale during discovery",
+                exc_info=True,
+            )
+            return self.async_abort(reason="unknown")
+        except AcaiaUnknownDevice:
+            _LOGGER.debug("Unsupported device during discovery")
+            return self.async_abort(reason="unsupported_device")
+
+        return await self.async_step_bluetooth_confirm()
+
+    async def async_step_bluetooth_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle confirmation of Bluetooth discovery."""
+
+        if user_input is not None:
+            return self.async_create_entry(
+                title=self._discovered[CONF_NAME],
+                data={
+                    CONF_ADDRESS: self._discovered[CONF_ADDRESS],
+                    CONF_IS_NEW_STYLE_SCALE: self._discovered[CONF_IS_NEW_STYLE_SCALE],
+                },
+            )
+
+        self.context["title_placeholders"] = placeholders = {
+            CONF_NAME: self._discovered[CONF_NAME]
+        }
+
+        self._set_confirm_only()
+        return self.async_show_form(
+            step_id="bluetooth_confirm",
+            description_placeholders=placeholders,
+        )
--- a/homeassistant/components/acaia/const.py
+++ b/homeassistant/components/acaia/const.py
@ -0,0 +1,4 @@
+"""Constants for component."""
+
+DOMAIN = "acaia"
+CONF_IS_NEW_STYLE_SCALE = "is_new_style_scale"
--- a/homeassistant/components/acaia/coordinator.py
+++ b/homeassistant/components/acaia/coordinator.py
@ -0,0 +1,86 @@
+"""Coordinator for Acaia integration."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+import logging
+
+from aioacaia.acaiascale import AcaiaScale
+from aioacaia.exceptions import AcaiaDeviceNotFound, AcaiaError
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_ADDRESS
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+
+from .const import CONF_IS_NEW_STYLE_SCALE
+
+SCAN_INTERVAL = timedelta(seconds=15)
+
+_LOGGER = logging.getLogger(__name__)
+
+type AcaiaConfigEntry = ConfigEntry[AcaiaCoordinator]
+
+
+class AcaiaCoordinator(DataUpdateCoordinator[None]):
+    """Class to handle fetching data from the scale."""
+
+    config_entry: AcaiaConfigEntry
+
+    def __init__(self, hass: HomeAssistant, entry: AcaiaConfigEntry) -> None:
+        """Initialize coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            name="acaia coordinator",
+            update_interval=SCAN_INTERVAL,
+            config_entry=entry,
+        )
+
+        self._scale = AcaiaScale(
+            address_or_ble_device=entry.data[CONF_ADDRESS],
+            name=entry.title,
+            is_new_style_scale=entry.data[CONF_IS_NEW_STYLE_SCALE],
+            notify_callback=self.async_update_listeners,
+        )
+
+    @property
+    def scale(self) -> AcaiaScale:
+        """Return the scale object."""
+        return self._scale
+
+    async def _async_update_data(self) -> None:
+        """Fetch data."""
+
+        # scale is already connected, return
+        if self._scale.connected:
+            return
+
+        # scale is not connected, try to connect
+        try:
+            await self._scale.connect(setup_tasks=False)
+        except (AcaiaDeviceNotFound, AcaiaError, TimeoutError) as ex:
+            _LOGGER.debug(
+                "Could not connect to scale: %s, Error: %s",
+                self.config_entry.data[CONF_ADDRESS],
+                ex,
+            )
+            self._scale.device_disconnected_handler(notify=False)
+            return
+
+        # connected, set up background tasks
+        if not self._scale.heartbeat_task or self._scale.heartbeat_task.done():
+            self._scale.heartbeat_task = self.config_entry.async_create_background_task(
+                hass=self.hass,
+                target=self._scale.send_heartbeats(),
+                name="acaia_heartbeat_task",
+            )
+
+        if not self._scale.process_queue_task or self._scale.process_queue_task.done():
+            self._scale.process_queue_task = (
+                self.config_entry.async_create_background_task(
+                    hass=self.hass,
+                    target=self._scale.process_queue(),
+                    name="acaia_process_queue_task",
+                )
+            )
--- a/homeassistant/components/acaia/entity.py
+++ b/homeassistant/components/acaia/entity.py
@ -0,0 +1,40 @@
+"""Base class for Acaia entities."""
+
+from dataclasses import dataclass
+
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity import EntityDescription
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import AcaiaCoordinator
+
+
+@dataclass
+class AcaiaEntity(CoordinatorEntity[AcaiaCoordinator]):
+    """Common elements for all entities."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: AcaiaCoordinator,
+        entity_description: EntityDescription,
+    ) -> None:
+        """Initialize the entity."""
+        super().__init__(coordinator)
+        self.entity_description = entity_description
+        self._scale = coordinator.scale
+        self._attr_unique_id = f"{self._scale.mac}_{entity_description.key}"
+
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, self._scale.mac)},
+            manufacturer="Acaia",
+            model=self._scale.model,
+            suggested_area="Kitchen",
+        )
+
+    @property
+    def available(self) -> bool:
+        """Returns whether entity is available."""
+        return super().available and self._scale.connected
--- a/homeassistant/components/acaia/icons.json
+++ b/homeassistant/components/acaia/icons.json
@ -0,0 +1,15 @@
+{
+  "entity": {
+    "button": {
+      "tare": {
+        "default": "mdi:scale-balance"
+      },
+      "reset_timer": {
+        "default": "mdi:timer-refresh"
+      },
+      "start_stop": {
+        "default": "mdi:timer-play"
+      }
+    }
+  }
+}
--- a/homeassistant/components/acaia/manifest.json
+++ b/homeassistant/components/acaia/manifest.json
@ -0,0 +1,29 @@
+{
+  "domain": "acaia",
+  "name": "Acaia",
+  "bluetooth": [
+    {
+      "manufacturer_id": 16962
+    },
+    {
+      "local_name": "ACAIA*"
+    },
+    {
+      "local_name": "PYXIS-*"
+    },
+    {
+      "local_name": "LUNAR-*"
+    },
+    {
+      "local_name": "PROCHBT001"
+    }
+  ],
+  "codeowners": ["@zweckj"],
+  "config_flow": true,
+  "dependencies": ["bluetooth_adapters"],
+  "documentation": "https://www.home-assistant.io/integrations/acaia",
+  "integration_type": "device",
+  "iot_class": "local_push",
+  "loggers": ["aioacaia"],
+  "requirements": ["aioacaia==0.1.6"]
+}
--- a/homeassistant/components/acaia/strings.json
+++ b/homeassistant/components/acaia/strings.json
@ -0,0 +1,38 @@
+{
+  "config": {
+    "flow_title": "{name}",
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "no_devices_found": "[%key:common::config_flow::abort::no_devices_found%]",
+      "unsupported_device": "This device is not supported."
+    },
+    "error": {
+      "device_not_found": "Device could not be found.",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "step": {
+      "bluetooth_confirm": {
+        "description": "[%key:component::bluetooth::config::step::bluetooth_confirm::description%]"
+      },
+      "user": {
+        "description": "[%key:component::bluetooth::config::step::user::description%]",
+        "data": {
+          "address": "[%key:common::config_flow::data::device%]"
+        }
+      }
+    }
+  },
+  "entity": {
+    "button": {
+      "tare": {
+        "name": "Tare"
+      },
+      "reset_timer": {
+        "name": "Reset timer"
+      },
+      "start_stop": {
+        "name": "Start/stop timer"
+      }
+    }
+  }
+}
--- a/homeassistant/components/aemet/init.py
+++ b/homeassistant/components/aemet/init.py
@ -1,6 +1,5 @@
 """The AEMET OpenData component."""

-from dataclasses import dataclass
 import logging

 from aemet_opendata.exceptions import AemetError, TownNotFound
@ -13,20 +12,10 @@ from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import aiohttp_client

 from .const import CONF_STATION_UPDATES, PLATFORMS
-from .coordinator import WeatherUpdateCoordinator
+from .coordinator import AemetConfigEntry, AemetData, WeatherUpdateCoordinator

 _LOGGER = logging.getLogger(__name__)

-type AemetConfigEntry = ConfigEntry[AemetData]
-
-
-@dataclass
-class AemetData:
-    """Aemet runtime data."""
-
-    name: str
-    coordinator: WeatherUpdateCoordinator
-

 async def async_setup_entry(hass: HomeAssistant, entry: AemetConfigEntry) -> bool:
    """Set up AEMET OpenData as config entry."""
@ -46,7 +35,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: AemetConfigEntry) -> boo
    except AemetError as err:
        raise ConfigEntryNotReady(err) from err

-    weather_coordinator = WeatherUpdateCoordinator(hass, aemet)
+    weather_coordinator = WeatherUpdateCoordinator(hass, entry, aemet)
    await weather_coordinator.async_config_entry_first_refresh()

    entry.runtime_data = AemetData(name=name, coordinator=weather_coordinator)
--- a/homeassistant/components/aemet/coordinator.py
+++ b/homeassistant/components/aemet/coordinator.py
@ -3,6 +3,7 @@
 from __future__ import annotations

 from asyncio import timeout
+from dataclasses import dataclass
 from datetime import timedelta
 import logging
 from typing import Any, Final, cast
@ -19,6 +20,7 @@ from aemet_opendata.helpers import dict_nested_value
 from aemet_opendata.interface import AEMET

 from homeassistant.components.weather import Forecast
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed

@ -29,6 +31,16 @@ _LOGGER = logging.getLogger(__name__)
 API_TIMEOUT: Final[int] = 120
 WEATHER_UPDATE_INTERVAL = timedelta(minutes=10)

+type AemetConfigEntry = ConfigEntry[AemetData]
+
+
+@dataclass
+class AemetData:
+    """Aemet runtime data."""
+
+    name: str
+    coordinator: WeatherUpdateCoordinator
+

 class WeatherUpdateCoordinator(DataUpdateCoordinator):
    """Weather data update coordinator."""
@ -36,6 +48,7 @@ class WeatherUpdateCoordinator(DataUpdateCoordinator):
    def __init__(
        self,
        hass: HomeAssistant,
+        entry: AemetConfigEntry,
        aemet: AEMET,
    ) -> None:
        """Initialize coordinator."""
@ -44,6 +57,7 @@ class WeatherUpdateCoordinator(DataUpdateCoordinator):
        super().__init__(
            hass,
            _LOGGER,
+            config_entry=entry,
            name=DOMAIN,
            update_interval=WEATHER_UPDATE_INTERVAL,
        )
--- a/homeassistant/components/aemet/diagnostics.py
+++ b/homeassistant/components/aemet/diagnostics.py
@ -15,7 +15,7 @@ from homeassistant.const import (
 )
 from homeassistant.core import HomeAssistant

-from . import AemetConfigEntry
+from .coordinator import AemetConfigEntry

 TO_REDACT_CONFIG = [
    CONF_API_KEY,
--- a/homeassistant/components/aemet/sensor.py
+++ b/homeassistant/components/aemet/sensor.py
@ -55,7 +55,6 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.util import dt as dt_util

-from . import AemetConfigEntry
 from .const import (
    ATTR_API_CONDITION,
    ATTR_API_FORECAST_CONDITION,
@ -87,7 +86,7 @@ from .const import (
    ATTR_API_WIND_SPEED,
    CONDITIONS_MAP,
 )
-from .coordinator import WeatherUpdateCoordinator
+from .coordinator import AemetConfigEntry, WeatherUpdateCoordinator
 from .entity import AemetEntity


@ -249,6 +248,7 @@ WEATHER_SENSORS: Final[tuple[AemetSensorEntityDescription, ...]] = (
        name="Rain",
        native_unit_of_measurement=UnitOfVolumetricFlux.MILLIMETERS_PER_HOUR,
        device_class=SensorDeviceClass.PRECIPITATION_INTENSITY,
+        state_class=SensorStateClass.MEASUREMENT,
    ),
    AemetSensorEntityDescription(
        key=ATTR_API_RAIN_PROB,
@ -263,6 +263,7 @@ WEATHER_SENSORS: Final[tuple[AemetSensorEntityDescription, ...]] = (
        name="Snow",
        native_unit_of_measurement=UnitOfVolumetricFlux.MILLIMETERS_PER_HOUR,
        device_class=SensorDeviceClass.PRECIPITATION_INTENSITY,
+        state_class=SensorStateClass.MEASUREMENT,
    ),
    AemetSensorEntityDescription(
        key=ATTR_API_SNOW_PROB,
--- a/homeassistant/components/aemet/weather.py
+++ b/homeassistant/components/aemet/weather.py
@ -27,9 +27,8 @@ from homeassistant.const import (
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddEntitiesCallback

-from . import AemetConfigEntry
 from .const import CONDITIONS_MAP
-from .coordinator import WeatherUpdateCoordinator
+from .coordinator import AemetConfigEntry, WeatherUpdateCoordinator
 from .entity import AemetEntity


--- a/homeassistant/components/agent_dvr/manifest.json
+++ b/homeassistant/components/agent_dvr/manifest.json
@ -6,5 +6,5 @@
  "documentation": "https://www.home-assistant.io/integrations/agent_dvr",
  "iot_class": "local_polling",
  "loggers": ["agent"],
-  "requirements": ["agent-py==0.0.23"]
+  "requirements": ["agent-py==0.0.24"]
 }
--- a/homeassistant/components/airthings_ble/manifest.json
+++ b/homeassistant/components/airthings_ble/manifest.json
@ -24,5 +24,5 @@
  "dependencies": ["bluetooth_adapters"],
  "documentation": "https://www.home-assistant.io/integrations/airthings_ble",
  "iot_class": "local_polling",
-  "requirements": ["airthings-ble==0.9.1"]
+  "requirements": ["airthings-ble==0.9.2"]
 }
--- a/homeassistant/components/airzone/manifest.json
+++ b/homeassistant/components/airzone/manifest.json
@ -11,5 +11,5 @@
  "documentation": "https://www.home-assistant.io/integrations/airzone",
  "iot_class": "local_polling",
  "loggers": ["aioairzone"],
-  "requirements": ["aioairzone==0.9.5"]
+  "requirements": ["aioairzone==0.9.6"]
 }
--- a/homeassistant/components/alarm_control_panel/init.py
+++ b/homeassistant/components/alarm_control_panel/init.py
@ -6,7 +6,7 @@ import asyncio
 from datetime import timedelta
 from functools import partial
 import logging
-from typing import Any, Final, final
+from typing import TYPE_CHECKING, Any, Final, final

 from propcache import cached_property
 import voluptuous as vol
@ -221,9 +221,15 @@ class AlarmControlPanelEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_A
    @property
    def state(self) -> str | None:
        """Return the current state."""
-        if (alarm_state := self.alarm_state) is None:
-            return None
+        if (alarm_state := self.alarm_state) is not None:
            return alarm_state
+        if self._attr_state is not None:
+            # Backwards compatibility for integrations that set state directly
+            # Should be removed in 2025.11
+            if TYPE_CHECKING:
+                assert isinstance(self._attr_state, str)
+            return self._attr_state
+        return None

    @cached_property
    def alarm_state(self) -> AlarmControlPanelState | None:
--- a/homeassistant/components/alexa/handlers.py
+++ b/homeassistant/components/alexa/handlers.py
@ -1083,7 +1083,13 @@ async def async_api_arm(
    arm_state = directive.payload["armState"]
    data: dict[str, Any] = {ATTR_ENTITY_ID: entity.entity_id}

-    if entity.state != alarm_control_panel.AlarmControlPanelState.DISARMED:
+    # Per Alexa Documentation: users are not allowed to switch from armed_away
+    # directly to another armed state without first disarming the system.
+    # https://developer.amazon.com/en-US/docs/alexa/device-apis/alexa-securitypanelcontroller.html#arming
+    if (
+        entity.state == alarm_control_panel.AlarmControlPanelState.ARMED_AWAY
+        and arm_state != "ARMED_AWAY"
+    ):
        msg = "You must disarm the system before you can set the requested arm state."
        raise AlexaSecurityPanelAuthorizationRequired(msg)

--- a/homeassistant/components/analytics_insights/config_flow.py
+++ b/homeassistant/components/analytics_insights/config_flow.py
@ -16,7 +16,6 @@ from homeassistant.config_entries import (
    ConfigFlow,
    ConfigFlowResult,
    OptionsFlow,
-    OptionsFlowWithConfigEntry,
 )
 from homeassistant.core import callback
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
@ -46,9 +45,11 @@ class HomeassistantAnalyticsConfigFlow(ConfigFlow, domain=DOMAIN):

    @staticmethod
    @callback
-    def async_get_options_flow(config_entry: ConfigEntry) -> OptionsFlow:
+    def async_get_options_flow(
+        config_entry: ConfigEntry,
+    ) -> HomeassistantAnalyticsOptionsFlowHandler:
        """Get the options flow for this handler."""
-        return HomeassistantAnalyticsOptionsFlowHandler(config_entry)
+        return HomeassistantAnalyticsOptionsFlowHandler()

    async def async_step_user(
        self, user_input: dict[str, Any] | None = None
@ -132,7 +133,7 @@ class HomeassistantAnalyticsConfigFlow(ConfigFlow, domain=DOMAIN):
        )


-class HomeassistantAnalyticsOptionsFlowHandler(OptionsFlowWithConfigEntry):
+class HomeassistantAnalyticsOptionsFlowHandler(OptionsFlow):
    """Handle Homeassistant Analytics options."""

    async def async_step_init(
@ -211,6 +212,6 @@ class HomeassistantAnalyticsOptionsFlowHandler(OptionsFlowWithConfigEntry):
                        ),
                    },
                ),
-                self.options,
+                self.config_entry.options,
            ),
        )
--- a/homeassistant/components/androidtv/config_flow.py
+++ b/homeassistant/components/androidtv/config_flow.py
@ -13,7 +13,7 @@ from homeassistant.config_entries import (
    ConfigEntry,
    ConfigFlow,
    ConfigFlowResult,
-    OptionsFlowWithConfigEntry,
+    OptionsFlow,
 )
 from homeassistant.const import CONF_DEVICE_CLASS, CONF_HOST, CONF_PORT
 from homeassistant.core import callback
@ -186,16 +186,14 @@ class AndroidTVFlowHandler(ConfigFlow, domain=DOMAIN):
        return OptionsFlowHandler(config_entry)


-class OptionsFlowHandler(OptionsFlowWithConfigEntry):
+class OptionsFlowHandler(OptionsFlow):
    """Handle an option flow for Android Debug Bridge."""

    def __init__(self, config_entry: ConfigEntry) -> None:
        """Initialize options flow."""
-        super().__init__(config_entry)
-
-        self._apps: dict[str, Any] = self.options.setdefault(CONF_APPS, {})
-        self._state_det_rules: dict[str, Any] = self.options.setdefault(
-            CONF_STATE_DETECTION_RULES, {}
+        self._apps: dict[str, Any] = dict(config_entry.options.get(CONF_APPS, {}))
+        self._state_det_rules: dict[str, Any] = dict(
+            config_entry.options.get(CONF_STATE_DETECTION_RULES, {})
        )
        self._conf_app_id: str | None = None
        self._conf_rule_id: str | None = None
@ -237,7 +235,7 @@ class OptionsFlowHandler(OptionsFlowWithConfigEntry):
            SelectOptionDict(value=k, label=v) for k, v in apps_list.items()
        ]
        rules = [RULES_NEW_ID, *self._state_det_rules]
-        options = self.options
+        options = self.config_entry.options

        data_schema = vol.Schema(
            {
--- a/homeassistant/components/androidtv_remote/config_flow.py
+++ b/homeassistant/components/androidtv_remote/config_flow.py
@ -20,7 +20,7 @@ from homeassistant.config_entries import (
    ConfigEntry,
    ConfigFlow,
    ConfigFlowResult,
-    OptionsFlowWithConfigEntry,
+    OptionsFlow,
 )
 from homeassistant.const import CONF_HOST, CONF_MAC, CONF_NAME
 from homeassistant.core import callback
@ -221,13 +221,12 @@ class AndroidTVRemoteConfigFlow(ConfigFlow, domain=DOMAIN):
        return AndroidTVRemoteOptionsFlowHandler(config_entry)


-class AndroidTVRemoteOptionsFlowHandler(OptionsFlowWithConfigEntry):
+class AndroidTVRemoteOptionsFlowHandler(OptionsFlow):
    """Android TV Remote options flow."""

    def __init__(self, config_entry: ConfigEntry) -> None:
        """Initialize options flow."""
-        super().__init__(config_entry)
-        self._apps: dict[str, Any] = self.options.setdefault(CONF_APPS, {})
+        self._apps: dict[str, Any] = dict(config_entry.options.get(CONF_APPS, {}))
        self._conf_app_id: str | None = None

    @callback
--- a/homeassistant/components/anthropic/config_flow.py
+++ b/homeassistant/components/anthropic/config_flow.py
@ -121,7 +121,6 @@ class AnthropicOptionsFlow(OptionsFlow):

    def __init__(self, config_entry: ConfigEntry) -> None:
        """Initialize options flow."""
-        self.config_entry = config_entry
        self.last_rendered_recommended = config_entry.options.get(
            CONF_RECOMMENDED, False
        )
--- a/homeassistant/components/assist_pipeline/audio_enhancer.py
+++ b/homeassistant/components/assist_pipeline/audio_enhancer.py
@ -22,8 +22,8 @@ class EnhancedAudioChunk:
    timestamp_ms: int
    """Timestamp relative to start of audio stream (milliseconds)"""

-    is_speech: bool | None
-    """True if audio chunk likely contains speech, False if not, None if unknown"""
+    speech_probability: float | None
+    """Probability that audio chunk contains speech (0-1), None if unknown"""


 class AudioEnhancer(ABC):
@ -70,27 +70,27 @@ class MicroVadSpeexEnhancer(AudioEnhancer):
            )

        self.vad: MicroVad | None = None
-        self.threshold = 0.5

        if self.is_vad_enabled:
            self.vad = MicroVad()
-            _LOGGER.debug("Initialized microVAD with threshold=%s", self.threshold)
+            _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."""
-        is_speech: bool | None = None
+        speech_probability: float | None = None

        assert len(audio) == BYTES_PER_CHUNK

        if self.vad is not None:
            # Run VAD
-            speech_prob = self.vad.Process10ms(audio)
-            is_speech = speech_prob > self.threshold
+            speech_probability = self.vad.Process10ms(audio)

        if self.audio_processor is not None:
            # Run noise suppression and auto gain
            audio = self.audio_processor.Process10ms(audio).audio

        return EnhancedAudioChunk(
-            audio=audio, timestamp_ms=timestamp_ms, is_speech=is_speech
+            audio=audio,
+            timestamp_ms=timestamp_ms,
+            speech_probability=speech_probability,
        )
--- a/homeassistant/components/assist_pipeline/pipeline.py
+++ b/homeassistant/components/assist_pipeline/pipeline.py
@ -780,7 +780,9 @@ class PipelineRun:
                # speaking the voice command.
                audio_chunks_for_stt.extend(
                    EnhancedAudioChunk(
-                        audio=chunk_ts[0], timestamp_ms=chunk_ts[1], is_speech=False
+                        audio=chunk_ts[0],
+                        timestamp_ms=chunk_ts[1],
+                        speech_probability=None,
                    )
                    for chunk_ts in result.queued_audio
                )
@ -827,7 +829,7 @@ class PipelineRun:

            if wake_word_vad is not None:
                chunk_seconds = (len(chunk.audio) // sample_width) / sample_rate
-                if not wake_word_vad.process(chunk_seconds, chunk.is_speech):
+                if not wake_word_vad.process(chunk_seconds, chunk.speech_probability):
                    raise WakeWordTimeoutError(
                        code="wake-word-timeout", message="Wake word was not detected"
                    )
@ -955,7 +957,7 @@ class PipelineRun:

            if stt_vad is not None:
                chunk_seconds = (len(chunk.audio) // sample_width) / sample_rate
-                if not stt_vad.process(chunk_seconds, chunk.is_speech):
+                if not stt_vad.process(chunk_seconds, chunk.speech_probability):
                    # Silence detected at the end of voice command
                    self.process_event(
                        PipelineEvent(
@ -1221,7 +1223,7 @@ class PipelineRun:
                yield EnhancedAudioChunk(
                    audio=sub_chunk,
                    timestamp_ms=timestamp_ms,
-                    is_speech=None,  # no VAD
+                    speech_probability=None,  # no VAD
                )
                timestamp_ms += MS_PER_CHUNK

--- a/homeassistant/components/assist_pipeline/vad.py
+++ b/homeassistant/components/assist_pipeline/vad.py
@ -75,7 +75,7 @@ class AudioBuffer:
 class VoiceCommandSegmenter:
    """Segments an audio stream into voice commands."""

-    speech_seconds: float = 0.3
+    speech_seconds: float = 0.1
    """Seconds of speech before voice command has started."""

    command_seconds: float = 1.0
@ -96,6 +96,12 @@ class VoiceCommandSegmenter:
    timed_out: bool = False
    """True a timeout occurred during voice command."""

+    before_command_speech_threshold: float = 0.2
+    """Probability threshold for speech before voice command."""
+
+    in_command_speech_threshold: float = 0.5
+    """Probability threshold for speech during voice command."""
+
    _speech_seconds_left: float = 0.0
    """Seconds left before considering voice command as started."""

@ -124,7 +130,7 @@ class VoiceCommandSegmenter:
        self._reset_seconds_left = self.reset_seconds
        self.in_command = False

-    def process(self, chunk_seconds: float, is_speech: bool | None) -> bool:
+    def process(self, chunk_seconds: float, speech_probability: float | None) -> bool:
        """Process samples using external VAD.

        Returns False when command is done.
@ -142,7 +148,12 @@ class VoiceCommandSegmenter:
            self.timed_out = True
            return False

+        if speech_probability is None:
+            speech_probability = 0.0
+
        if not self.in_command:
+            # Before command
+            is_speech = speech_probability > self.before_command_speech_threshold
            if is_speech:
                self._reset_seconds_left = self.reset_seconds
                self._speech_seconds_left -= chunk_seconds
@ -160,12 +171,17 @@ class VoiceCommandSegmenter:
                if self._reset_seconds_left <= 0:
                    self._speech_seconds_left = self.speech_seconds
                    self._reset_seconds_left = self.reset_seconds
-        elif not is_speech:
+        else:
+            # In command
+            is_speech = speech_probability > self.in_command_speech_threshold
+            if not is_speech:
                # Silence in command
                self._reset_seconds_left = self.reset_seconds
                self._silence_seconds_left -= chunk_seconds
                self._command_seconds_left -= chunk_seconds
-            if (self._silence_seconds_left <= 0) and (self._command_seconds_left <= 0):
+                if (self._silence_seconds_left <= 0) and (
+                    self._command_seconds_left <= 0
+                ):
                    # Command finished successfully
                    self.reset()
                    _LOGGER.debug("Voice command finished")
@ -226,6 +242,9 @@ class VoiceActivityTimeout:
    reset_seconds: float = 0.5
    """Seconds of speech before resetting timeout."""

+    speech_threshold: float = 0.5
+    """Threshold for speech."""
+
    _silence_seconds_left: float = 0.0
    """Seconds left before considering voice command as stopped."""

@ -241,12 +260,15 @@ class VoiceActivityTimeout:
        self._silence_seconds_left = self.silence_seconds
        self._reset_seconds_left = self.reset_seconds

-    def process(self, chunk_seconds: float, is_speech: bool | None) -> bool:
+    def process(self, chunk_seconds: float, speech_probability: float | None) -> bool:
        """Process samples using external VAD.

        Returns False when timeout is reached.
        """
-        if is_speech:
+        if speech_probability is None:
+            speech_probability = 0.0
+
+        if speech_probability > self.speech_threshold:
            # Speech
            self._reset_seconds_left -= chunk_seconds
            if self._reset_seconds_left <= 0:
--- a/homeassistant/components/axis/config_flow.py
+++ b/homeassistant/components/axis/config_flow.py
@ -18,7 +18,7 @@ from homeassistant.config_entries import (
    ConfigEntry,
    ConfigFlow,
    ConfigFlowResult,
-    OptionsFlowWithConfigEntry,
+    OptionsFlow,
 )
 from homeassistant.const import (
    CONF_HOST,
@ -59,9 +59,11 @@ class AxisFlowHandler(ConfigFlow, domain=AXIS_DOMAIN):

    @staticmethod
    @callback
-    def async_get_options_flow(config_entry: ConfigEntry) -> AxisOptionsFlowHandler:
+    def async_get_options_flow(
+        config_entry: ConfigEntry,
+    ) -> AxisOptionsFlowHandler:
        """Get the options flow for this handler."""
-        return AxisOptionsFlowHandler(config_entry)
+        return AxisOptionsFlowHandler()

    def __init__(self) -> None:
        """Initialize the Axis config flow."""
@ -264,7 +266,7 @@ class AxisFlowHandler(ConfigFlow, domain=AXIS_DOMAIN):
        return await self.async_step_user()


-class AxisOptionsFlowHandler(OptionsFlowWithConfigEntry):
+class AxisOptionsFlowHandler(OptionsFlow):
    """Handle Axis device options."""

    config_entry: AxisConfigEntry
@ -282,8 +284,7 @@ class AxisOptionsFlowHandler(OptionsFlowWithConfigEntry):
    ) -> ConfigFlowResult:
        """Manage the Axis device stream options."""
        if user_input is not None:
-            self.options.update(user_input)
-            return self.async_create_entry(title="", data=self.options)
+            return self.async_create_entry(data=self.config_entry.options | user_input)

        schema = {}

--- a/homeassistant/components/azure_event_hub/config_flow.py
+++ b/homeassistant/components/azure_event_hub/config_flow.py
@ -124,7 +124,9 @@ class AEHConfigFlow(ConfigFlow, domain=DOMAIN):
                step_id=STEP_CONN_STRING,
                data_schema=CONN_STRING_SCHEMA,
                errors=errors,
-                description_placeholders=self._data[CONF_EVENT_HUB_INSTANCE_NAME],
+                description_placeholders={
+                    "event_hub_instance_name": self._data[CONF_EVENT_HUB_INSTANCE_NAME]
+                },
                last_step=True,
            )

@ -144,7 +146,9 @@ class AEHConfigFlow(ConfigFlow, domain=DOMAIN):
                step_id=STEP_SAS,
                data_schema=SAS_SCHEMA,
                errors=errors,
-                description_placeholders=self._data[CONF_EVENT_HUB_INSTANCE_NAME],
+                description_placeholders={
+                    "event_hub_instance_name": self._data[CONF_EVENT_HUB_INSTANCE_NAME]
+                },
                last_step=True,
            )

--- a/homeassistant/components/backup/init.py
+++ b/homeassistant/components/backup/init.py
@ -32,7 +32,9 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:

    async def async_handle_create_service(call: ServiceCall) -> None:
        """Service handler for creating backups."""
-        await backup_manager.async_create_backup()
+        await backup_manager.async_create_backup(on_progress=None)
+        if backup_task := backup_manager.backup_task:
+            await backup_task

    hass.services.async_register(DOMAIN, "create", async_handle_create_service)

--- a/homeassistant/components/backup/http.py
+++ b/homeassistant/components/backup/http.py
@ -2,23 +2,26 @@

 from __future__ import annotations

+import asyncio
 from http import HTTPStatus
+from typing import cast

+from aiohttp import BodyPartReader
 from aiohttp.hdrs import CONTENT_DISPOSITION
 from aiohttp.web import FileResponse, Request, Response

-from homeassistant.components.http import KEY_HASS, HomeAssistantView
+from homeassistant.components.http import KEY_HASS, HomeAssistantView, require_admin
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.util import slugify

-from .const import DOMAIN
-from .manager import BaseBackupManager
+from .const import DATA_MANAGER


@callback
 def async_register_http_views(hass: HomeAssistant) -> None:
    """Register the http views."""
    hass.http.register_view(DownloadBackupView)
+    hass.http.register_view(UploadBackupView)


 class DownloadBackupView(HomeAssistantView):
@ -36,7 +39,7 @@ class DownloadBackupView(HomeAssistantView):
        if not request["hass_user"].is_admin:
            return Response(status=HTTPStatus.UNAUTHORIZED)

-        manager: BaseBackupManager = request.app[KEY_HASS].data[DOMAIN]
+        manager = request.app[KEY_HASS].data[DATA_MANAGER]
        backup = await manager.async_get_backup(slug=slug)

        if backup is None or not backup.path.exists():
@ -48,3 +51,29 @@ class DownloadBackupView(HomeAssistantView):
                CONTENT_DISPOSITION: f"attachment; filename={slugify(backup.name)}.tar"
            },
        )
+
+
+class UploadBackupView(HomeAssistantView):
+    """Generate backup view."""
+
+    url = "/api/backup/upload"
+    name = "api:backup:upload"
+
+    @require_admin
+    async def post(self, request: Request) -> Response:
+        """Upload a backup file."""
+        manager = request.app[KEY_HASS].data[DATA_MANAGER]
+        reader = await request.multipart()
+        contents = cast(BodyPartReader, await reader.next())
+
+        try:
+            await manager.async_receive_backup(contents=contents)
+        except OSError as err:
+            return Response(
+                body=f"Can't write backup file {err}",
+                status=HTTPStatus.INTERNAL_SERVER_ERROR,
+            )
+        except asyncio.CancelledError:
+            return Response(status=HTTPStatus.INTERNAL_SERVER_ERROR)
+
+        return Response(status=HTTPStatus.CREATED)
--- a/homeassistant/components/backup/manager.py
+++ b/homeassistant/components/backup/manager.py
@ -4,16 +4,21 @@ from __future__ import annotations

 import abc
 import asyncio
+from collections.abc import Callable
 from dataclasses import asdict, dataclass
 import hashlib
 import io
 import json
 from pathlib import Path
+from queue import SimpleQueue
+import shutil
 import tarfile
 from tarfile import TarError
+from tempfile import TemporaryDirectory
 import time
 from typing import Any, Protocol, cast

+import aiohttp
 from securetar import SecureTarFile, atomic_contents_add

 from homeassistant.backup_restore import RESTORE_BACKUP_FILE
@ -30,6 +35,13 @@ from .const import DOMAIN, EXCLUDE_FROM_BACKUP, LOGGER
 BUF_SIZE = 2**20 * 4  # 4MB


+@dataclass(slots=True)
+class NewBackup:
+    """New backup class."""
+
+    slug: str
+
+
@dataclass(slots=True)
 class Backup:
    """Backup class."""
@ -45,6 +57,15 @@ class Backup:
        return {**asdict(self), "path": self.path.as_posix()}


+@dataclass(slots=True)
+class BackupProgress:
+    """Backup progress class."""
+
+    done: bool
+    stage: str | None
+    success: bool | None
+
+
 class BackupPlatformProtocol(Protocol):
    """Define the format that backup platforms can have."""

@ -61,7 +82,7 @@ class BaseBackupManager(abc.ABC):
    def __init__(self, hass: HomeAssistant) -> None:
        """Initialize the backup manager."""
        self.hass = hass
-        self.backing_up = False
+        self.backup_task: asyncio.Task | None = None
        self.backups: dict[str, Backup] = {}
        self.loaded_platforms = False
        self.platforms: dict[str, BackupPlatformProtocol] = {}
@ -126,10 +147,15 @@ class BaseBackupManager(abc.ABC):

    @abc.abstractmethod
    async def async_restore_backup(self, slug: str, **kwargs: Any) -> None:
-        """Restpre a backup."""
+        """Restore a backup."""

    @abc.abstractmethod
-    async def async_create_backup(self, **kwargs: Any) -> Backup:
+    async def async_create_backup(
+        self,
+        *,
+        on_progress: Callable[[BackupProgress], None] | None,
+        **kwargs: Any,
+    ) -> NewBackup:
        """Generate a backup."""

    @abc.abstractmethod
@ -147,6 +173,15 @@ class BaseBackupManager(abc.ABC):
    async def async_remove_backup(self, *, slug: str, **kwargs: Any) -> None:
        """Remove a backup."""

+    @abc.abstractmethod
+    async def async_receive_backup(
+        self,
+        *,
+        contents: aiohttp.BodyPartReader,
+        **kwargs: Any,
+    ) -> None:
+        """Receive and store a backup file from upload."""
+

 class BackupManager(BaseBackupManager):
    """Backup manager for the Backup integration."""
@ -222,17 +257,93 @@ class BackupManager(BaseBackupManager):
        LOGGER.debug("Removed backup located at %s", backup.path)
        self.backups.pop(slug)

-    async def async_create_backup(self, **kwargs: Any) -> Backup:
-        """Generate a backup."""
-        if self.backing_up:
-            raise HomeAssistantError("Backup already in progress")
+    async def async_receive_backup(
+        self,
+        *,
+        contents: aiohttp.BodyPartReader,
+        **kwargs: Any,
+    ) -> None:
+        """Receive and store a backup file from upload."""
+        queue: SimpleQueue[tuple[bytes, asyncio.Future[None] | None] | None] = (
+            SimpleQueue()
+        )
+        temp_dir_handler = await self.hass.async_add_executor_job(TemporaryDirectory)
+        target_temp_file = Path(
+            temp_dir_handler.name, contents.filename or "backup.tar"
+        )

+        def _sync_queue_consumer() -> None:
+            with target_temp_file.open("wb") as file_handle:
+                while True:
+                    if (_chunk_future := queue.get()) is None:
+                        break
+                    _chunk, _future = _chunk_future
+                    if _future is not None:
+                        self.hass.loop.call_soon_threadsafe(_future.set_result, None)
+                    file_handle.write(_chunk)
+
+        fut: asyncio.Future[None] | None = None
        try:
-            self.backing_up = True
-            await self.async_pre_backup_actions()
+            fut = self.hass.async_add_executor_job(_sync_queue_consumer)
+            megabytes_sending = 0
+            while chunk := await contents.read_chunk(BUF_SIZE):
+                megabytes_sending += 1
+                if megabytes_sending % 5 != 0:
+                    queue.put_nowait((chunk, None))
+                    continue
+
+                chunk_future = self.hass.loop.create_future()
+                queue.put_nowait((chunk, chunk_future))
+                await asyncio.wait(
+                    (fut, chunk_future),
+                    return_when=asyncio.FIRST_COMPLETED,
+                )
+                if fut.done():
+                    # The executor job failed
+                    break
+
+            queue.put_nowait(None)  # terminate queue consumer
+        finally:
+            if fut is not None:
+                await fut
+
+        def _move_and_cleanup() -> None:
+            shutil.move(target_temp_file, self.backup_dir / target_temp_file.name)
+            temp_dir_handler.cleanup()
+
+        await self.hass.async_add_executor_job(_move_and_cleanup)
+        await self.load_backups()
+
+    async def async_create_backup(
+        self,
+        *,
+        on_progress: Callable[[BackupProgress], None] | None,
+        **kwargs: Any,
+    ) -> NewBackup:
+        """Generate a backup."""
+        if self.backup_task:
+            raise HomeAssistantError("Backup already in progress")
        backup_name = f"Core {HAVERSION}"
        date_str = dt_util.now().isoformat()
        slug = _generate_slug(date_str, backup_name)
+        self.backup_task = self.hass.async_create_task(
+            self._async_create_backup(backup_name, date_str, slug, on_progress),
+            name="backup_manager_create_backup",
+            eager_start=False,  # To ensure the task is not started before we return
+        )
+        return NewBackup(slug=slug)
+
+    async def _async_create_backup(
+        self,
+        backup_name: str,
+        date_str: str,
+        slug: str,
+        on_progress: Callable[[BackupProgress], None] | None,
+    ) -> Backup:
+        """Generate a backup."""
+        success = False
+        try:
+            await self.async_pre_backup_actions()

            backup_data = {
                "slug": slug,
@ -259,9 +370,12 @@ class BackupManager(BaseBackupManager):
            if self.loaded_backups:
                self.backups[slug] = backup
            LOGGER.debug("Generated new backup with slug %s", slug)
+            success = True
            return backup
        finally:
-            self.backing_up = False
+            if on_progress:
+                on_progress(BackupProgress(done=True, stage=None, success=success))
+            self.backup_task = None
            await self.async_post_backup_actions()

    def _mkdir_and_generate_backup_contents(
@ -308,7 +422,7 @@ class BackupManager(BaseBackupManager):
        def _write_restore_file() -> None:
            """Write the restore file."""
            Path(self.hass.config.path(RESTORE_BACKUP_FILE)).write_text(
-                f"{backup.path.as_posix()};",
+                json.dumps({"path": backup.path.as_posix()}),
                encoding="utf-8",
            )

--- a/homeassistant/components/backup/websocket.py
+++ b/homeassistant/components/backup/websocket.py
@ -8,6 +8,7 @@ from homeassistant.components import websocket_api
 from homeassistant.core import HomeAssistant, callback

 from .const import DATA_MANAGER, LOGGER
+from .manager import BackupProgress


@callback
@ -40,7 +41,7 @@ async def handle_info(
        msg["id"],
        {
            "backups": list(backups.values()),
-            "backing_up": manager.backing_up,
+            "backing_up": manager.backup_task is not None,
        },
    )

@ -113,7 +114,11 @@ async def handle_create(
    msg: dict[str, Any],
 ) -> None:
    """Generate a backup."""
-    backup = await hass.data[DATA_MANAGER].async_create_backup()
+
+    def on_progress(progress: BackupProgress) -> None:
+        connection.send_message(websocket_api.event_message(msg["id"], progress))
+
+    backup = await hass.data[DATA_MANAGER].async_create_backup(on_progress=on_progress)
    connection.send_result(msg["id"], backup)


@ -127,7 +132,6 @@ async def handle_backup_start(
 ) -> None:
    """Backup start notification."""
    manager = hass.data[DATA_MANAGER]
-    manager.backing_up = True
    LOGGER.debug("Backup start notification")

    try:
@ -149,7 +153,6 @@ async def handle_backup_end(
 ) -> None:
    """Backup end notification."""
    manager = hass.data[DATA_MANAGER]
-    manager.backing_up = False
    LOGGER.debug("Backup end notification")

    try:
--- a/homeassistant/components/bang_olufsen/const.py
+++ b/homeassistant/components/bang_olufsen/const.py
@ -17,46 +17,9 @@ from homeassistant.components.media_player import (
 class BangOlufsenSource:
    """Class used for associating device source ids with friendly names. May not include all sources."""

-    URI_STREAMER: Final[Source] = Source(
-        name="Audio Streamer",
-        id="uriStreamer",
-        is_seekable=False,
-    )
-    BLUETOOTH: Final[Source] = Source(
-        name="Bluetooth",
-        id="bluetooth",
-        is_seekable=False,
-    )
-    CHROMECAST: Final[Source] = Source(
-        name="Chromecast built-in",
-        id="chromeCast",
-        is_seekable=False,
-    )
-    LINE_IN: Final[Source] = Source(
-        name="Line-In",
-        id="lineIn",
-        is_seekable=False,
-    )
-    SPDIF: Final[Source] = Source(
-        name="Optical",
-        id="spdif",
-        is_seekable=False,
-    )
-    NET_RADIO: Final[Source] = Source(
-        name="B&O Radio",
-        id="netRadio",
-        is_seekable=False,
-    )
-    DEEZER: Final[Source] = Source(
-        name="Deezer",
-        id="deezer",
-        is_seekable=True,
-    )
-    TIDAL: Final[Source] = Source(
-        name="Tidal",
-        id="tidal",
-        is_seekable=True,
-    )
+    LINE_IN: Final[Source] = Source(name="Line-In", id="lineIn")
+    SPDIF: Final[Source] = Source(name="Optical", id="spdif")
+    URI_STREAMER: Final[Source] = Source(name="Audio Streamer", id="uriStreamer")


 BANG_OLUFSEN_STATES: dict[str, MediaPlayerState] = {
@ -170,20 +133,6 @@ VALID_MEDIA_TYPES: Final[tuple] = (
    MediaType.CHANNEL,
 )

-# Sources on the device that should not be selectable by the user
-HIDDEN_SOURCE_IDS: Final[tuple] = (
-    "airPlay",
-    "bluetooth",
-    "chromeCast",
-    "generator",
-    "local",
-    "dlna",
-    "qplay",
-    "wpl",
-    "pl",
-    "beolink",
-    "usbIn",
-)

 # Fallback sources to use in case of API failure.
 FALLBACK_SOURCES: Final[SourceArray] = SourceArray(
@ -191,7 +140,7 @@ FALLBACK_SOURCES: Final[SourceArray] = SourceArray(
        Source(
            id="uriStreamer",
            is_enabled=True,
-            is_playable=False,
+            is_playable=True,
            name="Audio Streamer",
            type=SourceTypeEnum(value="uriStreamer"),
            is_seekable=False,
@ -199,7 +148,7 @@ FALLBACK_SOURCES: Final[SourceArray] = SourceArray(
        Source(
            id="bluetooth",
            is_enabled=True,
-            is_playable=False,
+            is_playable=True,
            name="Bluetooth",
            type=SourceTypeEnum(value="bluetooth"),
            is_seekable=False,
@ -207,7 +156,7 @@ FALLBACK_SOURCES: Final[SourceArray] = SourceArray(
        Source(
            id="spotify",
            is_enabled=True,
-            is_playable=False,
+            is_playable=True,
            name="Spotify Connect",
            type=SourceTypeEnum(value="spotify"),
            is_seekable=True,
--- a/homeassistant/components/bang_olufsen/icons.json
+++ b/homeassistant/components/bang_olufsen/icons.json
@ -0,0 +1,9 @@
+{
+  "services": {
+    "beolink_join": { "service": "mdi:location-enter" },
+    "beolink_expand": { "service": "mdi:location-enter" },
+    "beolink_unexpand": { "service": "mdi:location-exit" },
+    "beolink_leave": { "service": "mdi:close-circle-outline" },
+    "beolink_allstandby": { "service": "mdi:close-circle-multiple-outline" }
+  }
+}
--- a/homeassistant/components/bang_olufsen/media_player.py
+++ b/homeassistant/components/bang_olufsen/media_player.py
@ -11,7 +11,7 @@ from typing import TYPE_CHECKING, Any, cast

 from aiohttp import ClientConnectorError
 from mozart_api import __version__ as MOZART_API_VERSION
-from mozart_api.exceptions import ApiException
+from mozart_api.exceptions import ApiException, NotFoundException
 from mozart_api.models import (
    Action,
    Art,
@ -38,6 +38,7 @@ from mozart_api.models import (
    VolumeState,
 )
 from mozart_api.mozart_client import MozartClient, get_highest_resolution_artwork
+import voluptuous as vol

 from homeassistant.components import media_source
 from homeassistant.components.media_player import (
@ -55,10 +56,17 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_MODEL, Platform
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
-from homeassistant.helpers import entity_registry as er
+from homeassistant.helpers import (
+    config_validation as cv,
+    device_registry as dr,
+    entity_registry as er,
+)
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.helpers.entity_platform import (
+    AddEntitiesCallback,
+    async_get_current_platform,
+)
 from homeassistant.util.dt import utcnow

 from . import BangOlufsenConfigEntry
@ -70,7 +78,6 @@ from .const import (
    CONNECTION_STATUS,
    DOMAIN,
    FALLBACK_SOURCES,
-    HIDDEN_SOURCE_IDS,
    VALID_MEDIA_TYPES,
    BangOlufsenMediaType,
    BangOlufsenSource,
@ -117,6 +124,58 @@ async def async_setup_entry(
        ]
    )

+    # Register actions.
+    platform = async_get_current_platform()
+
+    jid_regex = vol.Match(
+        r"(^\d{4})[.](\d{7})[.](\d{8})(@products\.bang-olufsen\.com)$"
+    )
+
+    platform.async_register_entity_service(
+        name="beolink_join",
+        schema={vol.Optional("beolink_jid"): jid_regex},
+        func="async_beolink_join",
+    )
+
+    platform.async_register_entity_service(
+        name="beolink_expand",
+        schema={
+            vol.Exclusive("all_discovered", "devices", ""): cv.boolean,
+            vol.Exclusive(
+                "beolink_jids",
+                "devices",
+                "Define either specific Beolink JIDs or all discovered",
+            ): vol.All(
+                cv.ensure_list,
+                [jid_regex],
+            ),
+        },
+        func="async_beolink_expand",
+    )
+
+    platform.async_register_entity_service(
+        name="beolink_unexpand",
+        schema={
+            vol.Required("beolink_jids"): vol.All(
+                cv.ensure_list,
+                [jid_regex],
+            ),
+        },
+        func="async_beolink_unexpand",
+    )
+
+    platform.async_register_entity_service(
+        name="beolink_leave",
+        schema=None,
+        func="async_beolink_leave",
+    )
+
+    platform.async_register_entity_service(
+        name="beolink_allstandby",
+        schema=None,
+        func="async_beolink_allstandby",
+    )
+

 class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
    """Representation of a media player."""
@ -157,6 +216,8 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
        # Beolink compatible sources
        self._beolink_sources: dict[str, bool] = {}
        self._remote_leader: BeolinkLeader | None = None
+        # Extra state attributes for showing Beolink: peer(s), listener(s), leader and self
+        self._beolink_attributes: dict[str, dict[str, dict[str, str]]] = {}

    async def async_added_to_hass(self) -> None:
        """Turn on the dispatchers."""
@ -166,9 +227,11 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
            CONNECTION_STATUS: self._async_update_connection_state,
            WebsocketNotification.ACTIVE_LISTENING_MODE: self._async_update_sound_modes,
            WebsocketNotification.BEOLINK: self._async_update_beolink,
+            WebsocketNotification.CONFIGURATION: self._async_update_name_and_beolink,
            WebsocketNotification.PLAYBACK_ERROR: self._async_update_playback_error,
            WebsocketNotification.PLAYBACK_METADATA: self._async_update_playback_metadata_and_beolink,
            WebsocketNotification.PLAYBACK_PROGRESS: self._async_update_playback_progress,
+            WebsocketNotification.PLAYBACK_SOURCE: self._async_update_sources,
            WebsocketNotification.PLAYBACK_STATE: self._async_update_playback_state,
            WebsocketNotification.REMOTE_MENU_CHANGED: self._async_update_sources,
            WebsocketNotification.SOURCE_CHANGE: self._async_update_source_change,
@ -230,6 +293,9 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):

        await self._async_update_sound_modes()

+        # Update beolink attributes and device name.
+        await self._async_update_name_and_beolink()
+
    async def async_update(self) -> None:
        """Update queue settings."""
        # The WebSocket event listener is the main handler for connection state.
@ -243,7 +309,7 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
            if queue_settings.shuffle is not None:
                self._attr_shuffle = queue_settings.shuffle

-    async def _async_update_sources(self) -> None:
+    async def _async_update_sources(self, _: Source | None = None) -> None:
        """Get sources for the specific product."""

        # Audio sources
@ -270,10 +336,7 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
        self._audio_sources = {
            source.id: source.name
            for source in cast(list[Source], sources.items)
-            if source.is_enabled
-            and source.id
-            and source.name
-            and source.id not in HIDDEN_SOURCE_IDS
+            if source.is_enabled and source.id and source.name and source.is_playable
        }

        # Some sources are not Beolink expandable, meaning that they can't be joined by
@ -375,9 +438,44 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):

        self.async_write_ha_state()

+    async def _async_update_name_and_beolink(self) -> None:
+        """Update the device friendly name."""
+        beolink_self = await self._client.get_beolink_self()
+
+        # Update device name
+        device_registry = dr.async_get(self.hass)
+        assert self.device_entry is not None
+
+        device_registry.async_update_device(
+            device_id=self.device_entry.id,
+            name=beolink_self.friendly_name,
+        )
+
+        await self._async_update_beolink()
+
    async def _async_update_beolink(self) -> None:
        """Update the current Beolink leader, listeners, peers and self."""

+        self._beolink_attributes = {}
+
+        assert self.device_entry is not None
+        assert self.device_entry.name is not None
+
+        # Add Beolink self
+        self._beolink_attributes = {
+            "beolink": {"self": {self.device_entry.name: self._beolink_jid}}
+        }
+
+        # Add Beolink peers
+        peers = await self._client.get_beolink_peers()
+
+        if len(peers) > 0:
+            self._beolink_attributes["beolink"]["peers"] = {}
+            for peer in peers:
+                self._beolink_attributes["beolink"]["peers"][peer.friendly_name] = (
+                    peer.jid
+                )
+
        # Add Beolink listeners / leader
        self._remote_leader = self._playback_metadata.remote_leader

@ -397,9 +495,14 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
            # Add self
            group_members.append(self.entity_id)

+            self._beolink_attributes["beolink"]["leader"] = {
+                self._remote_leader.friendly_name: self._remote_leader.jid,
+            }
+
        # If not listener, check if leader.
        else:
            beolink_listeners = await self._client.get_beolink_listeners()
+            beolink_listeners_attribute = {}

            # Check if the device is a leader.
            if len(beolink_listeners) > 0:
@ -420,6 +523,18 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
                        for beolink_listener in beolink_listeners
                    ]
                )
+                # Update Beolink attributes
+                for beolink_listener in beolink_listeners:
+                    for peer in peers:
+                        if peer.jid == beolink_listener.jid:
+                            # Get the friendly names for the listeners from the peers
+                            beolink_listeners_attribute[peer.friendly_name] = (
+                                beolink_listener.jid
+                            )
+                            break
+                self._beolink_attributes["beolink"]["listeners"] = (
+                    beolink_listeners_attribute
+                )

        self._attr_group_members = group_members

@ -573,38 +688,19 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
    @property
    def source(self) -> str | None:
        """Return the current audio source."""
-
-        # Try to fix some of the source_change chromecast weirdness.
-        if hasattr(self._playback_metadata, "title"):
-            # source_change is chromecast but line in is selected.
-            if self._playback_metadata.title == BangOlufsenSource.LINE_IN.name:
-                return BangOlufsenSource.LINE_IN.name
-
-            # source_change is chromecast but bluetooth is selected.
-            if self._playback_metadata.title == BangOlufsenSource.BLUETOOTH.name:
-                return BangOlufsenSource.BLUETOOTH.name
-
-            # source_change is line in, bluetooth or optical but stale metadata is sent through the WebSocket,
-            # And the source has not changed.
-            if self._source_change.id in (
-                BangOlufsenSource.BLUETOOTH.id,
-                BangOlufsenSource.LINE_IN.id,
-                BangOlufsenSource.SPDIF.id,
-            ):
-                return BangOlufsenSource.CHROMECAST.name
-
-        # source_change is chromecast and there is metadata but no artwork. Bluetooth does support metadata but not artwork
-        # So i assume that it is bluetooth and not chromecast
-        if (
-            hasattr(self._playback_metadata, "art")
-            and self._playback_metadata.art is not None
-            and len(self._playback_metadata.art) == 0
-            and self._source_change.id == BangOlufsenSource.CHROMECAST.id
-        ):
-            return BangOlufsenSource.BLUETOOTH.name
-
        return self._source_change.name

+    @property
+    def extra_state_attributes(self) -> dict[str, Any] | None:
+        """Return information that is not returned anywhere else."""
+        attributes: dict[str, Any] = {}
+
+        # Add Beolink attributes
+        if self._beolink_attributes:
+            attributes.update(self._beolink_attributes)
+
+        return attributes
+
    async def async_turn_off(self) -> None:
        """Set the device to "networkStandby"."""
        await self._client.post_standby()
@ -876,23 +972,30 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
        # Beolink compatible B&O device.
        # Repeated presses / calls will cycle between compatible playing devices.
        if len(group_members) == 0:
-            await self._async_beolink_join()
+            await self.async_beolink_join()
            return

        # Get JID for each group member
        jids = [self._get_beolink_jid(group_member) for group_member in group_members]
-        await self._async_beolink_expand(jids)
+        await self.async_beolink_expand(jids)

    async def async_unjoin_player(self) -> None:
        """Unjoin Beolink session. End session if leader."""
-        await self._async_beolink_leave()
+        await self.async_beolink_leave()

-    async def _async_beolink_join(self) -> None:
+    # Custom actions:
+    async def async_beolink_join(self, beolink_jid: str | None = None) -> None:
        """Join a Beolink multi-room experience."""
+        if beolink_jid is None:
            await self._client.join_latest_beolink_experience()
+        else:
+            await self._client.join_beolink_peer(jid=beolink_jid)

-    async def _async_beolink_expand(self, beolink_jids: list[str]) -> None:
+    async def async_beolink_expand(
+        self, beolink_jids: list[str] | None = None, all_discovered: bool = False
+    ) -> None:
        """Expand a Beolink multi-room experience with a device or devices."""
+
        # Ensure that the current source is expandable
        if not self._beolink_sources[cast(str, self._source_change.id)]:
            raise ServiceValidationError(
@ -904,10 +1007,37 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
                },
            )

-        # Try to expand to all defined devices
-        for beolink_jid in beolink_jids:
-            await self._client.post_beolink_expand(jid=beolink_jid)
+        # Expand to all discovered devices
+        if all_discovered:
+            peers = await self._client.get_beolink_peers()

-    async def _async_beolink_leave(self) -> None:
+            for peer in peers:
+                try:
+                    await self._client.post_beolink_expand(jid=peer.jid)
+                except NotFoundException:
+                    _LOGGER.warning("Unable to expand to %s", peer.jid)
+
+        # Try to expand to all defined devices
+        elif beolink_jids:
+            for beolink_jid in beolink_jids:
+                try:
+                    await self._client.post_beolink_expand(jid=beolink_jid)
+                except NotFoundException:
+                    _LOGGER.warning(
+                        "Unable to expand to %s. Is the device available on the network?",
+                        beolink_jid,
+                    )
+
+    async def async_beolink_unexpand(self, beolink_jids: list[str]) -> None:
+        """Unexpand a Beolink multi-room experience with a device or devices."""
+        # Unexpand all defined devices
+        for beolink_jid in beolink_jids:
+            await self._client.post_beolink_unexpand(jid=beolink_jid)
+
+    async def async_beolink_leave(self) -> None:
        """Leave the current Beolink experience."""
        await self._client.post_beolink_leave()
+
+    async def async_beolink_allstandby(self) -> None:
+        """Set all connected Beolink devices to standby."""
+        await self._client.post_beolink_allstandby()
--- a/homeassistant/components/bang_olufsen/services.yaml
+++ b/homeassistant/components/bang_olufsen/services.yaml
@ -0,0 +1,79 @@
+beolink_allstandby:
+  target:
+    entity:
+      integration: bang_olufsen
+      domain: media_player
+    device:
+      integration: bang_olufsen
+
+beolink_expand:
+  target:
+    entity:
+      integration: bang_olufsen
+      domain: media_player
+    device:
+      integration: bang_olufsen
+  fields:
+    all_discovered:
+      required: false
+      example: false
+      selector:
+        boolean:
+    jid_options:
+      collapsed: false
+      fields:
+        beolink_jids:
+          required: false
+          example: >-
+            [
+              1111.2222222.33333333@products.bang-olufsen.com,
+              4444.5555555.66666666@products.bang-olufsen.com
+            ]
+          selector:
+            object:
+
+beolink_join:
+  target:
+    entity:
+      integration: bang_olufsen
+      domain: media_player
+    device:
+      integration: bang_olufsen
+  fields:
+    jid_options:
+      collapsed: false
+      fields:
+        beolink_jid:
+          required: false
+          example: 1111.2222222.33333333@products.bang-olufsen.com
+          selector:
+            text:
+
+beolink_leave:
+  target:
+    entity:
+      integration: bang_olufsen
+      domain: media_player
+    device:
+      integration: bang_olufsen
+
+beolink_unexpand:
+  target:
+    entity:
+      integration: bang_olufsen
+      domain: media_player
+    device:
+      integration: bang_olufsen
+  fields:
+    jid_options:
+      collapsed: false
+      fields:
+        beolink_jids:
+          required: true
+          example: >-
+            [
+              1111.2222222.33333333@products.bang-olufsen.com,
+              4444.5555555.66666666@products.bang-olufsen.com
+            ]
+          selector:
+            object:
--- a/homeassistant/components/bang_olufsen/strings.json
+++ b/homeassistant/components/bang_olufsen/strings.json
@ -1,4 +1,8 @@
 {
+  "common": {
+    "jid_options_name": "JID options",
+    "jid_options_description": "Advanced grouping options, where devices' unique Beolink IDs (Called JIDs) are used directly. JIDs can be found in the state attributes of the media player entity."
+  },
  "config": {
    "error": {
      "api_exception": "[%key:common::config_flow::error::cannot_connect%]",
@ -25,6 +29,68 @@
      }
    }
  },
+  "services": {
+    "beolink_allstandby": {
+      "name": "Beolink all standby",
+      "description": "Set all Connected Beolink devices to standby."
+    },
+    "beolink_expand": {
+      "name": "Beolink expand",
+      "description": "Expand current Beolink experience.",
+      "fields": {
+        "all_discovered": {
+          "name": "All discovered",
+          "description": "Expand Beolink experience to all discovered devices."
+        },
+        "beolink_jids": {
+          "name": "Beolink JIDs",
+          "description": "Specify which Beolink JIDs will join current Beolink experience."
+        }
+      },
+      "sections": {
+        "jid_options": {
+          "name": "[%key:component::bang_olufsen::common::jid_options_name%]",
+          "description": "[%key:component::bang_olufsen::common::jid_options_description%]"
+        }
+      }
+    },
+    "beolink_join": {
+      "name": "Beolink join",
+      "description": "Join a Beolink experience.",
+      "fields": {
+        "beolink_jid": {
+          "name": "Beolink JID",
+          "description": "Manually specify Beolink JID to join."
+        }
+      },
+      "sections": {
+        "jid_options": {
+          "name": "[%key:component::bang_olufsen::common::jid_options_name%]",
+          "description": "[%key:component::bang_olufsen::common::jid_options_description%]"
+        }
+      }
+    },
+    "beolink_leave": {
+      "name": "Beolink leave",
+      "description": "Leave a Beolink experience."
+    },
+    "beolink_unexpand": {
+      "name": "Beolink unexpand",
+      "description": "Unexpand from current Beolink experience.",
+      "fields": {
+        "beolink_jids": {
+          "name": "Beolink JIDs",
+          "description": "Specify which Beolink JIDs will leave from current Beolink experience."
+        }
+      },
+      "sections": {
+        "jid_options": {
+          "name": "[%key:component::bang_olufsen::common::jid_options_name%]",
+          "description": "[%key:component::bang_olufsen::common::jid_options_description%]"
+        }
+      }
+    }
+  },
  "exceptions": {
    "m3u_invalid_format": {
      "message": "Media sources with the .m3u extension are not supported."
--- a/homeassistant/components/bang_olufsen/websocket.py
+++ b/homeassistant/components/bang_olufsen/websocket.py
@ -63,6 +63,9 @@ class BangOlufsenWebsocket(BangOlufsenBase):
        self._client.get_playback_progress_notifications(
            self.on_playback_progress_notification
        )
+        self._client.get_playback_source_notifications(
+            self.on_playback_source_notification
+        )
        self._client.get_playback_state_notifications(
            self.on_playback_state_notification
        )
@ -117,6 +120,11 @@ class BangOlufsenWebsocket(BangOlufsenBase):
                self.hass,
                f"{self._unique_id}_{WebsocketNotification.BEOLINK}",
            )
+        elif notification_type is WebsocketNotification.CONFIGURATION:
+            async_dispatcher_send(
+                self.hass,
+                f"{self._unique_id}_{WebsocketNotification.CONFIGURATION}",
+            )
        elif notification_type is WebsocketNotification.REMOTE_MENU_CHANGED:
            async_dispatcher_send(
                self.hass,
@ -157,6 +165,14 @@ class BangOlufsenWebsocket(BangOlufsenBase):
            notification,
        )

+    def on_playback_source_notification(self, notification: Source) -> None:
+        """Send playback_source dispatch."""
+        async_dispatcher_send(
+            self.hass,
+            f"{self._unique_id}_{WebsocketNotification.PLAYBACK_SOURCE}",
+            notification,
+        )
+
    def on_source_change_notification(self, notification: Source) -> None:
        """Send source_change dispatch."""
        async_dispatcher_send(
--- a/homeassistant/components/blink/sensor.py
+++ b/homeassistant/components/blink/sensor.py
@ -10,7 +10,11 @@ from homeassistant.components.sensor import (
    SensorEntityDescription,
    SensorStateClass,
 )
-from homeassistant.const import EntityCategory, UnitOfTemperature
+from homeassistant.const import (
+    SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
+    EntityCategory,
+    UnitOfTemperature,
+)
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -32,6 +36,8 @@ SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
    SensorEntityDescription(
        key=TYPE_WIFI_STRENGTH,
        translation_key="wifi_strength",
+        native_unit_of_measurement=SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
+        device_class=SensorDeviceClass.SIGNAL_STRENGTH,
        entity_category=EntityCategory.DIAGNOSTIC,
        state_class=SensorStateClass.MEASUREMENT,
    ),
--- a/homeassistant/components/bluesound/media_player.py
+++ b/homeassistant/components/bluesound/media_player.py
@ -364,11 +364,12 @@ class BluesoundPlayer(MediaPlayerEntity):
        if self.is_grouped and not self.is_master:
            return MediaPlayerState.IDLE

-        status = self._status.state
-        if status in ("pause", "stop"):
+        match self._status.state:
+            case "pause":
                return MediaPlayerState.PAUSED
-        if status in ("stream", "play"):
+            case "stream" | "play":
                return MediaPlayerState.PLAYING
+            case _:
                return MediaPlayerState.IDLE

    @property
@ -769,7 +770,7 @@ class BluesoundPlayer(MediaPlayerEntity):

    async def async_set_volume_level(self, volume: float) -> None:
        """Send volume_up command to media player."""
-        volume = int(volume * 100)
+        volume = int(round(volume * 100))
        volume = min(100, volume)
        volume = max(0, volume)

--- a/homeassistant/components/bmw_connected_drive/config_flow.py
+++ b/homeassistant/components/bmw_connected_drive/config_flow.py
@ -7,7 +7,11 @@ from typing import Any

 from bimmer_connected.api.authentication import MyBMWAuthentication
 from bimmer_connected.api.regions import get_region_from_name
-from bimmer_connected.models import MyBMWAPIError, MyBMWAuthError
+from bimmer_connected.models import (
+    MyBMWAPIError,
+    MyBMWAuthError,
+    MyBMWCaptchaMissingError,
+)
 from httpx import RequestError
 import voluptuous as vol

@ -17,7 +21,7 @@ from homeassistant.config_entries import (
    ConfigEntry,
    ConfigFlow,
    ConfigFlowResult,
-    OptionsFlowWithConfigEntry,
+    OptionsFlow,
 )
 from homeassistant.const import CONF_PASSWORD, CONF_REGION, CONF_SOURCE, CONF_USERNAME
 from homeassistant.core import HomeAssistant, callback
@ -54,6 +58,8 @@ async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str,

    try:
        await auth.login()
+    except MyBMWCaptchaMissingError as ex:
+        raise MissingCaptcha from ex
    except MyBMWAuthError as ex:
        raise InvalidAuth from ex
    except (MyBMWAPIError, RequestError) as ex:
@ -98,6 +104,8 @@ class BMWConfigFlow(ConfigFlow, domain=DOMAIN):
                    CONF_REFRESH_TOKEN: info.get(CONF_REFRESH_TOKEN),
                    CONF_GCID: info.get(CONF_GCID),
                }
+            except MissingCaptcha:
+                errors["base"] = "missing_captcha"
            except CannotConnect:
                errors["base"] = "cannot_connect"
            except InvalidAuth:
@ -145,10 +153,10 @@ class BMWConfigFlow(ConfigFlow, domain=DOMAIN):
        config_entry: ConfigEntry,
    ) -> BMWOptionsFlow:
        """Return a MyBMW option flow."""
-        return BMWOptionsFlow(config_entry)
+        return BMWOptionsFlow()


-class BMWOptionsFlow(OptionsFlowWithConfigEntry):
+class BMWOptionsFlow(OptionsFlow):
    """Handle a option flow for MyBMW."""

    async def async_step_init(
@ -192,3 +200,7 @@ class CannotConnect(HomeAssistantError):

 class InvalidAuth(HomeAssistantError):
    """Error to indicate there is invalid auth."""
+
+
+class MissingCaptcha(HomeAssistantError):
+    """Error to indicate the captcha token is missing."""
--- a/homeassistant/components/bmw_connected_drive/coordinator.py
+++ b/homeassistant/components/bmw_connected_drive/coordinator.py
@ -7,7 +7,12 @@ import logging

 from bimmer_connected.account import MyBMWAccount
 from bimmer_connected.api.regions import get_region_from_name
-from bimmer_connected.models import GPSPosition, MyBMWAPIError, MyBMWAuthError
+from bimmer_connected.models import (
+    GPSPosition,
+    MyBMWAPIError,
+    MyBMWAuthError,
+    MyBMWCaptchaMissingError,
+)
 from httpx import RequestError

 from homeassistant.config_entries import ConfigEntry
@ -61,6 +66,12 @@ class BMWDataUpdateCoordinator(DataUpdateCoordinator[None]):

        try:
            await self.account.get_vehicles()
+        except MyBMWCaptchaMissingError as err:
+            # If a captcha is required (user/password login flow), always trigger the reauth flow
+            raise ConfigEntryAuthFailed(
+                translation_domain=DOMAIN,
+                translation_key="missing_captcha",
+            ) from err
        except MyBMWAuthError as err:
            # Allow one retry interval before raising AuthFailed to avoid flaky API issues
            if self.last_update_success:
--- a/homeassistant/components/bmw_connected_drive/manifest.json
+++ b/homeassistant/components/bmw_connected_drive/manifest.json
@ -7,5 +7,5 @@
  "iot_class": "cloud_polling",
  "loggers": ["bimmer_connected"],
  "quality_scale": "platinum",
-  "requirements": ["bimmer-connected[china]==0.16.3"]
+  "requirements": ["bimmer-connected[china]==0.16.4"]
 }
--- a/homeassistant/components/bmw_connected_drive/strings.json
+++ b/homeassistant/components/bmw_connected_drive/strings.json
@ -11,7 +11,8 @@
    },
    "error": {
      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
-      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]"
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "missing_captcha": "Captcha validation missing"
    },
    "abort": {
      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
@ -200,6 +201,9 @@
  "exceptions": {
    "invalid_poi": {
      "message": "Invalid data for point of interest: {poi_exception}"
+    },
+    "missing_captcha": {
+      "message": "Login requires captcha validation"
    }
  }
 }
--- a/homeassistant/components/bring/icons.json
+++ b/homeassistant/components/bring/icons.json
@ -16,7 +16,8 @@
      "list_access": {
        "default": "mdi:account-lock",
        "state": {
-          "shared": "mdi:account-group"
+          "shared": "mdi:account-group",
+          "invitation": "mdi:account-multiple-plus"
        }
      }
    },
--- a/homeassistant/components/bring/manifest.json
+++ b/homeassistant/components/bring/manifest.json
@ -6,5 +6,5 @@
  "documentation": "https://www.home-assistant.io/integrations/bring",
  "integration_type": "service",
  "iot_class": "cloud_polling",
-  "requirements": ["bring-api==0.9.0"]
+  "requirements": ["bring-api==0.9.1"]
 }
--- a/homeassistant/components/bring/sensor.py
+++ b/homeassistant/components/bring/sensor.py
@ -79,7 +79,7 @@ SENSOR_DESCRIPTIONS: tuple[BringSensorEntityDescription, ...] = (
        translation_key=BringSensor.LIST_ACCESS,
        value_fn=lambda lst, _: lst["status"].lower(),
        entity_category=EntityCategory.DIAGNOSTIC,
-        options=["registered", "shared"],
+        options=["registered", "shared", "invitation"],
        device_class=SensorDeviceClass.ENUM,
    ),
 )
--- a/homeassistant/components/bring/strings.json
+++ b/homeassistant/components/bring/strings.json
@ -66,7 +66,8 @@
        "name": "List access",
        "state": {
          "registered": "Private",
-          "shared": "Shared"
+          "shared": "Shared",
+          "invitation": "Invitation pending"
        }
      }
    }
--- a/homeassistant/components/bsblan/manifest.json
+++ b/homeassistant/components/bsblan/manifest.json
@ -7,5 +7,5 @@
  "integration_type": "device",
  "iot_class": "local_polling",
  "loggers": ["bsblan"],
-  "requirements": ["python-bsblan==1.0.0"]
+  "requirements": ["python-bsblan==1.2.1"]
 }
--- a/homeassistant/components/caldav/calendar.py
+++ b/homeassistant/components/caldav/calendar.py
@ -109,6 +109,7 @@ async def async_setup_platform(
            entity_id = async_generate_entity_id(ENTITY_ID_FORMAT, device_id, hass=hass)
            coordinator = CalDavUpdateCoordinator(
                hass,
+                None,
                calendar=calendar,
                days=days,
                include_all_day=True,
@ -126,6 +127,7 @@ async def async_setup_platform(
            entity_id = async_generate_entity_id(ENTITY_ID_FORMAT, device_id, hass=hass)
            coordinator = CalDavUpdateCoordinator(
                hass,
+                None,
                calendar=calendar,
                days=days,
                include_all_day=False,
@ -152,6 +154,7 @@ async def async_setup_entry(
                async_generate_entity_id(ENTITY_ID_FORMAT, calendar.name, hass=hass),
                CalDavUpdateCoordinator(
                    hass,
+                    entry,
                    calendar=calendar,
                    days=CONFIG_ENTRY_DEFAULT_DAYS,
                    include_all_day=True,
@ -204,7 +207,8 @@ class WebDavCalendarEntity(CoordinatorEntity[CalDavUpdateCoordinator], CalendarE
        if self._supports_offset:
            self._attr_extra_state_attributes = {
                "offset_reached": is_offset_reached(
-                    self._event.start_datetime_local, self.coordinator.offset
+                    self._event.start_datetime_local,
+                    self.coordinator.offset,  # type: ignore[arg-type]
                )
                if self._event
                else False
--- a/homeassistant/components/caldav/coordinator.py
+++ b/homeassistant/components/caldav/coordinator.py
@ -6,6 +6,9 @@ from datetime import date, datetime, time, timedelta
 from functools import partial
 import logging
 import re
+from typing import TYPE_CHECKING
+
+import caldav

 from homeassistant.components.calendar import CalendarEvent, extract_offset
 from homeassistant.core import HomeAssistant
@ -14,6 +17,9 @@ from homeassistant.util import dt as dt_util

 from .api import get_attr_value

+if TYPE_CHECKING:
+    from . import CalDavConfigEntry
+
 _LOGGER = logging.getLogger(__name__)

 MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=15)
@ -23,11 +29,20 @@ OFFSET = "!!"
 class CalDavUpdateCoordinator(DataUpdateCoordinator[CalendarEvent | None]):
    """Class to utilize the calendar dav client object to get next event."""

-    def __init__(self, hass, calendar, days, include_all_day, search):
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        entry: CalDavConfigEntry | None,
+        calendar: caldav.Calendar,
+        days: int,
+        include_all_day: bool,
+        search: str | None,
+    ) -> None:
        """Set up how we are going to search the WebDav calendar."""
        super().__init__(
            hass,
            _LOGGER,
+            config_entry=entry,
            name=f"CalDAV {calendar.name}",
            update_interval=MIN_TIME_BETWEEN_UPDATES,
        )
@ -35,7 +50,7 @@ class CalDavUpdateCoordinator(DataUpdateCoordinator[CalendarEvent | None]):
        self.days = days
        self.include_all_day = include_all_day
        self.search = search
-        self.offset = None
+        self.offset: timedelta | None = None

    async def async_get_events(
        self, hass: HomeAssistant, start_date: datetime, end_date: datetime
@ -109,7 +124,7 @@ class CalDavUpdateCoordinator(DataUpdateCoordinator[CalendarEvent | None]):
                    _start_of_tomorrow = start_of_tomorrow
                if _start_of_today <= start_dt < _start_of_tomorrow:
                    new_event = event.copy()
-                    new_vevent = new_event.instance.vevent
+                    new_vevent = new_event.instance.vevent  # type: ignore[attr-defined]
                    if hasattr(new_vevent, "dtend"):
                        dur = new_vevent.dtend.value - new_vevent.dtstart.value
                        new_vevent.dtend.value = start_dt + dur
--- a/homeassistant/components/cambridge_audio/manifest.json
+++ b/homeassistant/components/cambridge_audio/manifest.json
@ -7,6 +7,6 @@
  "integration_type": "device",
  "iot_class": "local_push",
  "loggers": ["aiostreammagic"],
-  "requirements": ["aiostreammagic==2.8.4"],
+  "requirements": ["aiostreammagic==2.8.5"],
  "zeroconf": ["_stream-magic._tcp.local.", "_smoip._tcp.local."]
 }
--- a/homeassistant/components/cambridge_audio/select.py
+++ b/homeassistant/components/cambridge_audio/select.py
@ -51,8 +51,13 @@ CONTROL_ENTITIES: tuple[CambridgeAudioSelectEntityDescription, ...] = (
    CambridgeAudioSelectEntityDescription(
        key="display_brightness",
        translation_key="display_brightness",
-        options=[x.value for x in DisplayBrightness],
+        options=[
+            DisplayBrightness.BRIGHT.value,
+            DisplayBrightness.DIM.value,
+            DisplayBrightness.OFF.value,
+        ],
        entity_category=EntityCategory.CONFIG,
+        load_fn=lambda client: client.display.brightness != DisplayBrightness.NONE,
        value_fn=lambda client: client.display.brightness,
        set_value_fn=lambda client, value: client.set_display_brightness(
            DisplayBrightness(value)
--- a/homeassistant/components/camera/init.py
+++ b/homeassistant/components/camera/init.py
@ -20,7 +20,7 @@ from aiohttp import hdrs, web
 import attr
 from propcache import cached_property, under_cached_property
 import voluptuous as vol
-from webrtc_models import RTCIceServer
+from webrtc_models import RTCIceCandidate, RTCIceServer

 from homeassistant.components import websocket_api
 from homeassistant.components.http import KEY_AUTHENTICATED, HomeAssistantView
@ -421,8 +421,12 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
        if hass.config.webrtc.ice_servers:
            return hass.config.webrtc.ice_servers
        return [
-            RTCIceServer(urls="stun:stun.home-assistant.io:80"),
-            RTCIceServer(urls="stun:stun.home-assistant.io:3478"),
+            RTCIceServer(
+                urls=[
+                    "stun:stun.home-assistant.io:80",
+                    "stun:stun.home-assistant.io:3478",
+                ]
+            ),
        ]

    async_register_ice_servers(hass, get_ice_servers)
@ -472,6 +476,8 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
    _attr_state: None = None  # State is determined by is_on
    _attr_supported_features: CameraEntityFeature = CameraEntityFeature(0)

+    __supports_stream: CameraEntityFeature | None = None
+
    def __init__(self) -> None:
        """Initialize a camera."""
        self._cache: dict[str, Any] = {}
@ -484,9 +490,13 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
        self._create_stream_lock: asyncio.Lock | None = None
        self._webrtc_provider: CameraWebRTCProvider | None = None
        self._legacy_webrtc_provider: CameraWebRTCLegacyProvider | None = None
-        self._webrtc_sync_offer = (
+        self._supports_native_sync_webrtc = (
            type(self).async_handle_web_rtc_offer != Camera.async_handle_web_rtc_offer
        )
+        self._supports_native_async_webrtc = (
+            type(self).async_handle_async_webrtc_offer
+            != Camera.async_handle_async_webrtc_offer
+        )

    @cached_property
    def entity_picture(self) -> str:
@ -623,7 +633,7 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):

        Integrations can override with a native WebRTC implementation.
        """
-        if self._webrtc_sync_offer:
+        if self._supports_native_sync_webrtc:
            try:
                answer = await self.async_handle_web_rtc_offer(offer_sdp)
            except ValueError as ex:
@ -779,6 +789,9 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
    async def async_internal_added_to_hass(self) -> None:
        """Run when entity about to be added to hass."""
        await super().async_internal_added_to_hass()
+        self.__supports_stream = (
+            self.supported_features_compat & CameraEntityFeature.STREAM
+        )
        await self.async_refresh_providers(write_state=False)

    async def async_refresh_providers(self, *, write_state: bool = True) -> None:
@ -788,12 +801,19 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
        providers or inputs to the state attributes change.
        """
        old_provider = self._webrtc_provider
+        old_legacy_provider = self._legacy_webrtc_provider
+        new_provider = None
+        new_legacy_provider = None
+
+        # Skip all providers if the camera has a native WebRTC implementation
+        if not (
+            self._supports_native_sync_webrtc or self._supports_native_async_webrtc
+        ):
+            # Camera doesn't have a native WebRTC implementation
            new_provider = await self._async_get_supported_webrtc_provider(
                async_get_supported_provider
            )

-        old_legacy_provider = self._legacy_webrtc_provider
-        new_legacy_provider = None
            if new_provider is None:
                # Only add the legacy provider if the new provider is not available
                new_legacy_provider = await self._async_get_supported_webrtc_provider(
@ -827,6 +847,9 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
        """Return the WebRTC client configuration and extend it with the registered ice servers."""
        config = self._async_get_webrtc_client_configuration()

+        if not self._supports_native_sync_webrtc:
+            # Until 2024.11, the frontend was not resolving any ice servers
+            # The async approach was added 2024.11 and new integrations need to use it
            ice_servers = [
                server
                for servers in self.hass.data.get(DATA_ICE_SERVERS, [])
@ -835,12 +858,15 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
            config.configuration.ice_servers.extend(ice_servers)

        config.get_candidates_upfront = (
-            self._webrtc_sync_offer or self._legacy_webrtc_provider is not None
+            self._supports_native_sync_webrtc
+            or self._legacy_webrtc_provider is not None
        )

        return config

-    async def async_on_webrtc_candidate(self, session_id: str, candidate: str) -> None:
+    async def async_on_webrtc_candidate(
+        self, session_id: str, candidate: RTCIceCandidate
+    ) -> None:
        """Handle a WebRTC candidate."""
        if self._webrtc_provider:
            await self._webrtc_provider.async_on_webrtc_candidate(session_id, candidate)
@ -864,12 +890,7 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
        """Return the camera capabilities."""
        frontend_stream_types = set()
        if CameraEntityFeature.STREAM in self.supported_features_compat:
-            if (
-                type(self).async_handle_web_rtc_offer
-                != Camera.async_handle_web_rtc_offer
-                or type(self).async_handle_async_webrtc_offer
-                != Camera.async_handle_async_webrtc_offer
-            ):
+            if self._supports_native_sync_webrtc or self._supports_native_async_webrtc:
                # The camera has a native WebRTC implementation
                frontend_stream_types.add(StreamType.WEB_RTC)
            else:
@ -880,6 +901,21 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):

        return CameraCapabilities(frontend_stream_types)

+    @callback
+    def async_write_ha_state(self) -> None:
+        """Write the state to the state machine.
+
+        Schedules async_refresh_providers if support of streams have changed.
+        """
+        super().async_write_ha_state()
+        if self.__supports_stream != (
+            supports_stream := self.supported_features_compat
+            & CameraEntityFeature.STREAM
+        ):
+            self.__supports_stream = supports_stream
+            self._invalidate_camera_capabilities_cache()
+            self.hass.async_create_task(self.async_refresh_providers())
+

 class CameraView(HomeAssistantView):
    """Base CameraView."""
--- a/homeassistant/components/camera/webrtc.py
+++ b/homeassistant/components/camera/webrtc.py
@ -6,12 +6,12 @@ from abc import ABC, abstractmethod
 import asyncio
 from collections.abc import Awaitable, Callable, Iterable
 from dataclasses import asdict, dataclass, field
-from functools import cache, partial
+from functools import cache, partial, wraps
 import logging
 from typing import TYPE_CHECKING, Any, Protocol

 import voluptuous as vol
-from webrtc_models import RTCConfiguration, RTCIceServer
+from webrtc_models import RTCConfiguration, RTCIceCandidate, RTCIceServer

 from homeassistant.components import websocket_api
 from homeassistant.core import HomeAssistant, callback
@ -78,7 +78,14 @@ class WebRTCAnswer(WebRTCMessage):
 class WebRTCCandidate(WebRTCMessage):
    """WebRTC candidate."""

-    candidate: str
+    candidate: RTCIceCandidate
+
+    def as_dict(self) -> dict[str, Any]:
+        """Return a dict representation of the message."""
+        return {
+            "type": self._get_type(),
+            "candidate": self.candidate.candidate,
+        }


@dataclass(frozen=True)
@ -138,7 +145,9 @@ class CameraWebRTCProvider(ABC):
        """Handle the WebRTC offer and return the answer via the provided callback."""

    @abstractmethod
-    async def async_on_webrtc_candidate(self, session_id: str, candidate: str) -> None:
+    async def async_on_webrtc_candidate(
+        self, session_id: str, candidate: RTCIceCandidate
+    ) -> None:
        """Handle the WebRTC candidate."""

    @callback
@ -196,6 +205,49 @@ async def _async_refresh_providers(hass: HomeAssistant) -> None:
    )


+type WsCommandWithCamera = Callable[
+    [websocket_api.ActiveConnection, dict[str, Any], Camera],
+    Awaitable[None],
+]
+
+
+def require_webrtc_support(
+    error_code: str,
+) -> Callable[[WsCommandWithCamera], websocket_api.AsyncWebSocketCommandHandler]:
+    """Validate that the camera supports WebRTC."""
+
+    def decorate(
+        func: WsCommandWithCamera,
+    ) -> websocket_api.AsyncWebSocketCommandHandler:
+        """Decorate func."""
+
+        @wraps(func)
+        async def validate(
+            hass: HomeAssistant,
+            connection: websocket_api.ActiveConnection,
+            msg: dict[str, Any],
+        ) -> None:
+            """Validate that the camera supports WebRTC."""
+            entity_id = msg["entity_id"]
+            camera = get_camera_from_entity_id(hass, entity_id)
+            if camera.frontend_stream_type != StreamType.WEB_RTC:
+                connection.send_error(
+                    msg["id"],
+                    error_code,
+                    (
+                        "Camera does not support WebRTC,"
+                        f" frontend_stream_type={camera.frontend_stream_type}"
+                    ),
+                )
+                return
+
+            await func(connection, msg, camera)
+
+        return validate
+
+    return decorate
+
+
@websocket_api.websocket_command(
    {
        vol.Required("type"): "camera/webrtc/offer",
@ -204,8 +256,9 @@ async def _async_refresh_providers(hass: HomeAssistant) -> None:
    }
 )
@websocket_api.async_response
+@require_webrtc_support("webrtc_offer_failed")
 async def ws_webrtc_offer(
-    hass: HomeAssistant, connection: websocket_api.ActiveConnection, msg: dict[str, Any]
+    connection: websocket_api.ActiveConnection, msg: dict[str, Any], camera: Camera
 ) -> None:
    """Handle the signal path for a WebRTC stream.

@ -217,20 +270,7 @@ async def ws_webrtc_offer(

    Async friendly.
    """
-    entity_id = msg["entity_id"]
    offer = msg["offer"]
-    camera = get_camera_from_entity_id(hass, entity_id)
-    if camera.frontend_stream_type != StreamType.WEB_RTC:
-        connection.send_error(
-            msg["id"],
-            "webrtc_offer_failed",
-            (
-                "Camera does not support WebRTC,"
-                f" frontend_stream_type={camera.frontend_stream_type}"
-            ),
-        )
-        return
-
    session_id = ulid()
    connection.subscriptions[msg["id"]] = partial(
        camera.close_webrtc_session, session_id
@ -269,23 +309,11 @@ async def ws_webrtc_offer(
    }
 )
@websocket_api.async_response
+@require_webrtc_support("webrtc_get_client_config_failed")
 async def ws_get_client_config(
-    hass: HomeAssistant, connection: websocket_api.ActiveConnection, msg: dict[str, Any]
+    connection: websocket_api.ActiveConnection, msg: dict[str, Any], camera: Camera
 ) -> None:
    """Handle get WebRTC client config websocket command."""
-    entity_id = msg["entity_id"]
-    camera = get_camera_from_entity_id(hass, entity_id)
-    if camera.frontend_stream_type != StreamType.WEB_RTC:
-        connection.send_error(
-            msg["id"],
-            "webrtc_get_client_config_failed",
-            (
-                "Camera does not support WebRTC,"
-                f" frontend_stream_type={camera.frontend_stream_type}"
-            ),
-        )
-        return
-
    config = camera.async_get_webrtc_client_configuration().to_frontend_dict()
    connection.send_result(
        msg["id"],
@ -302,24 +330,14 @@ async def ws_get_client_config(
    }
 )
@websocket_api.async_response
+@require_webrtc_support("webrtc_candidate_failed")
 async def ws_candidate(
-    hass: HomeAssistant, connection: websocket_api.ActiveConnection, msg: dict[str, Any]
+    connection: websocket_api.ActiveConnection, msg: dict[str, Any], camera: Camera
 ) -> None:
    """Handle WebRTC candidate websocket command."""
-    entity_id = msg["entity_id"]
-    camera = get_camera_from_entity_id(hass, entity_id)
-    if camera.frontend_stream_type != StreamType.WEB_RTC:
-        connection.send_error(
-            msg["id"],
-            "webrtc_candidate_failed",
-            (
-                "Camera does not support WebRTC,"
-                f" frontend_stream_type={camera.frontend_stream_type}"
-            ),
+    await camera.async_on_webrtc_candidate(
+        msg["session_id"], RTCIceCandidate(msg["candidate"])
    )
-        return
-
-    await camera.async_on_webrtc_candidate(msg["session_id"], msg["candidate"])
    connection.send_message(websocket_api.result_message(msg["id"]))


--- a/homeassistant/components/cast/config_flow.py
+++ b/homeassistant/components/cast/config_flow.py
@ -41,7 +41,7 @@ class FlowHandler(ConfigFlow, domain=DOMAIN):
        config_entry: ConfigEntry,
    ) -> CastOptionsFlowHandler:
        """Get the options flow for this handler."""
-        return CastOptionsFlowHandler(config_entry)
+        return CastOptionsFlowHandler()

    async def async_step_user(
        self, user_input: dict[str, Any] | None = None
@ -109,9 +109,8 @@ class FlowHandler(ConfigFlow, domain=DOMAIN):
 class CastOptionsFlowHandler(OptionsFlow):
    """Handle Google Cast options."""

-    def __init__(self, config_entry: ConfigEntry) -> None:
+    def __init__(self) -> None:
        """Initialize Google Cast options flow."""
-        self.config_entry = config_entry
        self.updated_config: dict[str, Any] = {}

    async def async_step_init(self, user_input: None = None) -> ConfigFlowResult:
--- a/homeassistant/components/cloud/http_api.py
+++ b/homeassistant/components/cloud/http_api.py
@ -440,16 +440,16 @@ def validate_language_voice(value: tuple[str, str]) -> tuple[str, str]:
@websocket_api.websocket_command(
    {
        vol.Required("type"): "cloud/update_prefs",
-        vol.Optional(PREF_ENABLE_GOOGLE): bool,
-        vol.Optional(PREF_ENABLE_ALEXA): bool,
        vol.Optional(PREF_ALEXA_REPORT_STATE): bool,
+        vol.Optional(PREF_ENABLE_ALEXA): bool,
+        vol.Optional(PREF_ENABLE_CLOUD_ICE_SERVERS): bool,
+        vol.Optional(PREF_ENABLE_GOOGLE): bool,
        vol.Optional(PREF_GOOGLE_REPORT_STATE): bool,
        vol.Optional(PREF_GOOGLE_SECURE_DEVICES_PIN): vol.Any(None, str),
+        vol.Optional(PREF_REMOTE_ALLOW_REMOTE_ENABLE): bool,
        vol.Optional(PREF_TTS_DEFAULT_VOICE): vol.All(
            vol.Coerce(tuple), validate_language_voice
        ),
-        vol.Optional(PREF_REMOTE_ALLOW_REMOTE_ENABLE): bool,
-        vol.Optional(PREF_ENABLE_CLOUD_ICE_SERVERS): bool,
    }
 )
@websocket_api.async_response
--- a/homeassistant/components/cloud/manifest.json
+++ b/homeassistant/components/cloud/manifest.json
@ -8,6 +8,6 @@
  "integration_type": "system",
  "iot_class": "cloud_push",
  "loggers": ["hass_nabucasa"],
-  "requirements": ["hass-nabucasa==0.83.0"],
+  "requirements": ["hass-nabucasa==0.84.0"],
  "single_config_entry": true
 }
--- a/homeassistant/components/cloud/prefs.py
+++ b/homeassistant/components/cloud/prefs.py
@ -163,21 +163,21 @@ class CloudPreferences:
    async def async_update(
        self,
        *,
-        google_enabled: bool | UndefinedType = UNDEFINED,
        alexa_enabled: bool | UndefinedType = UNDEFINED,
-        remote_enabled: bool | UndefinedType = UNDEFINED,
-        google_secure_devices_pin: str | None | UndefinedType = UNDEFINED,
-        cloudhooks: dict[str, dict[str, str | bool]] | UndefinedType = UNDEFINED,
-        cloud_user: str | UndefinedType = UNDEFINED,
        alexa_report_state: bool | UndefinedType = UNDEFINED,
-        google_report_state: bool | UndefinedType = UNDEFINED,
-        tts_default_voice: tuple[str, str] | UndefinedType = UNDEFINED,
-        remote_domain: str | None | UndefinedType = UNDEFINED,
        alexa_settings_version: int | UndefinedType = UNDEFINED,
-        google_settings_version: int | UndefinedType = UNDEFINED,
-        google_connected: bool | UndefinedType = UNDEFINED,
-        remote_allow_remote_enable: bool | UndefinedType = UNDEFINED,
        cloud_ice_servers_enabled: bool | UndefinedType = UNDEFINED,
+        cloud_user: str | UndefinedType = UNDEFINED,
+        cloudhooks: dict[str, dict[str, str | bool]] | UndefinedType = UNDEFINED,
+        google_connected: bool | UndefinedType = UNDEFINED,
+        google_enabled: bool | UndefinedType = UNDEFINED,
+        google_report_state: bool | UndefinedType = UNDEFINED,
+        google_secure_devices_pin: str | None | UndefinedType = UNDEFINED,
+        google_settings_version: int | UndefinedType = UNDEFINED,
+        remote_allow_remote_enable: bool | UndefinedType = UNDEFINED,
+        remote_domain: str | None | UndefinedType = UNDEFINED,
+        remote_enabled: bool | UndefinedType = UNDEFINED,
+        tts_default_voice: tuple[str, str] | UndefinedType = UNDEFINED,
    ) -> None:
        """Update user preferences."""
        prefs = {**self._prefs}
@ -186,21 +186,21 @@ class CloudPreferences:
            {
                key: value
                for key, value in (
-                    (PREF_ENABLE_GOOGLE, google_enabled),
-                    (PREF_ENABLE_ALEXA, alexa_enabled),
-                    (PREF_ENABLE_REMOTE, remote_enabled),
-                    (PREF_GOOGLE_SECURE_DEVICES_PIN, google_secure_devices_pin),
-                    (PREF_CLOUDHOOKS, cloudhooks),
-                    (PREF_CLOUD_USER, cloud_user),
                    (PREF_ALEXA_REPORT_STATE, alexa_report_state),
-                    (PREF_GOOGLE_REPORT_STATE, google_report_state),
                    (PREF_ALEXA_SETTINGS_VERSION, alexa_settings_version),
-                    (PREF_GOOGLE_SETTINGS_VERSION, google_settings_version),
-                    (PREF_TTS_DEFAULT_VOICE, tts_default_voice),
-                    (PREF_REMOTE_DOMAIN, remote_domain),
-                    (PREF_GOOGLE_CONNECTED, google_connected),
-                    (PREF_REMOTE_ALLOW_REMOTE_ENABLE, remote_allow_remote_enable),
+                    (PREF_CLOUD_USER, cloud_user),
+                    (PREF_CLOUDHOOKS, cloudhooks),
+                    (PREF_ENABLE_ALEXA, alexa_enabled),
                    (PREF_ENABLE_CLOUD_ICE_SERVERS, cloud_ice_servers_enabled),
+                    (PREF_ENABLE_GOOGLE, google_enabled),
+                    (PREF_ENABLE_REMOTE, remote_enabled),
+                    (PREF_GOOGLE_CONNECTED, google_connected),
+                    (PREF_GOOGLE_REPORT_STATE, google_report_state),
+                    (PREF_GOOGLE_SECURE_DEVICES_PIN, google_secure_devices_pin),
+                    (PREF_GOOGLE_SETTINGS_VERSION, google_settings_version),
+                    (PREF_REMOTE_ALLOW_REMOTE_ENABLE, remote_allow_remote_enable),
+                    (PREF_REMOTE_DOMAIN, remote_domain),
+                    (PREF_TTS_DEFAULT_VOICE, tts_default_voice),
                )
                if value is not UNDEFINED
            }
@ -242,6 +242,7 @@ class CloudPreferences:
            PREF_ALEXA_REPORT_STATE: self.alexa_report_state,
            PREF_CLOUDHOOKS: self.cloudhooks,
            PREF_ENABLE_ALEXA: self.alexa_enabled,
+            PREF_ENABLE_CLOUD_ICE_SERVERS: self.cloud_ice_servers_enabled,
            PREF_ENABLE_GOOGLE: self.google_enabled,
            PREF_ENABLE_REMOTE: self.remote_enabled,
            PREF_GOOGLE_DEFAULT_EXPOSE: self.google_default_expose,
@ -249,7 +250,6 @@ class CloudPreferences:
            PREF_GOOGLE_SECURE_DEVICES_PIN: self.google_secure_devices_pin,
            PREF_REMOTE_ALLOW_REMOTE_ENABLE: self.remote_allow_remote_enable,
            PREF_TTS_DEFAULT_VOICE: self.tts_default_voice,
-            PREF_ENABLE_CLOUD_ICE_SERVERS: self.cloud_ice_servers_enabled,
        }

    @property
--- a/homeassistant/components/co2signal/config_flow.py
+++ b/homeassistant/components/co2signal/config_flow.py
@ -168,7 +168,7 @@ class ElectricityMapsConfigFlow(ConfigFlow, domain=DOMAIN):
                    )

                return self.async_create_entry(
-                    title=get_extra_name(data) or "CO2 Signal",
+                    title=get_extra_name(data) or "Electricity Maps",
                    data=data,
                )

--- a/homeassistant/components/compensation/manifest.json
+++ b/homeassistant/components/compensation/manifest.json
@ -4,5 +4,5 @@
  "codeowners": ["@Petro31"],
  "documentation": "https://www.home-assistant.io/integrations/compensation",
  "iot_class": "calculated",
-  "requirements": ["numpy==1.26.4"]
+  "requirements": ["numpy==2.1.3"]
 }
--- a/homeassistant/components/conversation/default_agent.py
+++ b/homeassistant/components/conversation/default_agent.py
@ -16,11 +16,11 @@ from hassil.expression import Expression, ListReference, Sequence
 from hassil.intents import Intents, SlotList, TextSlotList, WildcardSlotList
 from hassil.recognize import (
    MISSING_ENTITY,
-    MatchEntity,
    RecognizeResult,
-    UnmatchedTextEntity,
    recognize_all,
+    recognize_best,
 )
+from hassil.string_matcher import UnmatchedRangeEntity, UnmatchedTextEntity
 from hassil.util import merge_dict
 from home_assistant_intents import ErrorKey, get_intents, get_languages
 import yaml
@ -294,7 +294,7 @@ class DefaultAgent(ConversationEntity):
                    self.hass, language, DOMAIN, [DOMAIN]
                )
                response_text = translations.get(
-                    f"component.{DOMAIN}.agent.done", "Done"
+                    f"component.{DOMAIN}.conversation.agent.done", "Done"
                )

            response.async_set_speech(response_text)
@ -499,6 +499,7 @@ class DefaultAgent(ConversationEntity):
        maybe_result: RecognizeResult | None = None
        best_num_matched_entities = 0
        best_num_unmatched_entities = 0
+        best_num_unmatched_ranges = 0
        for result in recognize_all(
            user_input.text,
            lang_intents.intents,
@ -517,10 +518,14 @@ class DefaultAgent(ConversationEntity):
                    num_matched_entities += 1

            num_unmatched_entities = 0
+            num_unmatched_ranges = 0
            for unmatched_entity in result.unmatched_entities_list:
                if isinstance(unmatched_entity, UnmatchedTextEntity):
                    if unmatched_entity.text != MISSING_ENTITY:
                        num_unmatched_entities += 1
+                elif isinstance(unmatched_entity, UnmatchedRangeEntity):
+                    num_unmatched_ranges += 1
+                    num_unmatched_entities += 1
                else:
                    num_unmatched_entities += 1

@ -532,15 +537,24 @@ class DefaultAgent(ConversationEntity):
                    (num_matched_entities == best_num_matched_entities)
                    and (num_unmatched_entities < best_num_unmatched_entities)
                )
+                or (
+                    # Prefer unmatched ranges
+                    (num_matched_entities == best_num_matched_entities)
+                    and (num_unmatched_entities == best_num_unmatched_entities)
+                    and (num_unmatched_ranges > best_num_unmatched_ranges)
+                )
                or (
                    # More literal text matched
                    (num_matched_entities == best_num_matched_entities)
                    and (num_unmatched_entities == best_num_unmatched_entities)
+                    and (num_unmatched_ranges == best_num_unmatched_ranges)
                    and (result.text_chunks_matched > maybe_result.text_chunks_matched)
                )
                or (
                    # Prefer match failures with entities
                    (result.text_chunks_matched == maybe_result.text_chunks_matched)
+                    and (num_unmatched_entities == best_num_unmatched_entities)
+                    and (num_unmatched_ranges == best_num_unmatched_ranges)
                    and (
                        ("name" in result.entities)
                        or ("name" in result.unmatched_entities)
@ -550,6 +564,7 @@ class DefaultAgent(ConversationEntity):
                maybe_result = result
                best_num_matched_entities = num_matched_entities
                best_num_unmatched_entities = num_unmatched_entities
+                best_num_unmatched_ranges = num_unmatched_ranges

        return maybe_result

@ -562,77 +577,16 @@ class DefaultAgent(ConversationEntity):
        language: str,
    ) -> RecognizeResult | None:
        """Search intents for a strict match to user input."""
-        custom_found = False
-        name_found = False
-        best_results: list[RecognizeResult] = []
-        best_name_quality: int | None = None
-        best_text_chunks_matched: int | None = None
-        for result in recognize_all(
+        return recognize_best(
            user_input.text,
            lang_intents.intents,
            slot_lists=slot_lists,
            intent_context=intent_context,
            language=language,
-        ):
-            # Prioritize user intents
-            is_custom = (
-                result.intent_metadata is not None
-                and result.intent_metadata.get(METADATA_CUSTOM_SENTENCE)
+            best_metadata_key=METADATA_CUSTOM_SENTENCE,
+            best_slot_name="name",
        )

-            if custom_found and not is_custom:
-                continue
-
-            if not custom_found and is_custom:
-                custom_found = True
-                # Clear builtin results
-                name_found = False
-                best_results = []
-                best_name_quality = None
-                best_text_chunks_matched = None
-
-            # Prioritize results with a "name" slot
-            name = result.entities.get("name")
-            is_name = name and not name.is_wildcard
-
-            if name_found and not is_name:
-                continue
-
-            if not name_found and is_name:
-                name_found = True
-                # Clear non-name results
-                best_results = []
-                best_text_chunks_matched = None
-
-            if is_name:
-                # Prioritize results with a better "name" slot
-                name_quality = len(cast(MatchEntity, name).value.split())
-                if (best_name_quality is None) or (name_quality > best_name_quality):
-                    best_name_quality = name_quality
-                    # Clear worse name results
-                    best_results = []
-                    best_text_chunks_matched = None
-                elif name_quality < best_name_quality:
-                    continue
-
-            # Prioritize results with more literal text
-            # This causes wildcards to match last.
-            if (best_text_chunks_matched is None) or (
-                result.text_chunks_matched > best_text_chunks_matched
-            ):
-                best_results = [result]
-                best_text_chunks_matched = result.text_chunks_matched
-            elif result.text_chunks_matched == best_text_chunks_matched:
-                # Accumulate results with the same number of literal text matched.
-                # We will resolve the ambiguity below.
-                best_results.append(result)
-
-        if best_results:
-            # Successful strict match
-            return best_results[0]
-
-        return None
-
    async def _build_speech(
        self,
        language: str,
--- a/homeassistant/components/conversation/http.py
+++ b/homeassistant/components/conversation/http.py
@ -6,12 +6,8 @@ from collections.abc import Iterable
 from typing import Any

 from aiohttp import web
-from hassil.recognize import (
-    MISSING_ENTITY,
-    RecognizeResult,
-    UnmatchedRangeEntity,
-    UnmatchedTextEntity,
-)
+from hassil.recognize import MISSING_ENTITY, RecognizeResult
+from hassil.string_matcher import UnmatchedRangeEntity, UnmatchedTextEntity
 import voluptuous as vol

 from homeassistant.components import http, websocket_api
--- a/homeassistant/components/conversation/manifest.json
+++ b/homeassistant/components/conversation/manifest.json
@ -6,5 +6,5 @@
  "documentation": "https://www.home-assistant.io/integrations/conversation",
  "integration_type": "system",
  "quality_scale": "internal",
-  "requirements": ["hassil==1.7.4", "home-assistant-intents==2024.10.30"]
+  "requirements": ["hassil==2.0.1", "home-assistant-intents==2024.11.13"]
 }
--- a/homeassistant/components/conversation/trigger.py
+++ b/homeassistant/components/conversation/trigger.py
@ -4,7 +4,8 @@ from __future__ import annotations

 from typing import Any

-from hassil.recognize import PUNCTUATION, RecognizeResult
+from hassil.recognize import RecognizeResult
+from hassil.util import PUNCTUATION_ALL
 import voluptuous as vol

 from homeassistant.const import CONF_COMMAND, CONF_PLATFORM
@ -20,7 +21,7 @@ from .const import DATA_DEFAULT_ENTITY, DOMAIN
 def has_no_punctuation(value: list[str]) -> list[str]:
    """Validate result does not contain punctuation."""
    for sentence in value:
-        if PUNCTUATION.search(sentence):
+        if PUNCTUATION_ALL.search(sentence):
            raise vol.Invalid("sentence should not contain punctuation")

    return value
--- a/homeassistant/components/crownstone/config_flow.py
+++ b/homeassistant/components/crownstone/config_flow.py
@ -213,18 +213,19 @@ class CrownstoneOptionsFlowHandler(BaseCrownstoneFlowHandler, OptionsFlow):
    def __init__(self, config_entry: ConfigEntry) -> None:
        """Initialize Crownstone options."""
        super().__init__(OPTIONS_FLOW, self.async_create_new_entry)
-        self.entry = config_entry
-        self.updated_options = config_entry.options.copy()
+        self.options = config_entry.options.copy()

    async def async_step_init(
        self, user_input: dict[str, Any] | None = None
    ) -> ConfigFlowResult:
        """Manage Crownstone options."""
-        self.cloud: CrownstoneCloud = self.hass.data[DOMAIN][self.entry.entry_id].cloud
+        self.cloud: CrownstoneCloud = self.hass.data[DOMAIN][
+            self.config_entry.entry_id
+        ].cloud

        spheres = {sphere.name: sphere.cloud_id for sphere in self.cloud.cloud_data}
-        usb_path = self.entry.options.get(CONF_USB_PATH)
-        usb_sphere = self.entry.options.get(CONF_USB_SPHERE)
+        usb_path = self.config_entry.options.get(CONF_USB_PATH)
+        usb_sphere = self.config_entry.options.get(CONF_USB_SPHERE)

        options_schema = vol.Schema(
            {vol.Optional(CONF_USE_USB_OPTION, default=usb_path is not None): bool}
@ -243,14 +244,14 @@ class CrownstoneOptionsFlowHandler(BaseCrownstoneFlowHandler, OptionsFlow):
            if user_input[CONF_USE_USB_OPTION] and usb_path is None:
                return await self.async_step_usb_config()
            if not user_input[CONF_USE_USB_OPTION] and usb_path is not None:
-                self.updated_options[CONF_USB_PATH] = None
-                self.updated_options[CONF_USB_SPHERE] = None
+                self.options[CONF_USB_PATH] = None
+                self.options[CONF_USB_SPHERE] = None
            elif (
                CONF_USB_SPHERE_OPTION in user_input
                and spheres[user_input[CONF_USB_SPHERE_OPTION]] != usb_sphere
            ):
                sphere_id = spheres[user_input[CONF_USB_SPHERE_OPTION]]
-                self.updated_options[CONF_USB_SPHERE] = sphere_id
+                self.options[CONF_USB_SPHERE] = sphere_id

            return self.async_create_new_entry()

@ -260,7 +261,7 @@ class CrownstoneOptionsFlowHandler(BaseCrownstoneFlowHandler, OptionsFlow):
        """Create a new entry."""
        # these attributes will only change when a usb was configured
        if self.usb_path is not None and self.usb_sphere_id is not None:
-            self.updated_options[CONF_USB_PATH] = self.usb_path
-            self.updated_options[CONF_USB_SPHERE] = self.usb_sphere_id
+            self.options[CONF_USB_PATH] = self.usb_path
+            self.options[CONF_USB_SPHERE] = self.usb_sphere_id

-        return super().async_create_entry(title="", data=self.updated_options)
+        return super().async_create_entry(title="", data=self.options)
--- a/homeassistant/components/deconz/config_flow.py
+++ b/homeassistant/components/deconz/config_flow.py
@ -74,9 +74,11 @@ class DeconzFlowHandler(ConfigFlow, domain=DOMAIN):

    @staticmethod
    @callback
-    def async_get_options_flow(config_entry: ConfigEntry) -> OptionsFlow:
+    def async_get_options_flow(
+        config_entry: ConfigEntry,
+    ) -> DeconzOptionsFlowHandler:
        """Get the options flow for this handler."""
-        return DeconzOptionsFlowHandler(config_entry)
+        return DeconzOptionsFlowHandler()

    def __init__(self) -> None:
        """Initialize the deCONZ config flow."""
@ -299,11 +301,6 @@ class DeconzOptionsFlowHandler(OptionsFlow):

    gateway: DeconzHub

-    def __init__(self, config_entry: ConfigEntry) -> None:
-        """Initialize deCONZ options flow."""
-        self.config_entry = config_entry
-        self.options = dict(config_entry.options)
-
    async def async_step_init(
        self, user_input: dict[str, Any] | None = None
    ) -> ConfigFlowResult:
@ -315,8 +312,7 @@ class DeconzOptionsFlowHandler(OptionsFlow):
    ) -> ConfigFlowResult:
        """Manage the deconz devices options."""
        if user_input is not None:
-            self.options.update(user_input)
-            return self.async_create_entry(title="", data=self.options)
+            return self.async_create_entry(data=self.config_entry.options | user_input)

        schema_options = {}
        for option, default in (
--- a/homeassistant/components/demo/config_flow.py
+++ b/homeassistant/components/demo/config_flow.py
@ -47,7 +47,6 @@ class OptionsFlowHandler(OptionsFlow):

    def __init__(self, config_entry: ConfigEntry) -> None:
        """Initialize options flow."""
-        self.config_entry = config_entry
        self.options = dict(config_entry.options)

    async def async_step_init(
--- a/homeassistant/components/dnsip/config_flow.py
+++ b/homeassistant/components/dnsip/config_flow.py
@ -14,7 +14,7 @@ from homeassistant.config_entries import (
    ConfigEntry,
    ConfigFlow,
    ConfigFlowResult,
-    OptionsFlowWithConfigEntry,
+    OptionsFlow,
 )
 from homeassistant.const import CONF_NAME, CONF_PORT
 from homeassistant.core import callback
@ -101,7 +101,7 @@ class DnsIPConfigFlow(ConfigFlow, domain=DOMAIN):
        config_entry: ConfigEntry,
    ) -> DnsIPOptionsFlowHandler:
        """Return Option handler."""
-        return DnsIPOptionsFlowHandler(config_entry)
+        return DnsIPOptionsFlowHandler()

    async def async_step_user(
        self, user_input: dict[str, Any] | None = None
@ -165,7 +165,7 @@ class DnsIPConfigFlow(ConfigFlow, domain=DOMAIN):
        )


-class DnsIPOptionsFlowHandler(OptionsFlowWithConfigEntry):
+class DnsIPOptionsFlowHandler(OptionsFlow):
    """Handle a option config flow for dnsip integration."""

    async def async_step_init(
--- a/homeassistant/components/doods/manifest.json
+++ b/homeassistant/components/doods/manifest.json
@ -5,5 +5,5 @@
  "documentation": "https://www.home-assistant.io/integrations/doods",
  "iot_class": "local_polling",
  "loggers": ["pydoods"],
-  "requirements": ["pydoods==1.0.2", "Pillow==10.4.0"]
+  "requirements": ["pydoods==1.0.2", "Pillow==11.0.0"]
 }
--- a/homeassistant/components/doorbird/manifest.json
+++ b/homeassistant/components/doorbird/manifest.json
@ -7,7 +7,7 @@
  "documentation": "https://www.home-assistant.io/integrations/doorbird",
  "iot_class": "local_push",
  "loggers": ["doorbirdpy"],
-  "requirements": ["DoorBirdPy==3.0.7"],
+  "requirements": ["DoorBirdPy==3.0.8"],
  "zeroconf": [
    {
      "type": "_axis-video._tcp.local.",
--- a/homeassistant/components/dsmr/config_flow.py
+++ b/homeassistant/components/dsmr/config_flow.py
@ -171,9 +171,11 @@ class DSMRFlowHandler(ConfigFlow, domain=DOMAIN):

    @staticmethod
    @callback
-    def async_get_options_flow(config_entry: ConfigEntry) -> DSMROptionFlowHandler:
+    def async_get_options_flow(
+        config_entry: ConfigEntry,
+    ) -> DSMROptionFlowHandler:
        """Get the options flow for this handler."""
-        return DSMROptionFlowHandler(config_entry)
+        return DSMROptionFlowHandler()

    async def async_step_user(
        self, user_input: dict[str, Any] | None = None
@ -311,10 +313,6 @@ class DSMRFlowHandler(ConfigFlow, domain=DOMAIN):
 class DSMROptionFlowHandler(OptionsFlow):
    """Handle options."""

-    def __init__(self, entry: ConfigEntry) -> None:
-        """Initialize options flow."""
-        self.entry = entry
-
    async def async_step_init(
        self, user_input: dict[str, Any] | None = None
    ) -> ConfigFlowResult:
@ -328,7 +326,7 @@ class DSMROptionFlowHandler(OptionsFlow):
                {
                    vol.Optional(
                        CONF_TIME_BETWEEN_UPDATE,
-                        default=self.entry.options.get(
+                        default=self.config_entry.options.get(
                            CONF_TIME_BETWEEN_UPDATE, DEFAULT_TIME_BETWEEN_UPDATE
                        ),
                    ): vol.All(vol.Coerce(int), vol.Range(min=0)),
--- a/homeassistant/components/ecobee/number.py
+++ b/homeassistant/components/ecobee/number.py
@ -6,9 +6,14 @@ from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 import logging

-from homeassistant.components.number import NumberEntity, NumberEntityDescription
+from homeassistant.components.number import (
+    NumberDeviceClass,
+    NumberEntity,
+    NumberEntityDescription,
+    NumberMode,
+)
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import UnitOfTime
+from homeassistant.const import UnitOfTemperature, UnitOfTime
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback

@ -54,17 +59,26 @@ async def async_setup_entry(
 ) -> None:
    """Set up the ecobee thermostat number entity."""
    data: EcobeeData = hass.data[DOMAIN]
-    _LOGGER.debug("Adding min time ventilators numbers (if present)")

-    async_add_entities(
-        (
+    assert data is not None
+
+    entities: list[NumberEntity] = [
        EcobeeVentilatorMinTime(data, index, numbers)
        for index, thermostat in enumerate(data.ecobee.thermostats)
        if thermostat["settings"]["ventilatorType"] != "none"
        for numbers in VENTILATOR_NUMBERS
-        ),
-        True,
+    ]
+
+    _LOGGER.debug("Adding compressor min temp number (if present)")
+    entities.extend(
+        (
+            EcobeeCompressorMinTemp(data, index)
+            for index, thermostat in enumerate(data.ecobee.thermostats)
+            if thermostat["settings"]["hasHeatPump"]
        )
+    )
+
+    async_add_entities(entities, True)


 class EcobeeVentilatorMinTime(EcobeeBaseEntity, NumberEntity):
@ -105,3 +119,53 @@ class EcobeeVentilatorMinTime(EcobeeBaseEntity, NumberEntity):
        """Set new ventilator Min On Time value."""
        self.entity_description.set_fn(self.data, self.thermostat_index, int(value))
        self.update_without_throttle = True
+
+
+class EcobeeCompressorMinTemp(EcobeeBaseEntity, NumberEntity):
+    """Minimum outdoor temperature at which the compressor will operate.
+
+    This applies more to air source heat pumps than geothermal. This serves as a safety
+         feature (compressors have a minimum operating temperature) as well as
+        providing the ability to choose fuel in a dual-fuel system (i.e. choose between
+        electrical heat pump and fossil auxiliary heat depending on Time of Use, Solar,
+        etc.).
+        Note that python-ecobee-api refers to this as Aux Cutover Threshold, but Ecobee
+        uses Compressor Protection Min Temp.
+    """
+
+    _attr_device_class = NumberDeviceClass.TEMPERATURE
+    _attr_has_entity_name = True
+    _attr_icon = "mdi:thermometer-off"
+    _attr_mode = NumberMode.BOX
+    _attr_native_min_value = -25
+    _attr_native_max_value = 66
+    _attr_native_step = 5
+    _attr_native_unit_of_measurement = UnitOfTemperature.FAHRENHEIT
+    _attr_translation_key = "compressor_protection_min_temp"
+
+    def __init__(
+        self,
+        data: EcobeeData,
+        thermostat_index: int,
+    ) -> None:
+        """Initialize ecobee compressor min temperature."""
+        super().__init__(data, thermostat_index)
+        self._attr_unique_id = f"{self.base_unique_id}_compressor_protection_min_temp"
+        self.update_without_throttle = False
+
+    async def async_update(self) -> None:
+        """Get the latest state from the thermostat."""
+        if self.update_without_throttle:
+            await self.data.update(no_throttle=True)
+            self.update_without_throttle = False
+        else:
+            await self.data.update()
+
+        self._attr_native_value = (
+            (self.thermostat["settings"]["compressorProtectionMinTemp"]) / 10
+        )
+
+    def set_native_value(self, value: float) -> None:
+        """Set new compressor minimum temperature."""
+        self.data.ecobee.set_aux_cutover_threshold(self.thermostat_index, value)
+        self.update_without_throttle = True
--- a/homeassistant/components/ecobee/strings.json
+++ b/homeassistant/components/ecobee/strings.json
@ -33,15 +33,18 @@
    },
    "number": {
      "ventilator_min_type_home": {
-        "name": "Ventilator min time home"
+        "name": "Ventilator minimum time home"
      },
      "ventilator_min_type_away": {
-        "name": "Ventilator min time away"
+        "name": "Ventilator minimum time away"
+      },
+      "compressor_protection_min_temp": {
+        "name": "Compressor minimum temperature"
      }
    },
    "switch": {
      "aux_heat_only": {
-        "name": "Aux heat only"
+        "name": "Auxiliary heat only"
      }
    }
  },
--- a/homeassistant/components/ecobee/switch.py
+++ b/homeassistant/components/ecobee/switch.py
@ -31,8 +31,7 @@ async def async_setup_entry(
    """Set up the ecobee thermostat switch entity."""
    data: EcobeeData = hass.data[DOMAIN]

-    async_add_entities(
-        [
+    entities: list[SwitchEntity] = [
        EcobeeVentilator20MinSwitch(
            data,
            index,
@ -41,15 +40,17 @@ async def async_setup_entry(
        )
        for index, thermostat in enumerate(data.ecobee.thermostats)
        if thermostat["settings"]["ventilatorType"] != "none"
-        ],
-        update_before_add=True,
-    )
+    ]

-    async_add_entities(
+    entities.extend(
+        (
            EcobeeSwitchAuxHeatOnly(data, index)
            for index, thermostat in enumerate(data.ecobee.thermostats)
            if thermostat["settings"]["hasHeatPump"]
        )
+    )
+
+    async_add_entities(entities, update_before_add=True)


 class EcobeeVentilator20MinSwitch(EcobeeBaseEntity, SwitchEntity):
--- a/homeassistant/components/ecovacs/manifest.json
+++ b/homeassistant/components/ecovacs/manifest.json
@ -6,5 +6,5 @@
  "documentation": "https://www.home-assistant.io/integrations/ecovacs",
  "iot_class": "cloud_push",
  "loggers": ["sleekxmppfs", "sucks", "deebot_client"],
-  "requirements": ["py-sucks==0.9.10", "deebot-client==8.4.0"]
+  "requirements": ["py-sucks==0.9.10", "deebot-client==8.4.1"]
 }
--- a/homeassistant/components/elevenlabs/config_flow.py
+++ b/homeassistant/components/elevenlabs/config_flow.py
@ -14,7 +14,6 @@ from homeassistant.config_entries import (
    ConfigFlow,
    ConfigFlowResult,
    OptionsFlow,
-    OptionsFlowWithConfigEntry,
 )
 from homeassistant.const import CONF_API_KEY
 from homeassistant.core import HomeAssistant
@ -103,13 +102,12 @@ class ElevenLabsConfigFlow(ConfigFlow, domain=DOMAIN):
        return ElevenLabsOptionsFlow(config_entry)


-class ElevenLabsOptionsFlow(OptionsFlowWithConfigEntry):
+class ElevenLabsOptionsFlow(OptionsFlow):
    """ElevenLabs options flow."""

    def __init__(self, config_entry: ConfigEntry) -> None:
        """Initialize options flow."""
-        super().__init__(config_entry)
-        self.api_key: str = self.config_entry.data[CONF_API_KEY]
+        self.api_key: str = config_entry.data[CONF_API_KEY]
        # id -> name
        self.voices: dict[str, str] = {}
        self.models: dict[str, str] = {}
@ -170,7 +168,7 @@ class ElevenLabsOptionsFlow(OptionsFlowWithConfigEntry):
                    vol.Required(CONF_CONFIGURE_VOICE, default=False): bool,
                }
            ),
-            self.options,
+            self.config_entry.options,
        )

    async def async_step_voice_settings(
--- a/homeassistant/components/emoncms/init.py
+++ b/homeassistant/components/emoncms/init.py
@ -5,8 +5,11 @@ from pyemoncms import EmoncmsClient
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_API_KEY, CONF_URL, Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.issue_registry import IssueSeverity, async_create_issue

+from .const import DOMAIN, EMONCMS_UUID_DOC_URL, LOGGER
 from .coordinator import EmoncmsCoordinator

 PLATFORMS: list[Platform] = [Platform.SENSOR]
@ -14,6 +17,49 @@ PLATFORMS: list[Platform] = [Platform.SENSOR]
 type EmonCMSConfigEntry = ConfigEntry[EmoncmsCoordinator]


+def _migrate_unique_id(
+    hass: HomeAssistant, entry: EmonCMSConfigEntry, emoncms_unique_id: str
+) -> None:
+    """Migrate to emoncms unique id if needed."""
+    ent_reg = er.async_get(hass)
+    entry_entities = ent_reg.entities.get_entries_for_config_entry_id(entry.entry_id)
+    for entity in entry_entities:
+        if entity.unique_id.split("-")[0] == entry.entry_id:
+            feed_id = entity.unique_id.split("-")[-1]
+            LOGGER.debug(f"moving feed {feed_id} to hardware uuid")
+            ent_reg.async_update_entity(
+                entity.entity_id, new_unique_id=f"{emoncms_unique_id}-{feed_id}"
+            )
+    hass.config_entries.async_update_entry(
+        entry,
+        unique_id=emoncms_unique_id,
+    )
+
+
+async def _check_unique_id_migration(
+    hass: HomeAssistant, entry: EmonCMSConfigEntry, emoncms_client: EmoncmsClient
+) -> None:
+    """Check if we can migrate to the emoncms uuid."""
+    emoncms_unique_id = await emoncms_client.async_get_uuid()
+    if emoncms_unique_id:
+        if entry.unique_id != emoncms_unique_id:
+            _migrate_unique_id(hass, entry, emoncms_unique_id)
+    else:
+        async_create_issue(
+            hass,
+            DOMAIN,
+            "migrate database",
+            is_fixable=False,
+            issue_domain=DOMAIN,
+            severity=IssueSeverity.WARNING,
+            translation_key="migrate_database",
+            translation_placeholders={
+                "url": entry.data[CONF_URL],
+                "doc_url": EMONCMS_UUID_DOC_URL,
+            },
+        )
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: EmonCMSConfigEntry) -> bool:
    """Load a config entry."""
    emoncms_client = EmoncmsClient(
@ -21,6 +67,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: EmonCMSConfigEntry) -> b
        entry.data[CONF_API_KEY],
        session=async_get_clientsession(hass),
    )
+    await _check_unique_id_migration(hass, entry, emoncms_client)
    coordinator = EmoncmsCoordinator(hass, emoncms_client)
    await coordinator.async_config_entry_first_refresh()
    entry.runtime_data = coordinator
--- a/homeassistant/components/emoncms/config_flow.py
+++ b/homeassistant/components/emoncms/config_flow.py
@ -1,5 +1,7 @@
 """Configflow for the emoncms integration."""

+from __future__ import annotations
+
 from typing import Any

 from pyemoncms import EmoncmsClient
@ -9,10 +11,10 @@ from homeassistant.config_entries import (
    ConfigEntry,
    ConfigFlow,
    ConfigFlowResult,
-    OptionsFlowWithConfigEntry,
+    OptionsFlow,
 )
 from homeassistant.const import CONF_API_KEY, CONF_URL
-from homeassistant.core import HomeAssistant, callback
+from homeassistant.core import callback
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.selector import selector
 from homeassistant.helpers.typing import ConfigType
@ -46,13 +48,10 @@ def sensor_name(url: str) -> str:
    return f"emoncms@{sensorip}"


-async def get_feed_list(hass: HomeAssistant, url: str, api_key: str) -> dict[str, Any]:
+async def get_feed_list(
+    emoncms_client: EmoncmsClient,
+) -> dict[str, Any]:
    """Check connection to emoncms and return feed list if successful."""
-    emoncms_client = EmoncmsClient(
-        url,
-        api_key,
-        session=async_get_clientsession(hass),
-    )
    return await emoncms_client.async_request("/feed/list.json")


@ -68,7 +67,7 @@ class EmoncmsConfigFlow(ConfigFlow, domain=DOMAIN):
    @callback
    def async_get_options_flow(
        config_entry: ConfigEntry,
-    ) -> OptionsFlowWithConfigEntry:
+    ) -> EmoncmsOptionsFlow:
        """Get the options flow for this handler."""
        return EmoncmsOptionsFlow(config_entry)

@ -77,23 +76,28 @@ class EmoncmsConfigFlow(ConfigFlow, domain=DOMAIN):
    ) -> ConfigFlowResult:
        """Initiate a flow via the UI."""
        errors: dict[str, str] = {}
+        description_placeholders = {}

        if user_input is not None:
-            self._async_abort_entries_match(
-                {
-                    CONF_API_KEY: user_input[CONF_API_KEY],
-                    CONF_URL: user_input[CONF_URL],
-                }
-            )
-            result = await get_feed_list(
-                self.hass, user_input[CONF_URL], user_input[CONF_API_KEY]
-            )
-            if not result[CONF_SUCCESS]:
-                errors["base"] = result[CONF_MESSAGE]
-            else:
-                self.include_only_feeds = user_input.get(CONF_ONLY_INCLUDE_FEEDID)
            self.url = user_input[CONF_URL]
            self.api_key = user_input[CONF_API_KEY]
+            self._async_abort_entries_match(
+                {
+                    CONF_API_KEY: self.api_key,
+                    CONF_URL: self.url,
+                }
+            )
+            emoncms_client = EmoncmsClient(
+                self.url, self.api_key, session=async_get_clientsession(self.hass)
+            )
+            result = await get_feed_list(emoncms_client)
+            if not result[CONF_SUCCESS]:
+                errors["base"] = "api_error"
+                description_placeholders = {"details": result[CONF_MESSAGE]}
+            else:
+                self.include_only_feeds = user_input.get(CONF_ONLY_INCLUDE_FEEDID)
+                await self.async_set_unique_id(await emoncms_client.async_get_uuid())
+                self._abort_if_unique_id_configured()
                options = get_options(result[CONF_MESSAGE])
                self.dropdown = {
                    "options": options,
@ -113,6 +117,7 @@ class EmoncmsConfigFlow(ConfigFlow, domain=DOMAIN):
                user_input,
            ),
            errors=errors,
+            description_placeholders=description_placeholders,
        )

    async def async_step_choose_feeds(
@ -167,32 +172,41 @@ class EmoncmsConfigFlow(ConfigFlow, domain=DOMAIN):
        return result


-class EmoncmsOptionsFlow(OptionsFlowWithConfigEntry):
+class EmoncmsOptionsFlow(OptionsFlow):
    """Emoncms Options flow handler."""

+    def __init__(self, config_entry: ConfigEntry) -> None:
+        """Initialize emoncms options flow."""
+        self._url = config_entry.data[CONF_URL]
+        self._api_key = config_entry.data[CONF_API_KEY]
+
    async def async_step_init(
        self, user_input: dict[str, Any] | None = None
    ) -> ConfigFlowResult:
        """Manage the options."""
        errors: dict[str, str] = {}
-        data = self.options if self.options else self._config_entry.data
-        url = data[CONF_URL]
-        api_key = data[CONF_API_KEY]
-        include_only_feeds = data.get(CONF_ONLY_INCLUDE_FEEDID, [])
+        description_placeholders = {}
+        include_only_feeds = self.config_entry.options.get(
+            CONF_ONLY_INCLUDE_FEEDID,
+            self.config_entry.data.get(CONF_ONLY_INCLUDE_FEEDID, []),
+        )
        options: list = include_only_feeds
-        result = await get_feed_list(self.hass, url, api_key)
+        emoncms_client = EmoncmsClient(
+            self._url,
+            self._api_key,
+            session=async_get_clientsession(self.hass),
+        )
+        result = await get_feed_list(emoncms_client)
        if not result[CONF_SUCCESS]:
-            errors["base"] = result[CONF_MESSAGE]
+            errors["base"] = "api_error"
+            description_placeholders = {"details": result[CONF_MESSAGE]}
        else:
            options = get_options(result[CONF_MESSAGE])
        dropdown = {"options": options, "mode": "dropdown", "multiple": True}
        if user_input:
            include_only_feeds = user_input[CONF_ONLY_INCLUDE_FEEDID]
            return self.async_create_entry(
-                title=sensor_name(url),
                data={
-                    CONF_URL: url,
-                    CONF_API_KEY: api_key,
                    CONF_ONLY_INCLUDE_FEEDID: include_only_feeds,
                },
            )
@ -207,4 +221,5 @@ class EmoncmsOptionsFlow(OptionsFlowWithConfigEntry):
                }
            ),
            errors=errors,
+            description_placeholders=description_placeholders,
        )
--- a/homeassistant/components/emoncms/const.py
+++ b/homeassistant/components/emoncms/const.py
@ -7,6 +7,10 @@ CONF_ONLY_INCLUDE_FEEDID = "include_only_feed_id"
 CONF_MESSAGE = "message"
 CONF_SUCCESS = "success"
 DOMAIN = "emoncms"
+EMONCMS_UUID_DOC_URL = (
+    "https://docs.openenergymonitor.org/emoncms/update.html"
+    "#upgrading-to-a-version-producing-a-unique-identifier"
+)
 FEED_ID = "id"
 FEED_NAME = "name"
 FEED_TAG = "tag"
--- a/homeassistant/components/emoncms/sensor.py
+++ b/homeassistant/components/emoncms/sensor.py
@ -138,29 +138,30 @@ async def async_setup_entry(
    async_add_entities: AddEntitiesCallback,
 ) -> None:
    """Set up the emoncms sensors."""
-    config = entry.options if entry.options else entry.data
-    name = sensor_name(config[CONF_URL])
-    exclude_feeds = config.get(CONF_EXCLUDE_FEEDID)
-    include_only_feeds = config.get(CONF_ONLY_INCLUDE_FEEDID)
+    name = sensor_name(entry.data[CONF_URL])
+    exclude_feeds = entry.data.get(CONF_EXCLUDE_FEEDID)
+    include_only_feeds = entry.options.get(
+        CONF_ONLY_INCLUDE_FEEDID, entry.data.get(CONF_ONLY_INCLUDE_FEEDID)
+    )

    if exclude_feeds is None and include_only_feeds is None:
        return

    coordinator = entry.runtime_data
+    # uuid was added in emoncms database 11.5.7
+    unique_id = entry.unique_id if entry.unique_id else entry.entry_id
    elems = coordinator.data
    if not elems:
        return
-
    sensors: list[EmonCmsSensor] = []

    for idx, elem in enumerate(elems):
        if include_only_feeds is not None and elem[FEED_ID] not in include_only_feeds:
            continue
-
        sensors.append(
            EmonCmsSensor(
                coordinator,
-                entry.entry_id,
+                unique_id,
                elem["unit"],
                name,
                idx,
@ -175,7 +176,7 @@ class EmonCmsSensor(CoordinatorEntity[EmoncmsCoordinator], SensorEntity):
    def __init__(
        self,
        coordinator: EmoncmsCoordinator,
-        entry_id: str,
+        unique_id: str,
        unit_of_measurement: str | None,
        name: str,
        idx: int,
@ -188,7 +189,7 @@ class EmonCmsSensor(CoordinatorEntity[EmoncmsCoordinator], SensorEntity):
            elem = self.coordinator.data[self.idx]
        self._attr_name = f"{name} {elem[FEED_NAME]}"
        self._attr_native_unit_of_measurement = unit_of_measurement
-        self._attr_unique_id = f"{entry_id}-{elem[FEED_ID]}"
+        self._attr_unique_id = f"{unique_id}-{elem[FEED_ID]}"
        if unit_of_measurement in ("kWh", "Wh"):
            self._attr_device_class = SensorDeviceClass.ENERGY
            self._attr_state_class = SensorStateClass.TOTAL_INCREASING
--- a/homeassistant/components/emoncms/strings.json
+++ b/homeassistant/components/emoncms/strings.json
@ -1,5 +1,8 @@
 {
  "config": {
+    "error": {
+      "api_error": "An error occured in the pyemoncms API : {details}"
+    },
    "step": {
      "user": {
        "data": {
@ -16,9 +19,15 @@
          "include_only_feed_id": "Choose feeds to include"
        }
      }
+    },
+    "abort": {
+      "already_configured": "This server is already configured"
    }
  },
  "options": {
+    "error": {
+      "api_error": "[%key:component::emoncms::config::error::api_error%]"
+    },
    "step": {
      "init": {
        "data": {
@ -35,6 +44,10 @@
    "missing_include_only_feed_id": {
      "title": "No feed synchronized with the {domain} sensor",
      "description": "Configuring {domain} using YAML is being removed.\n\nPlease add manually the feeds you want to synchronize with the `configure` button of the integration."
+    },
+    "migrate_database": {
+      "title": "Upgrade your emoncms version",
+      "description": "Your [emoncms]({url}) does not ship a unique identifier.\n\n Please upgrade to at least version 11.5.7 and migrate your emoncms database.\n\n More info on [emoncms documentation]({doc_url})"
    }
  }
 }
--- a/homeassistant/components/emulated_kasa/manifest.json
+++ b/homeassistant/components/emulated_kasa/manifest.json
@ -6,5 +6,5 @@
  "iot_class": "local_push",
  "loggers": ["sense_energy"],
  "quality_scale": "internal",
-  "requirements": ["sense-energy==0.13.2"]
+  "requirements": ["sense-energy==0.13.3"]
 }
--- a/homeassistant/components/energy/data.py
+++ b/homeassistant/components/energy/data.py
@ -331,7 +331,7 @@ class EnergyManager:
            "device_consumption",
        ):
            if key in update:
-                data[key] = update[key]  # type: ignore[literal-required]
+                data[key] = update[key]

        self.data = data
        self._store.async_delay_save(lambda: data, 60)
--- a/homeassistant/components/enphase_envoy/config_flow.py
+++ b/homeassistant/components/enphase_envoy/config_flow.py
@ -16,7 +16,7 @@ from homeassistant.config_entries import (
    ConfigEntry,
    ConfigFlow,
    ConfigFlowResult,
-    OptionsFlowWithConfigEntry,
+    OptionsFlow,
 )
 from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant, callback
@ -66,9 +66,11 @@ class EnphaseConfigFlow(ConfigFlow, domain=DOMAIN):

    @staticmethod
    @callback
-    def async_get_options_flow(config_entry: ConfigEntry) -> EnvoyOptionsFlowHandler:
+    def async_get_options_flow(
+        config_entry: ConfigEntry,
+    ) -> EnvoyOptionsFlowHandler:
        """Options flow handler for Enphase_Envoy."""
-        return EnvoyOptionsFlowHandler(config_entry)
+        return EnvoyOptionsFlowHandler()

    @callback
    def _async_generate_schema(self) -> vol.Schema:
@ -288,7 +290,7 @@ class EnphaseConfigFlow(ConfigFlow, domain=DOMAIN):
        )


-class EnvoyOptionsFlowHandler(OptionsFlowWithConfigEntry):
+class EnvoyOptionsFlowHandler(OptionsFlow):
    """Envoy config flow options handler."""

    async def async_step_init(
--- a/homeassistant/components/eq3btsmart/init.py
+++ b/homeassistant/components/eq3btsmart/init.py
@ -15,17 +15,23 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers.dispatcher import async_dispatcher_send

-from .const import DOMAIN, SIGNAL_THERMOSTAT_CONNECTED, SIGNAL_THERMOSTAT_DISCONNECTED
+from .const import SIGNAL_THERMOSTAT_CONNECTED, SIGNAL_THERMOSTAT_DISCONNECTED
 from .models import Eq3Config, Eq3ConfigEntryData

 PLATFORMS = [
+    Platform.BINARY_SENSOR,
    Platform.CLIMATE,
+    Platform.NUMBER,
+    Platform.SWITCH,
 ]

 _LOGGER = logging.getLogger(__name__)


-async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+type Eq3ConfigEntry = ConfigEntry[Eq3ConfigEntryData]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: Eq3ConfigEntry) -> bool:
    """Handle config entry setup."""

    mac_address: str | None = entry.unique_id
@ -53,12 +59,11 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
        ble_device=device,
    )

-    eq3_config_entry = Eq3ConfigEntryData(eq3_config=eq3_config, thermostat=thermostat)
-    hass.data.setdefault(DOMAIN, {})[entry.entry_id] = eq3_config_entry
-
+    entry.runtime_data = Eq3ConfigEntryData(
+        eq3_config=eq3_config, thermostat=thermostat
+    )
    entry.async_on_unload(entry.add_update_listener(update_listener))
    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
-
    entry.async_create_background_task(
        hass, _async_run_thermostat(hass, entry), entry.entry_id
    )
@ -66,29 +71,27 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
    return True


-async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: Eq3ConfigEntry) -> bool:
    """Handle config entry unload."""

    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
-        eq3_config_entry: Eq3ConfigEntryData = hass.data[DOMAIN].pop(entry.entry_id)
-        await eq3_config_entry.thermostat.async_disconnect()
+        await entry.runtime_data.thermostat.async_disconnect()

    return unload_ok


-async def update_listener(hass: HomeAssistant, entry: ConfigEntry) -> None:
+async def update_listener(hass: HomeAssistant, entry: Eq3ConfigEntry) -> None:
    """Handle config entry update."""

    await hass.config_entries.async_reload(entry.entry_id)


-async def _async_run_thermostat(hass: HomeAssistant, entry: ConfigEntry) -> None:
+async def _async_run_thermostat(hass: HomeAssistant, entry: Eq3ConfigEntry) -> None:
    """Run the thermostat."""

-    eq3_config_entry: Eq3ConfigEntryData = hass.data[DOMAIN][entry.entry_id]
-    thermostat = eq3_config_entry.thermostat
-    mac_address = eq3_config_entry.eq3_config.mac_address
-    scan_interval = eq3_config_entry.eq3_config.scan_interval
+    thermostat = entry.runtime_data.thermostat
+    mac_address = entry.runtime_data.eq3_config.mac_address
+    scan_interval = entry.runtime_data.eq3_config.scan_interval

    await _async_reconnect_thermostat(hass, entry)

@ -117,13 +120,14 @@ async def _async_run_thermostat(hass: HomeAssistant, entry: ConfigEntry) -> None
        await asyncio.sleep(scan_interval)


-async def _async_reconnect_thermostat(hass: HomeAssistant, entry: ConfigEntry) -> None:
+async def _async_reconnect_thermostat(
+    hass: HomeAssistant, entry: Eq3ConfigEntry
+) -> None:
    """Reconnect the thermostat."""

-    eq3_config_entry: Eq3ConfigEntryData = hass.data[DOMAIN][entry.entry_id]
-    thermostat = eq3_config_entry.thermostat
-    mac_address = eq3_config_entry.eq3_config.mac_address
-    scan_interval = eq3_config_entry.eq3_config.scan_interval
+    thermostat = entry.runtime_data.thermostat
+    mac_address = entry.runtime_data.eq3_config.mac_address
+    scan_interval = entry.runtime_data.eq3_config.scan_interval

    while True:
        try:
--- a/Show more
+++ b/Show more