Use docker image to get go2rtc binary

Add sql.query action (#147260 )
Bump go2rtc to 1.9.11 (#155028 )
2025-10-26 12:09:32 +00:00 · 2025-10-23 11:27:23 +02:00 · 2025-10-23 11:08:37 +02:00 · 2025-10-23 11:53:35 +03:00 · 2025-10-23 09:40:41 +02:00 · 2025-10-23 08:44:56 +02:00
1521 changed files with 91914 additions and 17768 deletions
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -41,6 +41,7 @@
        "python.terminal.activateEnvInCurrentTerminal": true,
        "python.testing.pytestArgs": ["--no-cov"],
        "pylint.importStrategy": "fromEnvironment",
+        "python.analysis.typeCheckingMode": "basic",
        "editor.formatOnPaste": false,
        "editor.formatOnSave": true,
        "editor.formatOnType": true,
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -74,6 +74,7 @@ rules:
 - **Formatting**: Ruff
 - **Linting**: PyLint and Ruff
 - **Type Checking**: MyPy
+- **Lint/Type/Format Fixes**: Always prefer addressing the underlying issue (e.g., import the typed source, update shared stubs, align with Ruff expectations, or correct formatting at the source) before disabling a rule, adding `# type: ignore`, or skipping a formatter. Treat suppressions and `noqa` comments as a last resort once no compliant fix exists
 - **Testing**: pytest with plain functions and fixtures
 - **Language**: American English for all code, comments, and documentation (use sentence case, including titles)

--- a/.github/workflows/builder.yml
+++ b/.github/workflows/builder.yml
@@ -326,7 +326,7 @@ jobs:
        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0

      - name: Install Cosign
-        uses: sigstore/cosign-installer@d7543c93d881b35a8faa02e8e3605f69b7a1ce62 # v3.10.0
+        uses: sigstore/cosign-installer@faadad0cce49287aee09b3a48701e75088a2c6ad # v4.0.0
        with:
          cosign-release: "v2.2.3"

--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -24,11 +24,11 @@ jobs:
        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0

      - name: Initialize CodeQL
-        uses: github/codeql-action/init@3599b3baa15b485a2e49ef411a7a4bb2452e7f93 # v3.30.5
+        uses: github/codeql-action/init@16140ae1a102900babc80a33c44059580f687047 # v4.30.9
        with:
          languages: python

      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@3599b3baa15b485a2e49ef411a7a4bb2452e7f93 # v3.30.5
+        uses: github/codeql-action/analyze@16140ae1a102900babc80a33c44059580f687047 # v4.30.9
        with:
          category: "/language:python"
--- a/.github/workflows/stale.yml
+++ b/.github/workflows/stale.yml
@@ -17,7 +17,7 @@ jobs:
      # - No PRs marked as no-stale
      # - No issues (-1)
      - name: 60 days stale PRs policy
-        uses: actions/stale@3a9db7e6a41a89f618792c92c0e97cc736e1b13f # v10.0.0
+        uses: actions/stale@5f858e3efba33a5ca4407a664cc011ad407f2008 # v10.1.0
        with:
          repo-token: ${{ secrets.GITHUB_TOKEN }}
          days-before-stale: 60
@@ -57,7 +57,7 @@ jobs:
      # - No issues marked as no-stale or help-wanted
      # - No PRs (-1)
      - name: 90 days stale issues
-        uses: actions/stale@3a9db7e6a41a89f618792c92c0e97cc736e1b13f # v10.0.0
+        uses: actions/stale@5f858e3efba33a5ca4407a664cc011ad407f2008 # v10.1.0
        with:
          repo-token: ${{ steps.token.outputs.token }}
          days-before-stale: 90
@@ -87,7 +87,7 @@ jobs:
      # - No Issues marked as no-stale or help-wanted
      # - No PRs (-1)
      - name: Needs more information stale issues policy
-        uses: actions/stale@3a9db7e6a41a89f618792c92c0e97cc736e1b13f # v10.0.0
+        uses: actions/stale@5f858e3efba33a5ca4407a664cc011ad407f2008 # v10.1.0
        with:
          repo-token: ${{ steps.token.outputs.token }}
          only-labels: "needs-more-information"
--- a/.github/workflows/wheels.yml
+++ b/.github/workflows/wheels.yml
@@ -31,7 +31,8 @@ jobs:
    outputs:
      architectures: ${{ steps.info.outputs.architectures }}
    steps:
-      - name: Checkout the repository
+      - &checkout
+        name: Checkout the repository
        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0

      - name: Set up Python ${{ env.DEFAULT_PYTHON }}
@@ -91,7 +92,7 @@ jobs:
          ) > build_constraints.txt

      - name: Upload env_file
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: &actions-upload-artifact actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
        with:
          name: env_file
          path: ./.env_file
@@ -99,14 +100,14 @@ jobs:
          overwrite: true

      - name: Upload build_constraints
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: *actions-upload-artifact
        with:
          name: build_constraints
          path: ./build_constraints.txt
          overwrite: true

      - name: Upload requirements_diff
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: *actions-upload-artifact
        with:
          name: requirements_diff
          path: ./requirements_diff.txt
@@ -118,7 +119,7 @@ jobs:
          python -m script.gen_requirements_all ci

      - name: Upload requirements_all_wheels
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        uses: *actions-upload-artifact
        with:
          name: requirements_all_wheels
          path: ./requirements_all_wheels_*.txt
@@ -127,28 +128,41 @@ jobs:
    name: Build Core wheels ${{ matrix.abi }} for ${{ matrix.arch }} (musllinux_1_2)
    if: github.repository_owner == 'home-assistant'
    needs: init
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
-      matrix:
-        abi: ["cp313"]
+      matrix: &matrix-build
+        abi: ["cp313", "cp314"]
        arch: ${{ fromJson(needs.init.outputs.architectures) }}
+        include:
+          - os: ubuntu-latest
+          - arch: aarch64
+            os: ubuntu-24.04-arm
+        exclude:
+          - abi: cp314
+            arch: armv7
+          - abi: cp314
+            arch: armhf
+          - abi: cp314
+            arch: i386
    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+      - *checkout

-      - name: Download env_file
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+      - &download-env-file
+        name: Download env_file
+        uses: &actions-download-artifact actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
        with:
          name: env_file

-      - name: Download build_constraints
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+      - &download-build-constraints
+        name: Download build_constraints
+        uses: *actions-download-artifact
        with:
          name: build_constraints

-      - name: Download requirements_diff
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+      - &download-requirements-diff
+        name: Download requirements_diff
+        uses: *actions-download-artifact
        with:
          name: requirements_diff

@@ -160,7 +174,7 @@ jobs:

      # home-assistant/wheels doesn't support sha pinning
      - name: Build wheels
-        uses: home-assistant/wheels@2025.09.1
+        uses: &home-assistant-wheels home-assistant/wheels@2025.10.0
        with:
          abi: ${{ matrix.abi }}
          tag: musllinux_1_2
@@ -177,33 +191,19 @@ jobs:
    name: Build wheels ${{ matrix.abi }} for ${{ matrix.arch }}
    if: github.repository_owner == 'home-assistant'
    needs: init
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
-      matrix:
-        abi: ["cp313"]
-        arch: ${{ fromJson(needs.init.outputs.architectures) }}
+      matrix: *matrix-build
    steps:
-      - name: Checkout the repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
+      - *checkout

-      - name: Download env_file
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
-        with:
-          name: env_file
-
-      - name: Download build_constraints
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
-        with:
-          name: build_constraints
-
-      - name: Download requirements_diff
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
-        with:
-          name: requirements_diff
+      - *download-env-file
+      - *download-build-constraints
+      - *download-requirements-diff

      - name: Download requirements_all_wheels
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
+        uses: *actions-download-artifact
        with:
          name: requirements_all_wheels

@@ -221,7 +221,7 @@ jobs:

      # home-assistant/wheels doesn't support sha pinning
      - name: Build wheels
-        uses: home-assistant/wheels@2025.09.1
+        uses: *home-assistant-wheels
        with:
          abi: ${{ matrix.abi }}
          tag: musllinux_1_2
--- a/.gitignore
+++ b/.gitignore
@@ -79,7 +79,6 @@ junit.xml
 .project
 .pydevproject

-.python-version
 .tool-versions

 # emacs auto backups
--- a/.python-version
+++ b/.python-version
@@ -0,0 +1 @@
+3.13
--- a/.strict-typing
+++ b/.strict-typing
@@ -182,7 +182,6 @@ homeassistant.components.efergy.*
 homeassistant.components.eheimdigital.*
 homeassistant.components.electrasmart.*
 homeassistant.components.electric_kiwi.*
-homeassistant.components.elevenlabs.*
 homeassistant.components.elgato.*
 homeassistant.components.elkm1.*
 homeassistant.components.emulated_hue.*
@@ -221,6 +220,7 @@ homeassistant.components.generic_thermostat.*
 homeassistant.components.geo_location.*
 homeassistant.components.geocaching.*
 homeassistant.components.gios.*
+homeassistant.components.github.*
 homeassistant.components.glances.*
 homeassistant.components.go2rtc.*
 homeassistant.components.goalzero.*
@@ -477,6 +477,7 @@ homeassistant.components.skybell.*
 homeassistant.components.slack.*
 homeassistant.components.sleep_as_android.*
 homeassistant.components.sleepiq.*
+homeassistant.components.sma.*
 homeassistant.components.smhi.*
 homeassistant.components.smlight.*
 homeassistant.components.smtp.*
@@ -555,6 +556,7 @@ homeassistant.components.vacuum.*
 homeassistant.components.vallox.*
 homeassistant.components.valve.*
 homeassistant.components.velbus.*
+homeassistant.components.vivotek.*
 homeassistant.components.vlc_telnet.*
 homeassistant.components.vodafone_station.*
 homeassistant.components.volvo.*
--- a/.vscode/settings.default.json
+++ b/.vscode/settings.default.json
@@ -7,6 +7,8 @@
  "python.testing.pytestEnabled": false,
  // https://code.visualstudio.com/docs/python/linting#_general-settings
  "pylint.importStrategy": "fromEnvironment",
+  // Pyright is too pedantic for Home Assistant
+  "python.analysis.typeCheckingMode": "basic",
  "json.schemas": [
        {
            "fileMatch": [
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -0,0 +1 @@
+.github/copilot-instructions.md
--- a/22
+++ b/22
@@ -46,6 +46,8 @@ build.json @home-assistant/supervisor
 /tests/components/accuweather/ @bieniu
 /homeassistant/components/acmeda/ @atmurray
 /tests/components/acmeda/ @atmurray
+/homeassistant/components/actron_air/ @kclif9 @JagadishDhanamjayam
+/tests/components/actron_air/ @kclif9 @JagadishDhanamjayam
 /homeassistant/components/adax/ @danielhiversen @lazytarget
 /tests/components/adax/ @danielhiversen @lazytarget
 /homeassistant/components/adguard/ @frenck
@@ -617,6 +619,8 @@ build.json @home-assistant/supervisor
 /tests/components/greeneye_monitor/ @jkeljo
 /homeassistant/components/group/ @home-assistant/core
 /tests/components/group/ @home-assistant/core
+/homeassistant/components/growatt_server/ @johanzander
+/tests/components/growatt_server/ @johanzander
 /homeassistant/components/guardian/ @bachya
 /tests/components/guardian/ @bachya
 /homeassistant/components/habitica/ @tr4nt0r
@@ -762,8 +766,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/intent/ @home-assistant/core @synesthesiam @arturpragacz
 /tests/components/intent/ @home-assistant/core @synesthesiam @arturpragacz
 /homeassistant/components/intesishome/ @jnimmo
-/homeassistant/components/iometer/ @MaestroOnICe
-/tests/components/iometer/ @MaestroOnICe
+/homeassistant/components/iometer/ @jukrebs
+/tests/components/iometer/ @jukrebs
 /homeassistant/components/ios/ @robbiet480
 /tests/components/ios/ @robbiet480
 /homeassistant/components/iotawatt/ @gtdiehl @jyavenard
@@ -1065,6 +1069,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/nilu/ @hfurubotten
 /homeassistant/components/nina/ @DeerMaximum
 /tests/components/nina/ @DeerMaximum
+/homeassistant/components/nintendo_parental_controls/ @pantherale0
+/tests/components/nintendo_parental_controls/ @pantherale0
 /homeassistant/components/nissan_leaf/ @filcole
 /homeassistant/components/noaa_tides/ @jdelaney72
 /homeassistant/components/nobo_hub/ @echoromeo @oyvindwe
@@ -1133,6 +1139,8 @@ build.json @home-assistant/supervisor
 /tests/components/opengarage/ @danielhiversen
 /homeassistant/components/openhome/ @bazwilliams
 /tests/components/openhome/ @bazwilliams
+/homeassistant/components/openrgb/ @felipecrs
+/tests/components/openrgb/ @felipecrs
 /homeassistant/components/opensky/ @joostlek
 /tests/components/opensky/ @joostlek
 /homeassistant/components/opentherm_gw/ @mvn23
@@ -1196,8 +1204,6 @@ build.json @home-assistant/supervisor
 /tests/components/plex/ @jjlawren
 /homeassistant/components/plugwise/ @CoMPaTech @bouwew
 /tests/components/plugwise/ @CoMPaTech @bouwew
-/homeassistant/components/plum_lightpad/ @ColinHarrington @prystupa
-/tests/components/plum_lightpad/ @ColinHarrington @prystupa
 /homeassistant/components/point/ @fredrike
 /tests/components/point/ @fredrike
 /homeassistant/components/pooldose/ @lmaertin
@@ -1413,8 +1419,8 @@ build.json @home-assistant/supervisor
 /tests/components/sfr_box/ @epenet
 /homeassistant/components/sftp_storage/ @maretodoric
 /tests/components/sftp_storage/ @maretodoric
-/homeassistant/components/sharkiq/ @JeffResc @funkybunch
-/tests/components/sharkiq/ @JeffResc @funkybunch
+/homeassistant/components/sharkiq/ @JeffResc @funkybunch @TheOneOgre
+/tests/components/sharkiq/ @JeffResc @funkybunch @TheOneOgre
 /homeassistant/components/shell_command/ @home-assistant/core
 /tests/components/shell_command/ @home-assistant/core
 /homeassistant/components/shelly/ @bieniu @thecode @chemelli74 @bdraco
@@ -1479,8 +1485,8 @@ build.json @home-assistant/supervisor
 /tests/components/snoo/ @Lash-L
 /homeassistant/components/snooz/ @AustinBrunkhorst
 /tests/components/snooz/ @AustinBrunkhorst
-/homeassistant/components/solaredge/ @frenck @bdraco
-/tests/components/solaredge/ @frenck @bdraco
+/homeassistant/components/solaredge/ @frenck @bdraco @tronikos
+/tests/components/solaredge/ @frenck @bdraco @tronikos
 /homeassistant/components/solaredge_local/ @drobtravels @scheric
 /homeassistant/components/solarlog/ @Ernst79 @dontinelli
 /tests/components/solarlog/ @Ernst79 @dontinelli
--- a/17
+++ b/17
@@ -15,23 +15,10 @@ ARG QEMU_CPU
 # Home Assistant S6-Overlay
 COPY rootfs /

-# Needs to be redefined inside the FROM statement to be set for RUN commands
-ARG BUILD_ARCH
-# Get go2rtc binary
-RUN \
-    case "${BUILD_ARCH}" in \
-        "aarch64") go2rtc_suffix='arm64' ;; \
-        "armhf") go2rtc_suffix='armv6' ;; \
-        "armv7") go2rtc_suffix='arm' ;; \
-        *) go2rtc_suffix=${BUILD_ARCH} ;; \
-    esac \
-    && curl -L https://github.com/AlexxIT/go2rtc/releases/download/v1.9.9/go2rtc_linux_${go2rtc_suffix} --output /bin/go2rtc \
-    && chmod +x /bin/go2rtc \
-    # Verify go2rtc can be executed
-    && go2rtc --version
+COPY --from=ghcr.io/alexxit/go2rtc:1.9.11 /usr/local/bin/go2rtc /bin/go2rtc

 # Install uv
-RUN pip3 install uv==0.8.9
+RUN pip3 install uv==0.9.5

 WORKDIR /usr/src

--- a/Dockerfile.dev
+++ b/Dockerfile.dev
@@ -34,9 +34,11 @@ WORKDIR /usr/src

 COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv

-RUN uv python install 3.13.2
-
 USER vscode
+
+COPY .python-version ./
+RUN uv python install
+
 ENV VIRTUAL_ENV="/home/vscode/.local/ha-venv"
 RUN uv venv $VIRTUAL_ENV
 ENV PATH="$VIRTUAL_ENV/bin:$PATH"
--- 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:2025.10.0
-  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2025.10.0
-  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2025.10.0
-  amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2025.10.0
-  i386: ghcr.io/home-assistant/i386-homeassistant-base:2025.10.0
+  aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2025.10.1
+  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2025.10.1
+  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2025.10.1
+  amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2025.10.1
+  i386: ghcr.io/home-assistant/i386-homeassistant-base:2025.10.1
 codenotary:
  signer: notary@home-assistant.io
  base_image: notary@home-assistant.io
--- a/homeassistant/auth/mfa_modules/totp.py
+++ b/homeassistant/auth/mfa_modules/totp.py
@@ -34,6 +34,9 @@ INPUT_FIELD_CODE = "code"

 DUMMY_SECRET = "FPPTH34D4E3MI2HG"

+GOOGLE_AUTHENTICATOR_URL = "https://support.google.com/accounts/answer/1066447"
+AUTHY_URL = "https://authy.com/"
+

 def _generate_qr_code(data: str) -> str:
    """Generate a base64 PNG string represent QR Code image of data."""
@@ -229,6 +232,8 @@ class TotpSetupFlow(SetupFlow[TotpAuthModule]):
                "code": self._ota_secret,
                "url": self._url,
                "qr_code": self._image,
+                "google_authenticator_url": GOOGLE_AUTHENTICATOR_URL,
+                "authy_url": AUTHY_URL,
            },
            errors=errors,
        )
--- a/homeassistant/bootstrap.py
+++ b/homeassistant/bootstrap.py
@@ -635,25 +635,15 @@ async def async_enable_logging(
        err_log_path = os.path.abspath(log_file)

    if err_log_path:
-        err_path_exists = os.path.isfile(err_log_path)
-        err_dir = os.path.dirname(err_log_path)
+        err_handler = await hass.async_add_executor_job(
+            _create_log_file, err_log_path, log_rotate_days
+        )

-        # Check if we can write to the error log if it exists or that
-        # we can create files in the containing directory if not.
-        if (err_path_exists and os.access(err_log_path, os.W_OK)) or (
-            not err_path_exists and os.access(err_dir, os.W_OK)
-        ):
-            err_handler = await hass.async_add_executor_job(
-                _create_log_file, err_log_path, log_rotate_days
-            )
+        err_handler.setFormatter(logging.Formatter(fmt, datefmt=FORMAT_DATETIME))
+        logger.addHandler(err_handler)

-            err_handler.setFormatter(logging.Formatter(fmt, datefmt=FORMAT_DATETIME))
-            logger.addHandler(err_handler)
-
-            # Save the log file location for access by other components.
-            hass.data[DATA_LOGGING] = err_log_path
-        else:
-            _LOGGER.error("Unable to set up error log %s (access denied)", err_log_path)
+        # Save the log file location for access by other components.
+        hass.data[DATA_LOGGING] = err_log_path

    async_activate_log_queue_handler(hass)

--- a/homeassistant/brands/ibm.json
+++ b/homeassistant/brands/ibm.json
@@ -1,5 +0,0 @@
-{
-  "domain": "ibm",
-  "name": "IBM",
-  "integrations": ["watson_iot", "watson_tts"]
-}
--- a/homeassistant/components/acaia/coordinator.py
+++ b/homeassistant/components/acaia/coordinator.py
@@ -12,11 +12,13 @@ from homeassistant.components.bluetooth import async_get_scanner
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_ADDRESS
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers.debounce import Debouncer
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator

 from .const import CONF_IS_NEW_STYLE_SCALE

 SCAN_INTERVAL = timedelta(seconds=15)
+UPDATE_DEBOUNCE_TIME = 0.2

 _LOGGER = logging.getLogger(__name__)

@@ -38,11 +40,19 @@ class AcaiaCoordinator(DataUpdateCoordinator[None]):
            config_entry=entry,
        )

+        debouncer = Debouncer(
+            hass=hass,
+            logger=_LOGGER,
+            cooldown=UPDATE_DEBOUNCE_TIME,
+            immediate=True,
+            function=self.async_update_listeners,
+        )
+
        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,
+            notify_callback=debouncer.async_schedule_call,
            scanner=async_get_scanner(hass),
        )

--- a/homeassistant/components/accuweather/const.py
+++ b/homeassistant/components/accuweather/const.py
@@ -71,4 +71,4 @@ POLLEN_CATEGORY_MAP = {
 }
 UPDATE_INTERVAL_OBSERVATION = timedelta(minutes=10)
 UPDATE_INTERVAL_DAILY_FORECAST = timedelta(hours=6)
-UPDATE_INTERVAL_HOURLY_FORECAST = timedelta(hours=30)
+UPDATE_INTERVAL_HOURLY_FORECAST = timedelta(minutes=30)
--- a/homeassistant/components/accuweather/icons.json
+++ b/homeassistant/components/accuweather/icons.json
@@ -1,6 +1,9 @@
 {
  "entity": {
    "sensor": {
+      "air_quality": {
+        "default": "mdi:air-filter"
+      },
      "cloud_ceiling": {
        "default": "mdi:weather-fog"
      },
@@ -34,9 +37,6 @@
      "thunderstorm_probability_night": {
        "default": "mdi:weather-lightning"
      },
-      "translation_key": {
-        "default": "mdi:air-filter"
-      },
      "tree_pollen": {
        "default": "mdi:tree-outline"
      },
--- a/homeassistant/components/actron_air/init.py
+++ b/homeassistant/components/actron_air/init.py
@@ -0,0 +1,57 @@
+"""The Actron Air integration."""
+
+from actron_neo_api import (
+    ActronAirNeoACSystem,
+    ActronNeoAPI,
+    ActronNeoAPIError,
+    ActronNeoAuthError,
+)
+
+from homeassistant.const import CONF_API_TOKEN, Platform
+from homeassistant.core import HomeAssistant
+
+from .const import _LOGGER
+from .coordinator import (
+    ActronAirConfigEntry,
+    ActronAirRuntimeData,
+    ActronAirSystemCoordinator,
+)
+
+PLATFORM = [Platform.CLIMATE]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: ActronAirConfigEntry) -> bool:
+    """Set up Actron Air integration from a config entry."""
+
+    api = ActronNeoAPI(refresh_token=entry.data[CONF_API_TOKEN])
+    systems: list[ActronAirNeoACSystem] = []
+
+    try:
+        systems = await api.get_ac_systems()
+        await api.update_status()
+    except ActronNeoAuthError:
+        _LOGGER.error("Authentication error while setting up Actron Air integration")
+        raise
+    except ActronNeoAPIError as err:
+        _LOGGER.error("API error while setting up Actron Air integration: %s", err)
+        raise
+
+    system_coordinators: dict[str, ActronAirSystemCoordinator] = {}
+    for system in systems:
+        coordinator = ActronAirSystemCoordinator(hass, entry, api, system)
+        _LOGGER.debug("Setting up coordinator for system: %s", system["serial"])
+        await coordinator.async_config_entry_first_refresh()
+        system_coordinators[system["serial"]] = coordinator
+
+    entry.runtime_data = ActronAirRuntimeData(
+        api=api,
+        system_coordinators=system_coordinators,
+    )
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORM)
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ActronAirConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORM)
--- a/homeassistant/components/actron_air/climate.py
+++ b/homeassistant/components/actron_air/climate.py
@@ -0,0 +1,259 @@
+"""Climate platform for Actron Air integration."""
+
+from typing import Any
+
+from actron_neo_api import ActronAirNeoStatus, ActronAirNeoZone
+
+from homeassistant.components.climate import (
+    FAN_AUTO,
+    FAN_HIGH,
+    FAN_LOW,
+    FAN_MEDIUM,
+    ClimateEntity,
+    ClimateEntityFeature,
+    HVACMode,
+)
+from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import ActronAirConfigEntry, ActronAirSystemCoordinator
+
+PARALLEL_UPDATES = 0
+
+FAN_MODE_MAPPING_ACTRONAIR_TO_HA = {
+    "AUTO": FAN_AUTO,
+    "LOW": FAN_LOW,
+    "MED": FAN_MEDIUM,
+    "HIGH": FAN_HIGH,
+}
+FAN_MODE_MAPPING_HA_TO_ACTRONAIR = {
+    v: k for k, v in FAN_MODE_MAPPING_ACTRONAIR_TO_HA.items()
+}
+HVAC_MODE_MAPPING_ACTRONAIR_TO_HA = {
+    "COOL": HVACMode.COOL,
+    "HEAT": HVACMode.HEAT,
+    "FAN": HVACMode.FAN_ONLY,
+    "AUTO": HVACMode.AUTO,
+    "OFF": HVACMode.OFF,
+}
+HVAC_MODE_MAPPING_HA_TO_ACTRONAIR = {
+    v: k for k, v in HVAC_MODE_MAPPING_ACTRONAIR_TO_HA.items()
+}
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: ActronAirConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Actron Air climate entities."""
+    system_coordinators = entry.runtime_data.system_coordinators
+    entities: list[ClimateEntity] = []
+
+    for coordinator in system_coordinators.values():
+        status = coordinator.data
+        name = status.ac_system.system_name
+        entities.append(ActronSystemClimate(coordinator, name))
+
+        entities.extend(
+            ActronZoneClimate(coordinator, zone)
+            for zone in status.remote_zone_info
+            if zone.exists
+        )
+
+    async_add_entities(entities)
+
+
+class BaseClimateEntity(CoordinatorEntity[ActronAirSystemCoordinator], ClimateEntity):
+    """Base class for Actron Air climate entities."""
+
+    _attr_has_entity_name = True
+    _attr_temperature_unit = UnitOfTemperature.CELSIUS
+    _attr_supported_features = (
+        ClimateEntityFeature.TARGET_TEMPERATURE
+        | ClimateEntityFeature.FAN_MODE
+        | ClimateEntityFeature.TURN_ON
+        | ClimateEntityFeature.TURN_OFF
+    )
+    _attr_name = None
+    _attr_fan_modes = list(FAN_MODE_MAPPING_ACTRONAIR_TO_HA.values())
+    _attr_hvac_modes = list(HVAC_MODE_MAPPING_ACTRONAIR_TO_HA.values())
+
+    def __init__(
+        self,
+        coordinator: ActronAirSystemCoordinator,
+        name: str,
+    ) -> None:
+        """Initialize an Actron Air unit."""
+        super().__init__(coordinator)
+        self._serial_number = coordinator.serial_number
+
+
+class ActronSystemClimate(BaseClimateEntity):
+    """Representation of the Actron Air system."""
+
+    _attr_supported_features = (
+        ClimateEntityFeature.TARGET_TEMPERATURE
+        | ClimateEntityFeature.FAN_MODE
+        | ClimateEntityFeature.TURN_ON
+        | ClimateEntityFeature.TURN_OFF
+    )
+
+    def __init__(
+        self,
+        coordinator: ActronAirSystemCoordinator,
+        name: str,
+    ) -> None:
+        """Initialize an Actron Air unit."""
+        super().__init__(coordinator, name)
+        serial_number = coordinator.serial_number
+        self._attr_unique_id = serial_number
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, serial_number)},
+            name=self._status.ac_system.system_name,
+            manufacturer="Actron Air",
+            model_id=self._status.ac_system.master_wc_model,
+            sw_version=self._status.ac_system.master_wc_firmware_version,
+            serial_number=serial_number,
+        )
+
+    @property
+    def min_temp(self) -> float:
+        """Return the minimum temperature that can be set."""
+        return self._status.min_temp
+
+    @property
+    def max_temp(self) -> float:
+        """Return the maximum temperature that can be set."""
+        return self._status.max_temp
+
+    @property
+    def _status(self) -> ActronAirNeoStatus:
+        """Get the current status from the coordinator."""
+        return self.coordinator.data
+
+    @property
+    def hvac_mode(self) -> HVACMode | None:
+        """Return the current HVAC mode."""
+        if not self._status.user_aircon_settings.is_on:
+            return HVACMode.OFF
+
+        mode = self._status.user_aircon_settings.mode
+        return HVAC_MODE_MAPPING_ACTRONAIR_TO_HA.get(mode)
+
+    @property
+    def fan_mode(self) -> str | None:
+        """Return the current fan mode."""
+        fan_mode = self._status.user_aircon_settings.fan_mode
+        return FAN_MODE_MAPPING_ACTRONAIR_TO_HA.get(fan_mode)
+
+    @property
+    def current_humidity(self) -> float:
+        """Return the current humidity."""
+        return self._status.master_info.live_humidity_pc
+
+    @property
+    def current_temperature(self) -> float:
+        """Return the current temperature."""
+        return self._status.master_info.live_temp_c
+
+    @property
+    def target_temperature(self) -> float:
+        """Return the target temperature."""
+        return self._status.user_aircon_settings.temperature_setpoint_cool_c
+
+    async def async_set_fan_mode(self, fan_mode: str) -> None:
+        """Set a new fan mode."""
+        api_fan_mode = FAN_MODE_MAPPING_HA_TO_ACTRONAIR.get(fan_mode.lower())
+        await self._status.user_aircon_settings.set_fan_mode(api_fan_mode)
+
+    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
+        """Set the HVAC mode."""
+        ac_mode = HVAC_MODE_MAPPING_HA_TO_ACTRONAIR.get(hvac_mode)
+        await self._status.ac_system.set_system_mode(ac_mode)
+
+    async def async_set_temperature(self, **kwargs: Any) -> None:
+        """Set the temperature."""
+        temp = kwargs.get(ATTR_TEMPERATURE)
+        await self._status.user_aircon_settings.set_temperature(temperature=temp)
+
+
+class ActronZoneClimate(BaseClimateEntity):
+    """Representation of a zone within the Actron Air system."""
+
+    _attr_supported_features = (
+        ClimateEntityFeature.TARGET_TEMPERATURE
+        | ClimateEntityFeature.TURN_ON
+        | ClimateEntityFeature.TURN_OFF
+    )
+
+    def __init__(
+        self,
+        coordinator: ActronAirSystemCoordinator,
+        zone: ActronAirNeoZone,
+    ) -> None:
+        """Initialize an Actron Air unit."""
+        super().__init__(coordinator, zone.title)
+        serial_number = coordinator.serial_number
+        self._zone_id: int = zone.zone_id
+        self._attr_unique_id: str = f"{serial_number}_zone_{zone.zone_id}"
+        self._attr_device_info: DeviceInfo = DeviceInfo(
+            identifiers={(DOMAIN, self._attr_unique_id)},
+            name=zone.title,
+            manufacturer="Actron Air",
+            model="Zone",
+            suggested_area=zone.title,
+            via_device=(DOMAIN, serial_number),
+        )
+
+    @property
+    def min_temp(self) -> float:
+        """Return the minimum temperature that can be set."""
+        return self._zone.min_temp
+
+    @property
+    def max_temp(self) -> float:
+        """Return the maximum temperature that can be set."""
+        return self._zone.max_temp
+
+    @property
+    def _zone(self) -> ActronAirNeoZone:
+        """Get the current zone data from the coordinator."""
+        status = self.coordinator.data
+        return status.zones[self._zone_id]
+
+    @property
+    def hvac_mode(self) -> HVACMode | None:
+        """Return the current HVAC mode."""
+        if self._zone.is_active:
+            mode = self._zone.hvac_mode
+            return HVAC_MODE_MAPPING_ACTRONAIR_TO_HA.get(mode)
+        return HVACMode.OFF
+
+    @property
+    def current_humidity(self) -> float | None:
+        """Return the current humidity."""
+        return self._zone.humidity
+
+    @property
+    def current_temperature(self) -> float | None:
+        """Return the current temperature."""
+        return self._zone.live_temp_c
+
+    @property
+    def target_temperature(self) -> float | None:
+        """Return the target temperature."""
+        return self._zone.temperature_setpoint_cool_c
+
+    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
+        """Set the HVAC mode."""
+        is_enabled = hvac_mode != HVACMode.OFF
+        await self._zone.enable(is_enabled)
+
+    async def async_set_temperature(self, **kwargs: Any) -> None:
+        """Set the temperature."""
+        await self._zone.set_temperature(temperature=kwargs["temperature"])
--- a/homeassistant/components/actron_air/config_flow.py
+++ b/homeassistant/components/actron_air/config_flow.py
@@ -0,0 +1,132 @@
+"""Setup config flow for Actron Air integration."""
+
+import asyncio
+from typing import Any
+
+from actron_neo_api import ActronNeoAPI, ActronNeoAuthError
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_API_TOKEN
+from homeassistant.exceptions import HomeAssistantError
+
+from .const import _LOGGER, DOMAIN
+
+
+class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Actron Air."""
+
+    def __init__(self) -> None:
+        """Initialize the config flow."""
+        self._api: ActronNeoAPI | None = None
+        self._device_code: str | None = None
+        self._user_code: str = ""
+        self._verification_uri: str = ""
+        self._expires_minutes: str = "30"
+        self.login_task: asyncio.Task | None = None
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        if self._api is None:
+            _LOGGER.debug("Initiating device authorization")
+            self._api = ActronNeoAPI()
+            try:
+                device_code_response = await self._api.request_device_code()
+            except ActronNeoAuthError as err:
+                _LOGGER.error("OAuth2 flow failed: %s", err)
+                return self.async_abort(reason="oauth2_error")
+
+            self._device_code = device_code_response["device_code"]
+            self._user_code = device_code_response["user_code"]
+            self._verification_uri = device_code_response["verification_uri_complete"]
+            self._expires_minutes = str(device_code_response["expires_in"] // 60)
+
+        async def _wait_for_authorization() -> None:
+            """Wait for the user to authorize the device."""
+            assert self._api is not None
+            assert self._device_code is not None
+            _LOGGER.debug("Waiting for device authorization")
+            try:
+                await self._api.poll_for_token(self._device_code)
+                _LOGGER.debug("Authorization successful")
+            except ActronNeoAuthError as ex:
+                _LOGGER.exception("Error while waiting for device authorization")
+                raise CannotConnect from ex
+
+        _LOGGER.debug("Checking login task")
+        if self.login_task is None:
+            _LOGGER.debug("Creating task for device authorization")
+            self.login_task = self.hass.async_create_task(_wait_for_authorization())
+
+        if self.login_task.done():
+            _LOGGER.debug("Login task is done, checking results")
+            if exception := self.login_task.exception():
+                if isinstance(exception, CannotConnect):
+                    return self.async_show_progress_done(
+                        next_step_id="connection_error"
+                    )
+                return self.async_show_progress_done(next_step_id="timeout")
+            return self.async_show_progress_done(next_step_id="finish_login")
+
+        return self.async_show_progress(
+            step_id="user",
+            progress_action="wait_for_authorization",
+            description_placeholders={
+                "user_code": self._user_code,
+                "verification_uri": self._verification_uri,
+                "expires_minutes": self._expires_minutes,
+            },
+            progress_task=self.login_task,
+        )
+
+    async def async_step_finish_login(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the finalization of login."""
+        _LOGGER.debug("Finalizing authorization")
+        assert self._api is not None
+
+        try:
+            user_data = await self._api.get_user_info()
+        except ActronNeoAuthError as err:
+            _LOGGER.error("Error getting user info: %s", err)
+            return self.async_abort(reason="oauth2_error")
+
+        unique_id = str(user_data["id"])
+        await self.async_set_unique_id(unique_id)
+        self._abort_if_unique_id_configured()
+
+        return self.async_create_entry(
+            title=user_data["email"],
+            data={CONF_API_TOKEN: self._api.refresh_token_value},
+        )
+
+    async def async_step_timeout(
+        self,
+        user_input: dict[str, Any] | None = None,
+    ) -> ConfigFlowResult:
+        """Handle issues that need transition await from progress step."""
+        if user_input is None:
+            return self.async_show_form(
+                step_id="timeout",
+            )
+        del self.login_task
+        return await self.async_step_user()
+
+    async def async_step_connection_error(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle connection error from progress step."""
+        if user_input is None:
+            return self.async_show_form(step_id="connection_error")
+
+        # Reset state and try again
+        self._api = None
+        self._device_code = None
+        self.login_task = None
+        return await self.async_step_user()
+
+
+class CannotConnect(HomeAssistantError):
+    """Error to indicate we cannot connect."""
--- a/homeassistant/components/actron_air/const.py
+++ b/homeassistant/components/actron_air/const.py
@@ -0,0 +1,6 @@
+"""Constants used by Actron Air integration."""
+
+import logging
+
+_LOGGER = logging.getLogger(__package__)
+DOMAIN = "actron_air"
--- a/homeassistant/components/actron_air/coordinator.py
+++ b/homeassistant/components/actron_air/coordinator.py
@@ -0,0 +1,69 @@
+"""Coordinator for Actron Air integration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import timedelta
+
+from actron_neo_api import ActronAirNeoACSystem, ActronAirNeoStatus, ActronNeoAPI
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+from homeassistant.util import dt as dt_util
+
+from .const import _LOGGER
+
+STALE_DEVICE_TIMEOUT = timedelta(hours=24)
+ERROR_NO_SYSTEMS_FOUND = "no_systems_found"
+ERROR_UNKNOWN = "unknown_error"
+
+
+@dataclass
+class ActronAirRuntimeData:
+    """Runtime data for the Actron Air integration."""
+
+    api: ActronNeoAPI
+    system_coordinators: dict[str, ActronAirSystemCoordinator]
+
+
+type ActronAirConfigEntry = ConfigEntry[ActronAirRuntimeData]
+
+AUTH_ERROR_THRESHOLD = 3
+SCAN_INTERVAL = timedelta(seconds=30)
+
+
+class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirNeoACSystem]):
+    """System coordinator for Actron Air integration."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        entry: ActronAirConfigEntry,
+        api: ActronNeoAPI,
+        system: ActronAirNeoACSystem,
+    ) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            name="Actron Air Status",
+            update_interval=SCAN_INTERVAL,
+            config_entry=entry,
+        )
+        self.system = system
+        self.serial_number = system["serial"]
+        self.api = api
+        self.status = self.api.state_manager.get_status(self.serial_number)
+        self.last_seen = dt_util.utcnow()
+
+    async def _async_update_data(self) -> ActronAirNeoStatus:
+        """Fetch updates and merge incremental changes into the full state."""
+        await self.api.update_status()
+        self.status = self.api.state_manager.get_status(self.serial_number)
+        self.last_seen = dt_util.utcnow()
+        return self.status
+
+    def is_device_stale(self) -> bool:
+        """Check if a device is stale (not seen for a while)."""
+        return (dt_util.utcnow() - self.last_seen) > STALE_DEVICE_TIMEOUT
--- a/homeassistant/components/actron_air/manifest.json
+++ b/homeassistant/components/actron_air/manifest.json
@@ -0,0 +1,16 @@
+{
+  "domain": "actron_air",
+  "name": "Actron Air",
+  "codeowners": ["@kclif9", "@JagadishDhanamjayam"],
+  "config_flow": true,
+  "dhcp": [
+    {
+      "hostname": "neo-*",
+      "macaddress": "FC0FE7*"
+    }
+  ],
+  "documentation": "https://www.home-assistant.io/integrations/actron_air",
+  "iot_class": "cloud_polling",
+  "quality_scale": "bronze",
+  "requirements": ["actron-neo-api==0.1.84"]
+}
--- a/homeassistant/components/actron_air/quality_scale.yaml
+++ b/homeassistant/components/actron_air/quality_scale.yaml
@@ -0,0 +1,78 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: This integration does not have custom service actions.
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: This integration does not have custom service actions.
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: This integration does not subscribe to external events.
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions: todo
+  config-entry-unloading: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: No options flow
+  docs-installation-parameters: done
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: done
+  reauthentication-flow: todo
+  test-coverage: todo
+
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info:
+    status: exempt
+    comment: This integration uses DHCP discovery, however is cloud polling. Therefore there is no information to update.
+  discovery: done
+  docs-data-update: done
+  docs-examples: done
+  docs-known-limitations: done
+  docs-supported-devices: done
+  docs-supported-functions: done
+  docs-troubleshooting: done
+  docs-use-cases: done
+  dynamic-devices: todo
+  entity-category:
+    status: exempt
+    comment: This integration does not use entity categories.
+  entity-device-class:
+    status: exempt
+    comment: This integration does not use entity device classes.
+  entity-disabled-by-default:
+    status: exempt
+    comment: Not required for this integration at this stage.
+  entity-translations: todo
+  exception-translations: todo
+  icon-translations: todo
+  reconfiguration-flow: todo
+  repair-issues:
+    status: exempt
+    comment: This integration does not have any known issues that require repair.
+  stale-devices: todo
+
+  # Platinum
+  async-dependency: done
+  inject-websession: todo
+  strict-typing: todo
--- a/homeassistant/components/actron_air/strings.json
+++ b/homeassistant/components/actron_air/strings.json
@@ -0,0 +1,29 @@
+{
+  "config": {
+    "step": {
+      "user": {
+        "title": "Actron Air OAuth2 Authorization"
+      },
+      "timeout": {
+        "title": "Authorization timeout",
+        "description": "The authorization process timed out. Please try again.",
+        "data": {}
+      },
+      "connection_error": {
+        "title": "Connection error",
+        "description": "Failed to connect to Actron Air. Please check your internet connection and try again.",
+        "data": {}
+      }
+    },
+    "progress": {
+      "wait_for_authorization": "To authenticate, open the following URL and login at Actron Air:\n{verification_uri}\nIf the code is not automatically copied, paste the following code to authorize the integration:\n\n```{user_code}```\n\n\nThe login attempt will time out after {expires_minutes} minutes."
+    },
+    "error": {
+      "oauth2_error": "Failed to start OAuth2 flow. Please try again later."
+    },
+    "abort": {
+      "oauth2_error": "Failed to start OAuth2 flow",
+      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]"
+    }
+  }
+}
--- a/homeassistant/components/adax/manifest.json
+++ b/homeassistant/components/adax/manifest.json
@@ -6,5 +6,5 @@
  "documentation": "https://www.home-assistant.io/integrations/adax",
  "iot_class": "local_polling",
  "loggers": ["adax", "adax_local"],
-  "requirements": ["adax==0.4.0", "Adax-local==0.1.5"]
+  "requirements": ["adax==0.4.0", "Adax-local==0.2.0"]
 }
--- a/homeassistant/components/aemet/config_flow.py
+++ b/homeassistant/components/aemet/config_flow.py
@@ -71,7 +71,14 @@ class AemetConfigFlow(ConfigFlow, domain=DOMAIN):
            }
        )

-        return self.async_show_form(step_id="user", data_schema=schema, errors=errors)
+        return self.async_show_form(
+            step_id="user",
+            data_schema=schema,
+            errors=errors,
+            description_placeholders={
+                "api_key_url": "https://opendata.aemet.es/centrodedescargas/altaUsuario"
+            },
+        )

    @staticmethod
    @callback
--- a/homeassistant/components/aemet/strings.json
+++ b/homeassistant/components/aemet/strings.json
@@ -14,7 +14,7 @@
          "longitude": "[%key:common::config_flow::data::longitude%]",
          "name": "Name of the integration"
        },
-        "description": "To generate API key go to https://opendata.aemet.es/centrodedescargas/altaUsuario"
+        "description": "To generate API key go to {api_key_url}"
      }
    }
  },
--- a/homeassistant/components/ai_task/init.py
+++ b/homeassistant/components/ai_task/init.py
@@ -53,9 +53,6 @@ __all__ = [
    "GenImageTaskResult",
    "async_generate_data",
    "async_generate_image",
-    "async_setup",
-    "async_setup_entry",
-    "async_unload_entry",
 ]

 _LOGGER = logging.getLogger(__name__)
--- a/homeassistant/components/airgradient/update.py
+++ b/homeassistant/components/airgradient/update.py
@@ -1,7 +1,9 @@
 """Airgradient Update platform."""

 from datetime import timedelta
+import logging

+from airgradient import AirGradientConnectionError
 from propcache.api import cached_property

 from homeassistant.components.update import UpdateDeviceClass, UpdateEntity
@@ -13,6 +15,7 @@ from .entity import AirGradientEntity

 PARALLEL_UPDATES = 1
 SCAN_INTERVAL = timedelta(hours=1)
+_LOGGER = logging.getLogger(__name__)


 async def async_setup_entry(
@@ -31,6 +34,7 @@ class AirGradientUpdate(AirGradientEntity, UpdateEntity):
    """Representation of Airgradient Update."""

    _attr_device_class = UpdateDeviceClass.FIRMWARE
+    _server_unreachable_logged = False

    def __init__(self, coordinator: AirGradientCoordinator) -> None:
        """Initialize the entity."""
@@ -47,10 +51,27 @@ class AirGradientUpdate(AirGradientEntity, UpdateEntity):
        """Return the installed version of the entity."""
        return self.coordinator.data.measures.firmware_version

+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        return super().available and self._attr_available
+
    async def async_update(self) -> None:
        """Update the entity."""
-        self._attr_latest_version = (
-            await self.coordinator.client.get_latest_firmware_version(
-                self.coordinator.serial_number
+        try:
+            self._attr_latest_version = (
+                await self.coordinator.client.get_latest_firmware_version(
+                    self.coordinator.serial_number
+                )
            )
-        )
+        except AirGradientConnectionError:
+            self._attr_latest_version = None
+            self._attr_available = False
+            if not self._server_unreachable_logged:
+                _LOGGER.error(
+                    "Unable to connect to AirGradient server to check for updates"
+                )
+                self._server_unreachable_logged = True
+        else:
+            self._server_unreachable_logged = False
+            self._attr_available = True
--- a/homeassistant/components/airly/config_flow.py
+++ b/homeassistant/components/airly/config_flow.py
@@ -18,6 +18,10 @@ from homeassistant.helpers.aiohttp_client import async_get_clientsession

 from .const import CONF_USE_NEAREST, DOMAIN, NO_AIRLY_SENSORS

+DESCRIPTION_PLACEHOLDERS = {
+    "developer_registration_url": "https://developer.airly.eu/register",
+}
+

 class AirlyFlowHandler(ConfigFlow, domain=DOMAIN):
    """Config flow for Airly."""
@@ -85,6 +89,7 @@ class AirlyFlowHandler(ConfigFlow, domain=DOMAIN):
                }
            ),
            errors=errors,
+            description_placeholders=DESCRIPTION_PLACEHOLDERS,
        )


--- a/homeassistant/components/airly/strings.json
+++ b/homeassistant/components/airly/strings.json
@@ -2,7 +2,7 @@
  "config": {
    "step": {
      "user": {
-        "description": "To generate API key go to https://developer.airly.eu/register",
+        "description": "To generate API key go to {developer_registration_url}",
        "data": {
          "name": "[%key:common::config_flow::data::name%]",
          "api_key": "[%key:common::config_flow::data::api_key%]",
--- a/homeassistant/components/airnow/config_flow.py
+++ b/homeassistant/components/airnow/config_flow.py
@@ -26,6 +26,10 @@ from .const import DOMAIN
 _LOGGER = logging.getLogger(__name__)


+# Documentation URL for API key generation
+_API_KEY_URL = "https://docs.airnowapi.org/account/request/"
+
+
 async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> bool:
    """Validate the user input allows us to connect.

@@ -114,6 +118,7 @@ class AirNowConfigFlow(ConfigFlow, domain=DOMAIN):
                    ),
                }
            ),
+            description_placeholders={"api_key_url": _API_KEY_URL},
            errors=errors,
        )

--- a/homeassistant/components/airnow/strings.json
+++ b/homeassistant/components/airnow/strings.json
@@ -2,7 +2,7 @@
  "config": {
    "step": {
      "user": {
-        "description": "To generate API key go to https://docs.airnowapi.org/account/request/",
+        "description": "To generate API key go to {api_key_url}",
        "data": {
          "api_key": "[%key:common::config_flow::data::api_key%]",
          "latitude": "[%key:common::config_flow::data::latitude%]",
--- a/homeassistant/components/airos/init.py
+++ b/homeassistant/components/airos/init.py
@@ -2,6 +2,8 @@

 from __future__ import annotations

+import logging
+
 from airos.airos8 import AirOS8

 from homeassistant.const import (
@@ -12,10 +14,11 @@ from homeassistant.const import (
    CONF_VERIFY_SSL,
    Platform,
 )
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.aiohttp_client import async_get_clientsession

-from .const import DEFAULT_SSL, DEFAULT_VERIFY_SSL, SECTION_ADVANCED_SETTINGS
+from .const import DEFAULT_SSL, DEFAULT_VERIFY_SSL, DOMAIN, SECTION_ADVANCED_SETTINGS
 from .coordinator import AirOSConfigEntry, AirOSDataUpdateCoordinator

 _PLATFORMS: list[Platform] = [
@@ -23,6 +26,8 @@ _PLATFORMS: list[Platform] = [
    Platform.SENSOR,
 ]

+_LOGGER = logging.getLogger(__name__)
+

 async def async_setup_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> bool:
    """Set up Ubiquiti airOS from a config entry."""
@@ -54,11 +59,13 @@ async def async_setup_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> boo
 async def async_migrate_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> bool:
    """Migrate old config entry."""

-    if entry.version > 1:
-        # This means the user has downgraded from a future version
+    # This means the user has downgraded from a future version
+    if entry.version > 2:
        return False

+    # 1.1 Migrate config_entry to add advanced ssl settings
    if entry.version == 1 and entry.minor_version == 1:
+        new_minor_version = 2
        new_data = {**entry.data}
        advanced_data = {
            CONF_SSL: DEFAULT_SSL,
@@ -69,7 +76,52 @@ async def async_migrate_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> b
        hass.config_entries.async_update_entry(
            entry,
            data=new_data,
-            minor_version=2,
+            minor_version=new_minor_version,
+        )
+
+    # 2.1 Migrate binary_sensor entity unique_id from device_id to mac_address
+    #     Step 1 - migrate binary_sensor entity unique_id
+    #     Step 2 - migrate device entity identifier
+    if entry.version == 1:
+        new_version = 2
+        new_minor_version = 1
+
+        mac_adress = dr.format_mac(entry.unique_id)
+
+        device_registry = dr.async_get(hass)
+        if device_entry := device_registry.async_get_device(
+            connections={(dr.CONNECTION_NETWORK_MAC, mac_adress)}
+        ):
+            old_device_id = next(
+                (
+                    device_id
+                    for domain, device_id in device_entry.identifiers
+                    if domain == DOMAIN
+                ),
+            )
+
+            @callback
+            def update_unique_id(
+                entity_entry: er.RegistryEntry,
+            ) -> dict[str, str] | None:
+                """Update unique id from device_id to mac address."""
+                if old_device_id and entity_entry.unique_id.startswith(old_device_id):
+                    suffix = entity_entry.unique_id.removeprefix(old_device_id)
+                    new_unique_id = f"{mac_adress}{suffix}"
+                    return {"new_unique_id": new_unique_id}
+                return None
+
+            await er.async_migrate_entries(hass, entry.entry_id, update_unique_id)
+
+            new_identifiers = device_entry.identifiers.copy()
+            new_identifiers.discard((DOMAIN, old_device_id))
+            new_identifiers.add((DOMAIN, mac_adress))
+            device_registry.async_update_device(
+                device_entry.id, new_identifiers=new_identifiers
+            )
+
+        hass.config_entries.async_update_entry(
+            entry, version=new_version, minor_version=new_minor_version
        )

    return True
--- a/homeassistant/components/airos/binary_sensor.py
+++ b/homeassistant/components/airos/binary_sensor.py
@@ -98,7 +98,7 @@ class AirOSBinarySensor(AirOSEntity, BinarySensorEntity):
        super().__init__(coordinator)

        self.entity_description = description
-        self._attr_unique_id = f"{coordinator.data.host.device_id}_{description.key}"
+        self._attr_unique_id = f"{coordinator.data.derived.mac}_{description.key}"

    @property
    def is_on(self) -> bool:
--- a/homeassistant/components/airos/config_flow.py
+++ b/homeassistant/components/airos/config_flow.py
@@ -15,7 +15,12 @@ from airos.exceptions import (
 )
 import voluptuous as vol

-from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlow, ConfigFlowResult
+from homeassistant.config_entries import (
+    SOURCE_REAUTH,
+    SOURCE_RECONFIGURE,
+    ConfigFlow,
+    ConfigFlowResult,
+)
 from homeassistant.const import (
    CONF_HOST,
    CONF_PASSWORD,
@@ -57,8 +62,8 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
 class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
    """Handle a config flow for Ubiquiti airOS."""

-    VERSION = 1
-    MINOR_VERSION = 2
+    VERSION = 2
+    MINOR_VERSION = 1

    def __init__(self) -> None:
        """Initialize the config flow."""
@@ -119,7 +124,7 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
        else:
            await self.async_set_unique_id(airos_data.derived.mac)

-            if self.source == SOURCE_REAUTH:
+            if self.source in [SOURCE_REAUTH, SOURCE_RECONFIGURE]:
                self._abort_if_unique_id_mismatch()
            else:
                self._abort_if_unique_id_configured()
@@ -164,3 +169,54 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
            ),
            errors=self.errors,
        )
+
+    async def async_step_reconfigure(
+        self,
+        user_input: Mapping[str, Any] | None = None,
+    ) -> ConfigFlowResult:
+        """Handle reconfiguration of airOS."""
+        self.errors = {}
+        entry = self._get_reconfigure_entry()
+        current_data = entry.data
+
+        if user_input is not None:
+            validate_data = {**current_data, **user_input}
+            if await self._validate_and_get_device_info(config_data=validate_data):
+                return self.async_update_reload_and_abort(
+                    entry,
+                    data_updates=validate_data,
+                )
+
+        return self.async_show_form(
+            step_id="reconfigure",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_PASSWORD): TextSelector(
+                        TextSelectorConfig(
+                            type=TextSelectorType.PASSWORD,
+                            autocomplete="current-password",
+                        )
+                    ),
+                    vol.Required(SECTION_ADVANCED_SETTINGS): section(
+                        vol.Schema(
+                            {
+                                vol.Required(
+                                    CONF_SSL,
+                                    default=current_data[SECTION_ADVANCED_SETTINGS][
+                                        CONF_SSL
+                                    ],
+                                ): bool,
+                                vol.Required(
+                                    CONF_VERIFY_SSL,
+                                    default=current_data[SECTION_ADVANCED_SETTINGS][
+                                        CONF_VERIFY_SSL
+                                    ],
+                                ): bool,
+                            }
+                        ),
+                        {"collapsed": True},
+                    ),
+                }
+            ),
+            errors=self.errors,
+        )
--- a/homeassistant/components/airos/entity.py
+++ b/homeassistant/components/airos/entity.py
@@ -33,9 +33,14 @@ class AirOSEntity(CoordinatorEntity[AirOSDataUpdateCoordinator]):
        self._attr_device_info = DeviceInfo(
            connections={(CONNECTION_NETWORK_MAC, airos_data.derived.mac)},
            configuration_url=configuration_url,
-            identifiers={(DOMAIN, str(airos_data.host.device_id))},
+            identifiers={(DOMAIN, airos_data.derived.mac)},
            manufacturer=MANUFACTURER,
            model=airos_data.host.devmodel,
+            model_id=(
+                sku
+                if (sku := airos_data.derived.sku) not in ["UNKNOWN", "AMBIGUOUS"]
+                else None
+            ),
            name=airos_data.host.hostname,
            sw_version=airos_data.host.fwversion,
        )
--- a/homeassistant/components/airos/manifest.json
+++ b/homeassistant/components/airos/manifest.json
@@ -4,7 +4,8 @@
  "codeowners": ["@CoMPaTech"],
  "config_flow": true,
  "documentation": "https://www.home-assistant.io/integrations/airos",
+  "integration_type": "device",
  "iot_class": "local_polling",
-  "quality_scale": "bronze",
-  "requirements": ["airos==0.5.4"]
+  "quality_scale": "silver",
+  "requirements": ["airos==0.5.6"]
 }
--- a/homeassistant/components/airos/quality_scale.yaml
+++ b/homeassistant/components/airos/quality_scale.yaml
@@ -32,11 +32,11 @@ rules:
  config-entry-unloading: done
  docs-configuration-parameters: done
  docs-installation-parameters: done
-  entity-unavailable: todo
+  entity-unavailable: done
  integration-owner: done
-  log-when-unavailable: todo
-  parallel-updates: todo
-  reauthentication-flow: todo
+  log-when-unavailable: done
+  parallel-updates: done
+  reauthentication-flow: done
  test-coverage: done

  # Gold
@@ -48,9 +48,9 @@ rules:
  docs-examples: todo
  docs-known-limitations: done
  docs-supported-devices: done
-  docs-supported-functions: todo
+  docs-supported-functions: done
  docs-troubleshooting: done
-  docs-use-cases: todo
+  docs-use-cases: done
  dynamic-devices: todo
  entity-category: done
  entity-device-class: done
@@ -60,7 +60,7 @@ rules:
  icon-translations:
    status: exempt
    comment: no (custom) icons used or envisioned
-  reconfiguration-flow: todo
+  reconfiguration-flow: done
  repair-issues: todo
  stale-devices: todo

--- a/homeassistant/components/airos/strings.json
+++ b/homeassistant/components/airos/strings.json
@@ -10,6 +10,27 @@
          "password": "[%key:component::airos::config::step::user::data_description::password%]"
        }
      },
+      "reconfigure": {
+        "data": {
+          "password": "[%key:common::config_flow::data::password%]"
+        },
+        "data_description": {
+          "password": "[%key:component::airos::config::step::user::data_description::password%]"
+        },
+        "sections": {
+          "advanced_settings": {
+            "name": "[%key:component::airos::config::step::user::sections::advanced_settings::name%]",
+            "data": {
+              "ssl": "[%key:component::airos::config::step::user::sections::advanced_settings::data::ssl%]",
+              "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
+            },
+            "data_description": {
+              "ssl": "[%key:component::airos::config::step::user::sections::advanced_settings::data_description::ssl%]",
+              "verify_ssl": "[%key:component::airos::config::step::user::sections::advanced_settings::data_description::verify_ssl%]"
+            }
+          }
+        }
+      },
      "user": {
        "data": {
          "host": "[%key:common::config_flow::data::host%]",
@@ -23,6 +44,7 @@
        },
        "sections": {
          "advanced_settings": {
+            "name": "Advanced settings",
            "data": {
              "ssl": "Use HTTPS",
              "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
@@ -44,6 +66,7 @@
    "abort": {
      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
      "unique_id_mismatch": "Re-authentication should be used for the same device not a new one"
    }
  },
--- a/homeassistant/components/airq/manifest.json
+++ b/homeassistant/components/airq/manifest.json
@@ -7,5 +7,5 @@
  "integration_type": "hub",
  "iot_class": "local_polling",
  "loggers": ["aioairq"],
-  "requirements": ["aioairq==0.4.6"]
+  "requirements": ["aioairq==0.4.7"]
 }
--- a/homeassistant/components/airq/strings.json
+++ b/homeassistant/components/airq/strings.json
@@ -29,7 +29,7 @@
        },
        "data_description": {
          "return_average": "air-Q allows to poll both the noisy sensor readings as well as the values averaged on the device (default)",
-          "clip_negatives": "For baseline calibration purposes, certain sensor values may briefly become negative. The default behaviour is to clip such values to 0"
+          "clip_negatives": "For baseline calibration purposes, certain sensor values may briefly become negative. The default behavior is to clip such values to 0"
        }
      }
    }
--- a/homeassistant/components/airthings_ble/config_flow.py
+++ b/homeassistant/components/airthings_ble/config_flow.py
@@ -6,8 +6,13 @@ import dataclasses
 import logging
 from typing import Any

-from airthings_ble import AirthingsBluetoothDeviceData, AirthingsDevice
+from airthings_ble import (
+    AirthingsBluetoothDeviceData,
+    AirthingsDevice,
+    UnsupportedDeviceError,
+)
 from bleak import BleakError
+from habluetooth import BluetoothServiceInfoBleak
 import voluptuous as vol

 from homeassistant.components import bluetooth
@@ -27,6 +32,7 @@ SERVICE_UUIDS = [
    "b42e4a8e-ade7-11e4-89d3-123b93f75cba",
    "b42e1c08-ade7-11e4-89d3-123b93f75cba",
    "b42e3882-ade7-11e4-89d3-123b93f75cba",
+    "b42e90a2-ade7-11e4-89d3-123b93f75cba",
 ]


@@ -37,6 +43,7 @@ class Discovery:
    name: str
    discovery_info: BluetoothServiceInfo
    device: AirthingsDevice
+    data: AirthingsBluetoothDeviceData


 def get_name(device: AirthingsDevice) -> str:
@@ -44,7 +51,7 @@ def get_name(device: AirthingsDevice) -> str:

    name = device.friendly_name()
    if identifier := device.identifier:
-        name += f" ({identifier})"
+        name += f" ({device.model.value}{identifier})"
    return name


@@ -62,8 +69,8 @@ class AirthingsConfigFlow(ConfigFlow, domain=DOMAIN):
        self._discovered_device: Discovery | None = None
        self._discovered_devices: dict[str, Discovery] = {}

-    async def _get_device_data(
-        self, discovery_info: BluetoothServiceInfo
+    async def _get_device(
+        self, data: AirthingsBluetoothDeviceData, discovery_info: BluetoothServiceInfo
    ) -> AirthingsDevice:
        ble_device = bluetooth.async_ble_device_from_address(
            self.hass, discovery_info.address
@@ -72,10 +79,8 @@ class AirthingsConfigFlow(ConfigFlow, domain=DOMAIN):
            _LOGGER.debug("no ble_device in _get_device_data")
            raise AirthingsDeviceUpdateError("No ble_device")

-        airthings = AirthingsBluetoothDeviceData(_LOGGER)
-
        try:
-            data = await airthings.update_device(ble_device)
+            device = await data.update_device(ble_device)
        except BleakError as err:
            _LOGGER.error(
                "Error connecting to and getting data from %s: %s",
@@ -83,12 +88,15 @@ class AirthingsConfigFlow(ConfigFlow, domain=DOMAIN):
                err,
            )
            raise AirthingsDeviceUpdateError("Failed getting device data") from err
+        except UnsupportedDeviceError:
+            _LOGGER.debug("Skipping unsupported device: %s", discovery_info.name)
+            raise
        except Exception as err:
            _LOGGER.error(
                "Unknown error occurred from %s: %s", discovery_info.address, err
            )
            raise
-        return data
+        return device

    async def async_step_bluetooth(
        self, discovery_info: BluetoothServiceInfo
@@ -98,17 +106,21 @@ class AirthingsConfigFlow(ConfigFlow, domain=DOMAIN):
        await self.async_set_unique_id(discovery_info.address)
        self._abort_if_unique_id_configured()

+        data = AirthingsBluetoothDeviceData(logger=_LOGGER)
+
        try:
-            device = await self._get_device_data(discovery_info)
+            device = await self._get_device(data=data, discovery_info=discovery_info)
        except AirthingsDeviceUpdateError:
            return self.async_abort(reason="cannot_connect")
+        except UnsupportedDeviceError:
+            return self.async_abort(reason="unsupported_device")
        except Exception:
            _LOGGER.exception("Unknown error occurred")
            return self.async_abort(reason="unknown")

        name = get_name(device)
        self.context["title_placeholders"] = {"name": name}
-        self._discovered_device = Discovery(name, discovery_info, device)
+        self._discovered_device = Discovery(name, discovery_info, device, data=data)

        return await self.async_step_bluetooth_confirm()

@@ -117,6 +129,12 @@ class AirthingsConfigFlow(ConfigFlow, domain=DOMAIN):
    ) -> ConfigFlowResult:
        """Confirm discovery."""
        if user_input is not None:
+            if (
+                self._discovered_device is not None
+                and self._discovered_device.device.firmware.need_firmware_upgrade
+            ):
+                return self.async_abort(reason="firmware_upgrade_required")
+
            return self.async_create_entry(
                title=self.context["title_placeholders"]["name"], data={}
            )
@@ -137,6 +155,9 @@ class AirthingsConfigFlow(ConfigFlow, domain=DOMAIN):
            self._abort_if_unique_id_configured()
            discovery = self._discovered_devices[address]

+            if discovery.device.firmware.need_firmware_upgrade:
+                return self.async_abort(reason="firmware_upgrade_required")
+
            self.context["title_placeholders"] = {
                "name": discovery.name,
            }
@@ -146,26 +167,47 @@ class AirthingsConfigFlow(ConfigFlow, domain=DOMAIN):
            return self.async_create_entry(title=discovery.name, data={})

        current_addresses = self._async_current_ids(include_ignore=False)
+        devices: list[BluetoothServiceInfoBleak] = []
        for discovery_info in async_discovered_service_info(self.hass):
            address = discovery_info.address
            if address in current_addresses or address in self._discovered_devices:
                continue
-
            if MFCT_ID not in discovery_info.manufacturer_data:
                continue
-
            if not any(uuid in SERVICE_UUIDS for uuid in discovery_info.service_uuids):
+                _LOGGER.debug(
+                    "Skipping unsupported device: %s (%s)", discovery_info.name, address
+                )
                continue
+            devices.append(discovery_info)

+        for discovery_info in devices:
+            address = discovery_info.address
+            data = AirthingsBluetoothDeviceData(logger=_LOGGER)
            try:
-                device = await self._get_device_data(discovery_info)
+                device = await self._get_device(data, discovery_info)
            except AirthingsDeviceUpdateError:
-                return self.async_abort(reason="cannot_connect")
+                _LOGGER.error(
+                    "Error connecting to and getting data from %s (%s)",
+                    discovery_info.name,
+                    discovery_info.address,
+                )
+                continue
+            except UnsupportedDeviceError:
+                _LOGGER.debug(
+                    "Skipping unsupported device: %s (%s)",
+                    discovery_info.name,
+                    discovery_info.address,
+                )
+                continue
            except Exception:
                _LOGGER.exception("Unknown error occurred")
                return self.async_abort(reason="unknown")
            name = get_name(device)
-            self._discovered_devices[address] = Discovery(name, discovery_info, device)
+            _LOGGER.debug("Discovered Airthings device: %s (%s)", name, address)
+            self._discovered_devices[address] = Discovery(
+                name, discovery_info, device, data
+            )

        if not self._discovered_devices:
            return self.async_abort(reason="no_devices_found")
--- a/homeassistant/components/airthings_ble/manifest.json
+++ b/homeassistant/components/airthings_ble/manifest.json
@@ -17,6 +17,10 @@
    {
      "manufacturer_id": 820,
      "service_uuid": "b42e3882-ade7-11e4-89d3-123b93f75cba"
+    },
+    {
+      "manufacturer_id": 820,
+      "service_uuid": "b42e90a2-ade7-11e4-89d3-123b93f75cba"
    }
  ],
  "codeowners": ["@vincegio", "@LaStrada"],
@@ -24,5 +28,5 @@
  "dependencies": ["bluetooth_adapters"],
  "documentation": "https://www.home-assistant.io/integrations/airthings_ble",
  "iot_class": "local_polling",
-  "requirements": ["airthings-ble==0.9.2"]
+  "requirements": ["airthings-ble==1.1.1"]
 }
--- a/homeassistant/components/airthings_ble/sensor.py
+++ b/homeassistant/components/airthings_ble/sensor.py
@@ -16,10 +16,12 @@ from homeassistant.components.sensor import (
 from homeassistant.const import (
    CONCENTRATION_PARTS_PER_BILLION,
    CONCENTRATION_PARTS_PER_MILLION,
+    LIGHT_LUX,
    PERCENTAGE,
    EntityCategory,
    Platform,
    UnitOfPressure,
+    UnitOfSoundPressure,
    UnitOfTemperature,
 )
 from homeassistant.core import HomeAssistant, callback
@@ -112,6 +114,21 @@ SENSORS_MAPPING_TEMPLATE: dict[str, SensorEntityDescription] = {
        state_class=SensorStateClass.MEASUREMENT,
        suggested_display_precision=0,
    ),
+    "lux": SensorEntityDescription(
+        key="lux",
+        device_class=SensorDeviceClass.ILLUMINANCE,
+        native_unit_of_measurement=LIGHT_LUX,
+        state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=0,
+    ),
+    "noise": SensorEntityDescription(
+        key="noise",
+        translation_key="ambient_noise",
+        device_class=SensorDeviceClass.SOUND_PRESSURE,
+        native_unit_of_measurement=UnitOfSoundPressure.WEIGHTED_DECIBEL_A,
+        state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=0,
+    ),
 }

 PARALLEL_UPDATES = 0
--- a/homeassistant/components/airthings_ble/strings.json
+++ b/homeassistant/components/airthings_ble/strings.json
@@ -20,6 +20,8 @@
      "already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "firmware_upgrade_required": "Your device requires a firmware upgrade. Please use the Airthings app (Android/iOS) to upgrade it.",
+      "unsupported_device": "Unsupported device",
      "unknown": "[%key:common::config_flow::error::unknown%]"
    }
  },
@@ -39,6 +41,9 @@
      },
      "illuminance": {
        "name": "[%key:component::sensor::entity_component::illuminance::name%]"
+      },
+      "ambient_noise": {
+        "name": "Ambient noise"
      }
    }
  }
--- a/homeassistant/components/alarm_control_panel/init.py
+++ b/homeassistant/components/alarm_control_panel/init.py
@@ -2,10 +2,9 @@

 from __future__ import annotations

-import asyncio
 from datetime import timedelta
 import logging
-from typing import TYPE_CHECKING, Any, Final, final
+from typing import Any, Final, final

 from propcache.api import cached_property
 import voluptuous as vol
@@ -28,8 +27,6 @@ from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.config_validation import make_entity_service_schema
 from homeassistant.helpers.entity import Entity, EntityDescription
 from homeassistant.helpers.entity_component import EntityComponent
-from homeassistant.helpers.entity_platform import EntityPlatform
-from homeassistant.helpers.frame import ReportBehavior, report_usage
 from homeassistant.helpers.typing import ConfigType
 from homeassistant.util.hass_dict import HassKey

@@ -149,68 +146,11 @@ class AlarmControlPanelEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_A
    )
    _alarm_control_panel_option_default_code: str | None = None

-    __alarm_legacy_state: bool = False
-
-    def __init_subclass__(cls, **kwargs: Any) -> None:
-        """Post initialisation processing."""
-        super().__init_subclass__(**kwargs)
-        if any(method in cls.__dict__ for method in ("_attr_state", "state")):
-            # Integrations should use the 'alarm_state' property instead of
-            # setting the state directly.
-            cls.__alarm_legacy_state = True
-
-    def __setattr__(self, name: str, value: Any, /) -> None:
-        """Set attribute.
-
-        Deprecation warning if setting '_attr_state' directly
-        unless already reported.
-        """
-        if name == "_attr_state":
-            self._report_deprecated_alarm_state_handling()
-        return super().__setattr__(name, value)
-
-    @callback
-    def add_to_platform_start(
-        self,
-        hass: HomeAssistant,
-        platform: EntityPlatform,
-        parallel_updates: asyncio.Semaphore | None,
-    ) -> None:
-        """Start adding an entity to a platform."""
-        super().add_to_platform_start(hass, platform, parallel_updates)
-        if self.__alarm_legacy_state:
-            self._report_deprecated_alarm_state_handling()
-
-    @callback
-    def _report_deprecated_alarm_state_handling(self) -> None:
-        """Report on deprecated handling of alarm state.
-
-        Integrations should implement alarm_state instead of using state directly.
-        """
-        report_usage(
-            "is setting state directly."
-            f" Entity {self.entity_id} ({type(self)}) should implement the 'alarm_state'"
-            " property and return its state using the AlarmControlPanelState enum",
-            core_integration_behavior=ReportBehavior.ERROR,
-            custom_integration_behavior=ReportBehavior.LOG,
-            breaks_in_ha_version="2025.11",
-            integration_domain=self.platform.platform_name if self.platform else None,
-            exclude_integrations={DOMAIN},
-        )
-
    @final
    @property
    def state(self) -> str | None:
        """Return the current state."""
-        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
+        return self.alarm_state

    @cached_property
    def alarm_state(self) -> AlarmControlPanelState | None:
--- a/homeassistant/components/alexa/capabilities.py
+++ b/homeassistant/components/alexa/capabilities.py
@@ -1472,10 +1472,10 @@ class AlexaModeController(AlexaCapability):
            # Return state instead of position when using ModeController.
            mode = self.entity.state
            if mode in (
-                cover.STATE_OPEN,
-                cover.STATE_OPENING,
-                cover.STATE_CLOSED,
-                cover.STATE_CLOSING,
+                cover.CoverState.OPEN,
+                cover.CoverState.OPENING,
+                cover.CoverState.CLOSED,
+                cover.CoverState.CLOSING,
                STATE_UNKNOWN,
            ):
                return f"{cover.ATTR_POSITION}.{mode}"
@@ -1594,11 +1594,11 @@ class AlexaModeController(AlexaCapability):
                ["Position", AlexaGlobalCatalog.SETTING_OPENING], False
            )
            self._resource.add_mode(
-                f"{cover.ATTR_POSITION}.{cover.STATE_OPEN}",
+                f"{cover.ATTR_POSITION}.{cover.CoverState.OPEN}",
                [AlexaGlobalCatalog.VALUE_OPEN],
            )
            self._resource.add_mode(
-                f"{cover.ATTR_POSITION}.{cover.STATE_CLOSED}",
+                f"{cover.ATTR_POSITION}.{cover.CoverState.CLOSED}",
                [AlexaGlobalCatalog.VALUE_CLOSE],
            )
            self._resource.add_mode(
@@ -1651,22 +1651,22 @@ class AlexaModeController(AlexaCapability):
                raise_labels.append(AlexaSemantics.ACTION_OPEN)
                self._semantics.add_states_to_value(
                    [AlexaSemantics.STATES_CLOSED],
-                    f"{cover.ATTR_POSITION}.{cover.STATE_CLOSED}",
+                    f"{cover.ATTR_POSITION}.{cover.CoverState.CLOSED}",
                )
                self._semantics.add_states_to_value(
                    [AlexaSemantics.STATES_OPEN],
-                    f"{cover.ATTR_POSITION}.{cover.STATE_OPEN}",
+                    f"{cover.ATTR_POSITION}.{cover.CoverState.OPEN}",
                )

            self._semantics.add_action_to_directive(
                lower_labels,
                "SetMode",
-                {"mode": f"{cover.ATTR_POSITION}.{cover.STATE_CLOSED}"},
+                {"mode": f"{cover.ATTR_POSITION}.{cover.CoverState.CLOSED}"},
            )
            self._semantics.add_action_to_directive(
                raise_labels,
                "SetMode",
-                {"mode": f"{cover.ATTR_POSITION}.{cover.STATE_OPEN}"},
+                {"mode": f"{cover.ATTR_POSITION}.{cover.CoverState.OPEN}"},
            )

            return self._semantics.serialize_semantics()
--- a/homeassistant/components/alexa/handlers.py
+++ b/homeassistant/components/alexa/handlers.py
@@ -1261,9 +1261,9 @@ async def async_api_set_mode(
    elif instance == f"{cover.DOMAIN}.{cover.ATTR_POSITION}":
        position = mode.split(".")[1]

-        if position == cover.STATE_CLOSED:
+        if position == cover.CoverState.CLOSED:
            service = cover.SERVICE_CLOSE_COVER
-        elif position == cover.STATE_OPEN:
+        elif position == cover.CoverState.OPEN:
            service = cover.SERVICE_OPEN_COVER
        elif position == "custom":
            service = cover.SERVICE_STOP_COVER
--- a/homeassistant/components/alexa_devices/binary_sensor.py
+++ b/homeassistant/components/alexa_devices/binary_sensor.py
@@ -18,7 +18,9 @@ from homeassistant.components.binary_sensor import (
 from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+import homeassistant.helpers.entity_registry as er

+from .const import _LOGGER, DOMAIN
 from .coordinator import AmazonConfigEntry
 from .entity import AmazonEntity
 from .utils import async_update_unique_id
@@ -51,11 +53,47 @@ BINARY_SENSORS: Final = (
        ),
        is_supported=lambda device, key: device.sensors.get(key) is not None,
        is_available_fn=lambda device, key: (
-            device.online and device.sensors[key].error is False
+            device.online
+            and (sensor := device.sensors.get(key)) is not None
+            and sensor.error is False
        ),
    ),
 )

+DEPRECATED_BINARY_SENSORS: Final = (
+    AmazonBinarySensorEntityDescription(
+        key="bluetooth",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        translation_key="bluetooth",
+        is_on_fn=lambda device, key: False,
+    ),
+    AmazonBinarySensorEntityDescription(
+        key="babyCryDetectionState",
+        translation_key="baby_cry_detection",
+        is_on_fn=lambda device, key: False,
+    ),
+    AmazonBinarySensorEntityDescription(
+        key="beepingApplianceDetectionState",
+        translation_key="beeping_appliance_detection",
+        is_on_fn=lambda device, key: False,
+    ),
+    AmazonBinarySensorEntityDescription(
+        key="coughDetectionState",
+        translation_key="cough_detection",
+        is_on_fn=lambda device, key: False,
+    ),
+    AmazonBinarySensorEntityDescription(
+        key="dogBarkDetectionState",
+        translation_key="dog_bark_detection",
+        is_on_fn=lambda device, key: False,
+    ),
+    AmazonBinarySensorEntityDescription(
+        key="waterSoundsDetectionState",
+        translation_key="water_sounds_detection",
+        is_on_fn=lambda device, key: False,
+    ),
+)
+

 async def async_setup_entry(
    hass: HomeAssistant,
@@ -66,6 +104,8 @@ async def async_setup_entry(

    coordinator = entry.runtime_data

+    entity_registry = er.async_get(hass)
+
    # Replace unique id for "detectionState" binary sensor
    await async_update_unique_id(
        hass,
@@ -75,6 +115,16 @@ async def async_setup_entry(
        "detectionState",
    )

+    # Clean up deprecated sensors
+    for sensor_desc in DEPRECATED_BINARY_SENSORS:
+        for serial_num in coordinator.data:
+            unique_id = f"{serial_num}-{sensor_desc.key}"
+            if entity_id := entity_registry.async_get_entity_id(
+                BINARY_SENSOR_DOMAIN, DOMAIN, unique_id
+            ):
+                _LOGGER.debug("Removing deprecated entity %s", entity_id)
+                entity_registry.async_remove(entity_id)
+
    known_devices: set[str] = set()

    def _check_device() -> None:
--- a/homeassistant/components/alexa_devices/manifest.json
+++ b/homeassistant/components/alexa_devices/manifest.json
@@ -8,5 +8,5 @@
  "iot_class": "cloud_polling",
  "loggers": ["aioamazondevices"],
  "quality_scale": "platinum",
-  "requirements": ["aioamazondevices==6.2.7"]
+  "requirements": ["aioamazondevices==6.4.6"]
 }
--- a/homeassistant/components/alexa_devices/sensor.py
+++ b/homeassistant/components/alexa_devices/sensor.py
@@ -32,7 +32,9 @@ class AmazonSensorEntityDescription(SensorEntityDescription):

    native_unit_of_measurement_fn: Callable[[AmazonDevice, str], str] | None = None
    is_available_fn: Callable[[AmazonDevice, str], bool] = lambda device, key: (
-        device.online and device.sensors[key].error is False
+        device.online
+        and (sensor := device.sensors.get(key)) is not None
+        and sensor.error is False
    )


@@ -40,9 +42,9 @@ SENSORS: Final = (
    AmazonSensorEntityDescription(
        key="temperature",
        device_class=SensorDeviceClass.TEMPERATURE,
-        native_unit_of_measurement_fn=lambda device, _key: (
+        native_unit_of_measurement_fn=lambda device, key: (
            UnitOfTemperature.CELSIUS
-            if device.sensors[_key].scale == "CELSIUS"
+            if key in device.sensors and device.sensors[key].scale == "CELSIUS"
            else UnitOfTemperature.FAHRENHEIT
        ),
        state_class=SensorStateClass.MEASUREMENT,
--- a/homeassistant/components/alexa_devices/switch.py
+++ b/homeassistant/components/alexa_devices/switch.py
@@ -18,7 +18,11 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback

 from .coordinator import AmazonConfigEntry
 from .entity import AmazonEntity
-from .utils import alexa_api_call, async_update_unique_id
+from .utils import (
+    alexa_api_call,
+    async_remove_dnd_from_virtual_group,
+    async_update_unique_id,
+)

 PARALLEL_UPDATES = 1

@@ -29,7 +33,9 @@ class AmazonSwitchEntityDescription(SwitchEntityDescription):

    is_on_fn: Callable[[AmazonDevice], bool]
    is_available_fn: Callable[[AmazonDevice, str], bool] = lambda device, key: (
-        device.online and device.sensors[key].error is False
+        device.online
+        and (sensor := device.sensors.get(key)) is not None
+        and sensor.error is False
    )
    method: str

@@ -58,6 +64,9 @@ async def async_setup_entry(
        hass, coordinator, SWITCH_DOMAIN, "do_not_disturb", "dnd"
    )

+    # Remove DND switch from virtual groups
+    await async_remove_dnd_from_virtual_group(hass, coordinator)
+
    known_devices: set[str] = set()

    def _check_device() -> None:
--- a/homeassistant/components/alexa_devices/utils.py
+++ b/homeassistant/components/alexa_devices/utils.py
@@ -4,8 +4,10 @@ from collections.abc import Awaitable, Callable, Coroutine
 from functools import wraps
 from typing import Any, Concatenate

+from aioamazondevices.const import SPEAKER_GROUP_FAMILY
 from aioamazondevices.exceptions import CannotConnect, CannotRetrieveData

+from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 import homeassistant.helpers.entity_registry as er
@@ -61,3 +63,21 @@ async def async_update_unique_id(

            # Update the registry with the new unique_id
            entity_registry.async_update_entity(entity_id, new_unique_id=new_unique_id)
+
+
+async def async_remove_dnd_from_virtual_group(
+    hass: HomeAssistant,
+    coordinator: AmazonDevicesCoordinator,
+) -> None:
+    """Remove entity DND from virtual group."""
+    entity_registry = er.async_get(hass)
+
+    for serial_num in coordinator.data:
+        unique_id = f"{serial_num}-do_not_disturb"
+        entity_id = entity_registry.async_get_entity_id(
+            DOMAIN, SWITCH_DOMAIN, unique_id
+        )
+        is_group = coordinator.data[serial_num].device_family == SPEAKER_GROUP_FAMILY
+        if entity_id and is_group:
+            entity_registry.async_remove(entity_id)
+            _LOGGER.debug("Removed DND switch from virtual group %s", entity_id)
--- a/homeassistant/components/altruist/sensor.py
+++ b/homeassistant/components/altruist/sensor.py
@@ -65,6 +65,31 @@ SENSOR_DESCRIPTIONS = [
        suggested_display_precision=2,
        translation_placeholders={"sensor_name": "BME280"},
    ),
+    AltruistSensorEntityDescription(
+        device_class=SensorDeviceClass.HUMIDITY,
+        key="BME680_humidity",
+        translation_key="humidity",
+        native_unit_of_measurement=PERCENTAGE,
+        suggested_display_precision=2,
+        translation_placeholders={"sensor_name": "BME680"},
+    ),
+    AltruistSensorEntityDescription(
+        device_class=SensorDeviceClass.PRESSURE,
+        key="BME680_pressure",
+        translation_key="pressure",
+        native_unit_of_measurement=UnitOfPressure.PA,
+        suggested_unit_of_measurement=UnitOfPressure.MMHG,
+        suggested_display_precision=0,
+        translation_placeholders={"sensor_name": "BME680"},
+    ),
+    AltruistSensorEntityDescription(
+        device_class=SensorDeviceClass.TEMPERATURE,
+        key="BME680_temperature",
+        translation_key="temperature",
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        suggested_display_precision=2,
+        translation_placeholders={"sensor_name": "BME680"},
+    ),
    AltruistSensorEntityDescription(
        device_class=SensorDeviceClass.PRESSURE,
        key="BMP_pressure",
--- a/homeassistant/components/androidtv_remote/config_flow.py
+++ b/homeassistant/components/androidtv_remote/config_flow.py
@@ -41,6 +41,11 @@ APPS_NEW_ID = "add_new"
 CONF_APP_DELETE = "app_delete"
 CONF_APP_ID = "app_id"

+_EXAMPLE_APP_ID = "com.plexapp.android"
+_EXAMPLE_APP_PLAY_STORE_URL = (
+    f"https://play.google.com/store/apps/details?id={_EXAMPLE_APP_ID}"
+)
+
 STEP_PAIR_DATA_SCHEMA = vol.Schema(
    {
        vol.Required("pin"): str,
@@ -355,5 +360,7 @@ class AndroidTVRemoteOptionsFlowHandler(OptionsFlowWithReload):
            data_schema=data_schema,
            description_placeholders={
                "app_id": f"`{app_id}`" if app_id != APPS_NEW_ID else "",
+                "example_app_id": _EXAMPLE_APP_ID,
+                "example_app_play_store_url": _EXAMPLE_APP_PLAY_STORE_URL,
            },
        )
--- a/homeassistant/components/androidtv_remote/strings.json
+++ b/homeassistant/components/androidtv_remote/strings.json
@@ -75,7 +75,7 @@
        },
        "data_description": {
          "app_name": "Name of the application as you would like it to be displayed in Home Assistant.",
-          "app_id": "E.g. com.plexapp.android for https://play.google.com/store/apps/details?id=com.plexapp.android",
+          "app_id": "E.g. {example_app_id} for {example_app_play_store_url}",
          "app_icon": "Image URL. From the Play Store app page, right click on the icon and select 'Copy image address' and then paste it here. Alternatively, download the image, upload it under /config/www/ and use the URL /local/filename",
          "app_delete": "Check this box to delete the application from the list."
        }
--- a/homeassistant/components/anthropic/config_flow.py
+++ b/homeassistant/components/anthropic/config_flow.py
@@ -4,12 +4,15 @@ from __future__ import annotations

 from collections.abc import Mapping
 from functools import partial
+import json
 import logging
 from typing import Any, cast

 import anthropic
 import voluptuous as vol
+from voluptuous_openapi import convert

+from homeassistant.components.zone import ENTITY_ID_HOME
 from homeassistant.config_entries import (
    ConfigEntry,
    ConfigEntryState,
@@ -18,7 +21,13 @@ from homeassistant.config_entries import (
    ConfigSubentryFlow,
    SubentryFlowResult,
 )
-from homeassistant.const import CONF_API_KEY, CONF_LLM_HASS_API, CONF_NAME
+from homeassistant.const import (
+    ATTR_LATITUDE,
+    ATTR_LONGITUDE,
+    CONF_API_KEY,
+    CONF_LLM_HASS_API,
+    CONF_NAME,
+)
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import llm
 from homeassistant.helpers.selector import (
@@ -37,12 +46,23 @@ from .const import (
    CONF_RECOMMENDED,
    CONF_TEMPERATURE,
    CONF_THINKING_BUDGET,
+    CONF_WEB_SEARCH,
+    CONF_WEB_SEARCH_CITY,
+    CONF_WEB_SEARCH_COUNTRY,
+    CONF_WEB_SEARCH_MAX_USES,
+    CONF_WEB_SEARCH_REGION,
+    CONF_WEB_SEARCH_TIMEZONE,
+    CONF_WEB_SEARCH_USER_LOCATION,
    DEFAULT_CONVERSATION_NAME,
    DOMAIN,
    RECOMMENDED_CHAT_MODEL,
    RECOMMENDED_MAX_TOKENS,
    RECOMMENDED_TEMPERATURE,
    RECOMMENDED_THINKING_BUDGET,
+    RECOMMENDED_WEB_SEARCH,
+    RECOMMENDED_WEB_SEARCH_MAX_USES,
+    RECOMMENDED_WEB_SEARCH_USER_LOCATION,
+    WEB_SEARCH_UNSUPPORTED_MODELS,
 )

 _LOGGER = logging.getLogger(__name__)
@@ -168,6 +188,14 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
                CONF_THINKING_BUDGET, RECOMMENDED_THINKING_BUDGET
            ) >= user_input.get(CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS):
                errors[CONF_THINKING_BUDGET] = "thinking_budget_too_large"
+            if user_input.get(CONF_WEB_SEARCH, RECOMMENDED_WEB_SEARCH):
+                model = user_input.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL)
+                if model.startswith(tuple(WEB_SEARCH_UNSUPPORTED_MODELS)):
+                    errors[CONF_WEB_SEARCH] = "web_search_unsupported_model"
+                elif user_input.get(
+                    CONF_WEB_SEARCH_USER_LOCATION, RECOMMENDED_WEB_SEARCH_USER_LOCATION
+                ):
+                    user_input.update(await self._get_location_data())

            if not errors:
                if self._is_new:
@@ -215,6 +243,68 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
            errors=errors or None,
        )

+    async def _get_location_data(self) -> dict[str, str]:
+        """Get approximate location data of the user."""
+        location_data: dict[str, str] = {}
+        zone_home = self.hass.states.get(ENTITY_ID_HOME)
+        if zone_home is not None:
+            client = await self.hass.async_add_executor_job(
+                partial(
+                    anthropic.AsyncAnthropic,
+                    api_key=self._get_entry().data[CONF_API_KEY],
+                )
+            )
+            location_schema = vol.Schema(
+                {
+                    vol.Optional(
+                        CONF_WEB_SEARCH_CITY,
+                        description="Free text input for the city, e.g. `San Francisco`",
+                    ): str,
+                    vol.Optional(
+                        CONF_WEB_SEARCH_REGION,
+                        description="Free text input for the region, e.g. `California`",
+                    ): str,
+                }
+            )
+            response = await client.messages.create(
+                model=RECOMMENDED_CHAT_MODEL,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": "Where are the following coordinates located: "
+                        f"({zone_home.attributes[ATTR_LATITUDE]},"
+                        f" {zone_home.attributes[ATTR_LONGITUDE]})? Please respond "
+                        "only with a JSON object using the following schema:\n"
+                        f"{convert(location_schema)}",
+                    },
+                    {
+                        "role": "assistant",
+                        "content": "{",  # hints the model to skip any preamble
+                    },
+                ],
+                max_tokens=RECOMMENDED_MAX_TOKENS,
+            )
+            _LOGGER.debug("Model response: %s", response.content)
+            location_data = location_schema(
+                json.loads(
+                    "{"
+                    + "".join(
+                        block.text
+                        for block in response.content
+                        if isinstance(block, anthropic.types.TextBlock)
+                    )
+                )
+                or {}
+            )
+
+        if self.hass.config.country:
+            location_data[CONF_WEB_SEARCH_COUNTRY] = self.hass.config.country
+        location_data[CONF_WEB_SEARCH_TIMEZONE] = self.hass.config.time_zone
+
+        _LOGGER.debug("Location data: %s", location_data)
+
+        return location_data
+
    async_step_user = async_step_set_options
    async_step_reconfigure = async_step_set_options

@@ -273,6 +363,18 @@ def anthropic_config_option_schema(
                CONF_THINKING_BUDGET,
                default=RECOMMENDED_THINKING_BUDGET,
            ): int,
+            vol.Optional(
+                CONF_WEB_SEARCH,
+                default=RECOMMENDED_WEB_SEARCH,
+            ): bool,
+            vol.Optional(
+                CONF_WEB_SEARCH_MAX_USES,
+                default=RECOMMENDED_WEB_SEARCH_MAX_USES,
+            ): int,
+            vol.Optional(
+                CONF_WEB_SEARCH_USER_LOCATION,
+                default=RECOMMENDED_WEB_SEARCH_USER_LOCATION,
+            ): bool,
        }
    )
    return schema
--- a/homeassistant/components/anthropic/const.py
+++ b/homeassistant/components/anthropic/const.py
@@ -18,10 +18,26 @@ RECOMMENDED_TEMPERATURE = 1.0
 CONF_THINKING_BUDGET = "thinking_budget"
 RECOMMENDED_THINKING_BUDGET = 0
 MIN_THINKING_BUDGET = 1024
+CONF_WEB_SEARCH = "web_search"
+RECOMMENDED_WEB_SEARCH = False
+CONF_WEB_SEARCH_USER_LOCATION = "user_location"
+RECOMMENDED_WEB_SEARCH_USER_LOCATION = False
+CONF_WEB_SEARCH_MAX_USES = "web_search_max_uses"
+RECOMMENDED_WEB_SEARCH_MAX_USES = 5
+CONF_WEB_SEARCH_CITY = "city"
+CONF_WEB_SEARCH_REGION = "region"
+CONF_WEB_SEARCH_COUNTRY = "country"
+CONF_WEB_SEARCH_TIMEZONE = "timezone"

-THINKING_MODELS = [
-    "claude-3-7-sonnet",
-    "claude-sonnet-4-0",
-    "claude-opus-4-0",
-    "claude-opus-4-1",
+NON_THINKING_MODELS = [
+    "claude-3-5",  # Both sonnet and haiku
+    "claude-3-opus",
+    "claude-3-haiku",
+]
+
+WEB_SEARCH_UNSUPPORTED_MODELS = [
+    "claude-3-haiku",
+    "claude-3-opus",
+    "claude-3-5-sonnet-20240620",
+    "claude-3-5-sonnet-20241022",
 ]
--- a/homeassistant/components/anthropic/entity.py
+++ b/homeassistant/components/anthropic/entity.py
@@ -1,12 +1,17 @@
 """Base entity for Anthropic."""

 from collections.abc import AsyncGenerator, Callable, Iterable
+from dataclasses import dataclass, field
 import json
 from typing import Any

 import anthropic
 from anthropic import AsyncStream
 from anthropic.types import (
+    CitationsDelta,
+    CitationsWebSearchResultLocation,
+    CitationWebSearchResultLocationParam,
+    ContentBlockParam,
    InputJSONDelta,
    MessageDeltaUsage,
    MessageParam,
@@ -16,11 +21,16 @@ from anthropic.types import (
    RawContentBlockStopEvent,
    RawMessageDeltaEvent,
    RawMessageStartEvent,
+    RawMessageStopEvent,
    RedactedThinkingBlock,
    RedactedThinkingBlockParam,
+    ServerToolUseBlock,
+    ServerToolUseBlockParam,
    SignatureDelta,
    TextBlock,
    TextBlockParam,
+    TextCitation,
+    TextCitationParam,
    TextDelta,
    ThinkingBlock,
    ThinkingBlockParam,
@@ -29,9 +39,15 @@ from anthropic.types import (
    ThinkingDelta,
    ToolParam,
    ToolResultBlockParam,
+    ToolUnionParam,
    ToolUseBlock,
    ToolUseBlockParam,
    Usage,
+    WebSearchTool20250305Param,
+    WebSearchToolRequestErrorParam,
+    WebSearchToolResultBlock,
+    WebSearchToolResultBlockParam,
+    WebSearchToolResultError,
 )
 from anthropic.types.message_create_params import MessageCreateParamsStreaming
 from voluptuous_openapi import convert
@@ -48,14 +64,21 @@ from .const import (
    CONF_MAX_TOKENS,
    CONF_TEMPERATURE,
    CONF_THINKING_BUDGET,
+    CONF_WEB_SEARCH,
+    CONF_WEB_SEARCH_CITY,
+    CONF_WEB_SEARCH_COUNTRY,
+    CONF_WEB_SEARCH_MAX_USES,
+    CONF_WEB_SEARCH_REGION,
+    CONF_WEB_SEARCH_TIMEZONE,
+    CONF_WEB_SEARCH_USER_LOCATION,
    DOMAIN,
    LOGGER,
    MIN_THINKING_BUDGET,
+    NON_THINKING_MODELS,
    RECOMMENDED_CHAT_MODEL,
    RECOMMENDED_MAX_TOKENS,
    RECOMMENDED_TEMPERATURE,
    RECOMMENDED_THINKING_BUDGET,
-    THINKING_MODELS,
 )

 # Max number of back and forth with the LLM to generate a response
@@ -73,6 +96,69 @@ def _format_tool(
    )


+@dataclass(slots=True)
+class CitationDetails:
+    """Citation details for a content part."""
+
+    index: int = 0
+    """Start position of the text."""
+
+    length: int = 0
+    """Length of the relevant data."""
+
+    citations: list[TextCitationParam] = field(default_factory=list)
+    """Citations for the content part."""
+
+
+@dataclass(slots=True)
+class ContentDetails:
+    """Native data for AssistantContent."""
+
+    citation_details: list[CitationDetails] = field(default_factory=list)
+
+    def has_content(self) -> bool:
+        """Check if there is any content."""
+        return any(detail.length > 0 for detail in self.citation_details)
+
+    def has_citations(self) -> bool:
+        """Check if there are any citations."""
+        return any(detail.citations for detail in self.citation_details)
+
+    def add_citation_detail(self) -> None:
+        """Add a new citation detail."""
+        if not self.citation_details or self.citation_details[-1].length > 0:
+            self.citation_details.append(
+                CitationDetails(
+                    index=self.citation_details[-1].index
+                    + self.citation_details[-1].length
+                    if self.citation_details
+                    else 0
+                )
+            )
+
+    def add_citation(self, citation: TextCitation) -> None:
+        """Add a citation to the current detail."""
+        if not self.citation_details:
+            self.citation_details.append(CitationDetails())
+        citation_param: TextCitationParam | None = None
+        if isinstance(citation, CitationsWebSearchResultLocation):
+            citation_param = CitationWebSearchResultLocationParam(
+                type="web_search_result_location",
+                title=citation.title,
+                url=citation.url,
+                cited_text=citation.cited_text,
+                encrypted_index=citation.encrypted_index,
+            )
+        if citation_param:
+            self.citation_details[-1].citations.append(citation_param)
+
+    def delete_empty(self) -> None:
+        """Delete empty citation details."""
+        self.citation_details = [
+            detail for detail in self.citation_details if detail.citations
+        ]
+
+
 def _convert_content(
    chat_content: Iterable[conversation.Content],
 ) -> list[MessageParam]:
@@ -81,15 +167,31 @@ def _convert_content(

    for content in chat_content:
        if isinstance(content, conversation.ToolResultContent):
-            tool_result_block = ToolResultBlockParam(
-                type="tool_result",
-                tool_use_id=content.tool_call_id,
-                content=json.dumps(content.tool_result),
-            )
-            if not messages or messages[-1]["role"] != "user":
+            if content.tool_name == "web_search":
+                tool_result_block: ContentBlockParam = WebSearchToolResultBlockParam(
+                    type="web_search_tool_result",
+                    tool_use_id=content.tool_call_id,
+                    content=content.tool_result["content"]
+                    if "content" in content.tool_result
+                    else WebSearchToolRequestErrorParam(
+                        type="web_search_tool_result_error",
+                        error_code=content.tool_result.get("error_code", "unavailable"),  # type: ignore[typeddict-item]
+                    ),
+                )
+                external_tool = True
+            else:
+                tool_result_block = ToolResultBlockParam(
+                    type="tool_result",
+                    tool_use_id=content.tool_call_id,
+                    content=json.dumps(content.tool_result),
+                )
+                external_tool = False
+            if not messages or messages[-1]["role"] != (
+                "assistant" if external_tool else "user"
+            ):
                messages.append(
                    MessageParam(
-                        role="user",
+                        role="assistant" if external_tool else "user",
                        content=[tool_result_block],
                    )
                )
@@ -151,13 +253,56 @@ def _convert_content(
                        redacted_thinking_block
                    )
            if content.content:
-                messages[-1]["content"].append(  # type: ignore[union-attr]
-                    TextBlockParam(type="text", text=content.content)
-                )
+                current_index = 0
+                for detail in (
+                    content.native.citation_details
+                    if isinstance(content.native, ContentDetails)
+                    else [CitationDetails(length=len(content.content))]
+                ):
+                    if detail.index > current_index:
+                        # Add text block for any text without citations
+                        messages[-1]["content"].append(  # type: ignore[union-attr]
+                            TextBlockParam(
+                                type="text",
+                                text=content.content[current_index : detail.index],
+                            )
+                        )
+                    messages[-1]["content"].append(  # type: ignore[union-attr]
+                        TextBlockParam(
+                            type="text",
+                            text=content.content[
+                                detail.index : detail.index + detail.length
+                            ],
+                            citations=detail.citations,
+                        )
+                        if detail.citations
+                        else TextBlockParam(
+                            type="text",
+                            text=content.content[
+                                detail.index : detail.index + detail.length
+                            ],
+                        )
+                    )
+                    current_index = detail.index + detail.length
+                if current_index < len(content.content):
+                    # Add text block for any remaining text without citations
+                    messages[-1]["content"].append(  # type: ignore[union-attr]
+                        TextBlockParam(
+                            type="text",
+                            text=content.content[current_index:],
+                        )
+                    )
            if content.tool_calls:
                messages[-1]["content"].extend(  # type: ignore[union-attr]
                    [
-                        ToolUseBlockParam(
+                        ServerToolUseBlockParam(
+                            type="server_tool_use",
+                            id=tool_call.id,
+                            name="web_search",
+                            input=tool_call.tool_args,
+                        )
+                        if tool_call.external and tool_call.tool_name == "web_search"
+                        else ToolUseBlockParam(
                            type="tool_use",
                            id=tool_call.id,
                            name=tool_call.tool_name,
@@ -173,10 +318,12 @@ def _convert_content(
    return messages


-async def _transform_stream(
+async def _transform_stream(  # noqa: C901 - This is complex, but better to have it in one place
    chat_log: conversation.ChatLog,
    stream: AsyncStream[MessageStreamEvent],
-) -> AsyncGenerator[conversation.AssistantContentDeltaDict]:
+) -> AsyncGenerator[
+    conversation.AssistantContentDeltaDict | conversation.ToolResultContentDeltaDict
+]:
    """Transform the response stream into HA format.

    A typical stream of responses might look something like the following:
@@ -209,11 +356,13 @@ async def _transform_stream(
    if stream is None:
        raise TypeError("Expected a stream of messages")

-    current_tool_block: ToolUseBlockParam | None = None
+    current_tool_block: ToolUseBlockParam | ServerToolUseBlockParam | None = None
    current_tool_args: str
+    content_details = ContentDetails()
+    content_details.add_citation_detail()
    input_usage: Usage | None = None
-    has_content = False
    has_native = False
+    first_block: bool

    async for response in stream:
        LOGGER.debug("Received response: %s", response)
@@ -222,6 +371,7 @@ async def _transform_stream(
            if response.message.role != "assistant":
                raise ValueError("Unexpected message role")
            input_usage = response.message.usage
+            first_block = True
        elif isinstance(response, RawContentBlockStartEvent):
            if isinstance(response.content_block, ToolUseBlock):
                current_tool_block = ToolUseBlockParam(
@@ -232,17 +382,37 @@ async def _transform_stream(
                )
                current_tool_args = ""
            elif isinstance(response.content_block, TextBlock):
-                if has_content:
+                if (  # Do not start a new assistant content just for citations, concatenate consecutive blocks with citations instead.
+                    first_block
+                    or (
+                        not content_details.has_citations()
+                        and response.content_block.citations is None
+                        and content_details.has_content()
+                    )
+                ):
+                    if content_details.has_citations():
+                        content_details.delete_empty()
+                        yield {"native": content_details}
+                    content_details = ContentDetails()
                    yield {"role": "assistant"}
                    has_native = False
-                has_content = True
+                    first_block = False
+                content_details.add_citation_detail()
                if response.content_block.text:
+                    content_details.citation_details[-1].length += len(
+                        response.content_block.text
+                    )
                    yield {"content": response.content_block.text}
            elif isinstance(response.content_block, ThinkingBlock):
-                if has_native:
+                if first_block or has_native:
+                    if content_details.has_citations():
+                        content_details.delete_empty()
+                        yield {"native": content_details}
+                    content_details = ContentDetails()
+                    content_details.add_citation_detail()
                    yield {"role": "assistant"}
                    has_native = False
-                    has_content = False
+                    first_block = False
            elif isinstance(response.content_block, RedactedThinkingBlock):
                LOGGER.debug(
                    "Some of Claude’s internal reasoning has been automatically "
@@ -250,15 +420,60 @@ async def _transform_stream(
                    "responses"
                )
                if has_native:
+                    if content_details.has_citations():
+                        content_details.delete_empty()
+                        yield {"native": content_details}
+                    content_details = ContentDetails()
+                    content_details.add_citation_detail()
                    yield {"role": "assistant"}
                    has_native = False
-                    has_content = False
+                    first_block = False
                yield {"native": response.content_block}
                has_native = True
+            elif isinstance(response.content_block, ServerToolUseBlock):
+                current_tool_block = ServerToolUseBlockParam(
+                    type="server_tool_use",
+                    id=response.content_block.id,
+                    name=response.content_block.name,
+                    input="",
+                )
+                current_tool_args = ""
+            elif isinstance(response.content_block, WebSearchToolResultBlock):
+                if content_details.has_citations():
+                    content_details.delete_empty()
+                    yield {"native": content_details}
+                content_details = ContentDetails()
+                content_details.add_citation_detail()
+                yield {
+                    "role": "tool_result",
+                    "tool_call_id": response.content_block.tool_use_id,
+                    "tool_name": "web_search",
+                    "tool_result": {
+                        "type": "web_search_tool_result_error",
+                        "error_code": response.content_block.content.error_code,
+                    }
+                    if isinstance(
+                        response.content_block.content, WebSearchToolResultError
+                    )
+                    else {
+                        "content": [
+                            {
+                                "type": "web_search_result",
+                                "encrypted_content": block.encrypted_content,
+                                "page_age": block.page_age,
+                                "title": block.title,
+                                "url": block.url,
+                            }
+                            for block in response.content_block.content
+                        ]
+                    },
+                }
+                first_block = True
        elif isinstance(response, RawContentBlockDeltaEvent):
            if isinstance(response.delta, InputJSONDelta):
                current_tool_args += response.delta.partial_json
            elif isinstance(response.delta, TextDelta):
+                content_details.citation_details[-1].length += len(response.delta.text)
                yield {"content": response.delta.text}
            elif isinstance(response.delta, ThinkingDelta):
                yield {"thinking_content": response.delta.thinking}
@@ -271,6 +486,8 @@ async def _transform_stream(
                    )
                }
                has_native = True
+            elif isinstance(response.delta, CitationsDelta):
+                content_details.add_citation(response.delta.citation)
        elif isinstance(response, RawContentBlockStopEvent):
            if current_tool_block is not None:
                tool_args = json.loads(current_tool_args) if current_tool_args else {}
@@ -281,6 +498,7 @@ async def _transform_stream(
                            id=current_tool_block["id"],
                            tool_name=current_tool_block["name"],
                            tool_args=tool_args,
+                            external=current_tool_block["type"] == "server_tool_use",
                        )
                    ]
                }
@@ -290,6 +508,12 @@ async def _transform_stream(
                chat_log.async_trace(_create_token_stats(input_usage, usage))
            if response.delta.stop_reason == "refusal":
                raise HomeAssistantError("Potential policy violation detected")
+        elif isinstance(response, RawMessageStopEvent):
+            if content_details.has_citations():
+                content_details.delete_empty()
+                yield {"native": content_details}
+            content_details = ContentDetails()
+            content_details.add_citation_detail()


 def _create_token_stats(
@@ -337,21 +561,11 @@ class AnthropicBaseLLMEntity(Entity):
        """Generate an answer for the chat log."""
        options = self.subentry.data

-        tools: list[ToolParam] | None = None
-        if chat_log.llm_api:
-            tools = [
-                _format_tool(tool, chat_log.llm_api.custom_serializer)
-                for tool in chat_log.llm_api.tools
-            ]
-
        system = chat_log.content[0]
        if not isinstance(system, conversation.SystemContent):
            raise TypeError("First message must be a system message")
        messages = _convert_content(chat_log.content[1:])

-        client = self.entry.runtime_data
-
-        thinking_budget = options.get(CONF_THINKING_BUDGET, RECOMMENDED_THINKING_BUDGET)
        model = options.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL)

        model_args = MessageCreateParamsStreaming(
@@ -361,10 +575,10 @@ class AnthropicBaseLLMEntity(Entity):
            system=system.content,
            stream=True,
        )
-        if tools:
-            model_args["tools"] = tools
+
+        thinking_budget = options.get(CONF_THINKING_BUDGET, RECOMMENDED_THINKING_BUDGET)
        if (
-            model.startswith(tuple(THINKING_MODELS))
+            not model.startswith(tuple(NON_THINKING_MODELS))
            and thinking_budget >= MIN_THINKING_BUDGET
        ):
            model_args["thinking"] = ThinkingConfigEnabledParam(
@@ -376,6 +590,34 @@ class AnthropicBaseLLMEntity(Entity):
                CONF_TEMPERATURE, RECOMMENDED_TEMPERATURE
            )

+        tools: list[ToolUnionParam] = []
+        if chat_log.llm_api:
+            tools = [
+                _format_tool(tool, chat_log.llm_api.custom_serializer)
+                for tool in chat_log.llm_api.tools
+            ]
+
+        if options.get(CONF_WEB_SEARCH):
+            web_search = WebSearchTool20250305Param(
+                name="web_search",
+                type="web_search_20250305",
+                max_uses=options.get(CONF_WEB_SEARCH_MAX_USES),
+            )
+            if options.get(CONF_WEB_SEARCH_USER_LOCATION):
+                web_search["user_location"] = {
+                    "type": "approximate",
+                    "city": options.get(CONF_WEB_SEARCH_CITY, ""),
+                    "region": options.get(CONF_WEB_SEARCH_REGION, ""),
+                    "country": options.get(CONF_WEB_SEARCH_COUNTRY, ""),
+                    "timezone": options.get(CONF_WEB_SEARCH_TIMEZONE, ""),
+                }
+            tools.append(web_search)
+
+        if tools:
+            model_args["tools"] = tools
+
+        client = self.entry.runtime_data
+
        # To prevent infinite loops, we limit the number of iterations
        for _iteration in range(MAX_TOOL_ITERATIONS):
            try:
--- a/homeassistant/components/anthropic/manifest.json
+++ b/homeassistant/components/anthropic/manifest.json
@@ -8,5 +8,5 @@
  "documentation": "https://www.home-assistant.io/integrations/anthropic",
  "integration_type": "service",
  "iot_class": "cloud_polling",
-  "requirements": ["anthropic==0.62.0"]
+  "requirements": ["anthropic==0.69.0"]
 }
--- a/homeassistant/components/anthropic/strings.json
+++ b/homeassistant/components/anthropic/strings.json
@@ -35,11 +35,17 @@
            "temperature": "Temperature",
            "llm_hass_api": "[%key:common::config_flow::data::llm_hass_api%]",
            "recommended": "Recommended model settings",
-            "thinking_budget_tokens": "Thinking budget"
+            "thinking_budget": "Thinking budget",
+            "web_search": "Enable web search",
+            "web_search_max_uses": "Maximum web searches",
+            "user_location": "Include home location"
          },
          "data_description": {
            "prompt": "Instruct how the LLM should respond. This can be a template.",
-            "thinking_budget_tokens": "The number of tokens the model can use to think about the response out of the total maximum number of tokens. Set to 1024 or greater to enable extended thinking."
+            "thinking_budget": "The number of tokens the model can use to think about the response out of the total maximum number of tokens. Set to 1024 or greater to enable extended thinking.",
+            "web_search": "The web search tool gives Claude direct access to real-time web content, allowing it to answer questions with up-to-date information beyond its knowledge cutoff",
+            "web_search_max_uses": "Limit the number of searches performed per response",
+            "user_location": "Localize search results based on home location"
          }
        }
      },
@@ -48,7 +54,8 @@
        "entry_not_loaded": "Cannot add things while the configuration is disabled."
      },
      "error": {
-        "thinking_budget_too_large": "Maximum tokens must be greater than the thinking budget."
+        "thinking_budget_too_large": "Maximum tokens must be greater than the thinking budget.",
+        "web_search_unsupported_model": "Web search is not supported by the selected model. Please choose a compatible model or disable web search."
      }
    }
  }
--- a/homeassistant/components/apple_tv/init.py
+++ b/homeassistant/components/apple_tv/init.py
@@ -5,14 +5,9 @@ from __future__ import annotations
 import asyncio
 import logging
 from random import randrange
+import sys
 from typing import Any, cast

-from pyatv import connect, exceptions, scan
-from pyatv.conf import AppleTV
-from pyatv.const import DeviceModel, Protocol
-from pyatv.convert import model_str
-from pyatv.interface import AppleTV as AppleTVInterface, DeviceListener
-
 from homeassistant.components import zeroconf
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
@@ -29,7 +24,11 @@ from homeassistant.const import (
    Platform,
 )
 from homeassistant.core import Event, HomeAssistant, callback
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
+from homeassistant.exceptions import (
+    ConfigEntryAuthFailed,
+    ConfigEntryNotReady,
+    HomeAssistantError,
+)
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.dispatcher import async_dispatcher_send
@@ -43,6 +42,18 @@ from .const import (
    SIGNAL_DISCONNECTED,
 )

+if sys.version_info < (3, 14):
+    from pyatv import connect, exceptions, scan
+    from pyatv.conf import AppleTV
+    from pyatv.const import DeviceModel, Protocol
+    from pyatv.convert import model_str
+    from pyatv.interface import AppleTV as AppleTVInterface, DeviceListener
+else:
+
+    class DeviceListener:
+        """Dummy class."""
+
+
 _LOGGER = logging.getLogger(__name__)

 DEFAULT_NAME_TV = "Apple TV"
@@ -53,31 +64,41 @@ BACKOFF_TIME_UPPER_LIMIT = 300  # Five minutes

 PLATFORMS = [Platform.MEDIA_PLAYER, Platform.REMOTE]

-AUTH_EXCEPTIONS = (
-    exceptions.AuthenticationError,
-    exceptions.InvalidCredentialsError,
-    exceptions.NoCredentialsError,
-)
-CONNECTION_TIMEOUT_EXCEPTIONS = (
-    OSError,
-    asyncio.CancelledError,
-    TimeoutError,
-    exceptions.ConnectionLostError,
-    exceptions.ConnectionFailedError,
-)
-DEVICE_EXCEPTIONS = (
-    exceptions.ProtocolError,
-    exceptions.NoServiceError,
-    exceptions.PairingError,
-    exceptions.BackOffError,
-    exceptions.DeviceIdMissingError,
-)
+if sys.version_info < (3, 14):
+    AUTH_EXCEPTIONS = (
+        exceptions.AuthenticationError,
+        exceptions.InvalidCredentialsError,
+        exceptions.NoCredentialsError,
+    )
+    CONNECTION_TIMEOUT_EXCEPTIONS = (
+        OSError,
+        asyncio.CancelledError,
+        TimeoutError,
+        exceptions.ConnectionLostError,
+        exceptions.ConnectionFailedError,
+    )
+    DEVICE_EXCEPTIONS = (
+        exceptions.ProtocolError,
+        exceptions.NoServiceError,
+        exceptions.PairingError,
+        exceptions.BackOffError,
+        exceptions.DeviceIdMissingError,
+    )
+else:
+    AUTH_EXCEPTIONS = ()
+    CONNECTION_TIMEOUT_EXCEPTIONS = ()
+    DEVICE_EXCEPTIONS = ()
+

 type AppleTvConfigEntry = ConfigEntry[AppleTVManager]


 async def async_setup_entry(hass: HomeAssistant, entry: AppleTvConfigEntry) -> bool:
    """Set up a config entry for Apple TV."""
+    if sys.version_info >= (3, 14):
+        raise HomeAssistantError(
+            "Apple TV is not supported on Python 3.14. Please use Python 3.13."
+        )
    manager = AppleTVManager(hass, entry)

    if manager.is_on:
--- a/homeassistant/components/apple_tv/manifest.json
+++ b/homeassistant/components/apple_tv/manifest.json
@@ -7,7 +7,7 @@
  "documentation": "https://www.home-assistant.io/integrations/apple_tv",
  "iot_class": "local_push",
  "loggers": ["pyatv", "srptools"],
-  "requirements": ["pyatv==0.16.1"],
+  "requirements": ["pyatv==0.16.1;python_version<'3.14'"],
  "zeroconf": [
    "_mediaremotetv._tcp.local.",
    "_companion-link._tcp.local.",
--- a/homeassistant/components/aprilaire/climate.py
+++ b/homeassistant/components/aprilaire/climate.py
@@ -7,6 +7,8 @@ from typing import Any
 from pyaprilaire.const import Attribute

 from homeassistant.components.climate import (
+    ATTR_TARGET_TEMP_HIGH,
+    ATTR_TARGET_TEMP_LOW,
    FAN_AUTO,
    FAN_ON,
    PRESET_AWAY,
@@ -16,7 +18,12 @@ from homeassistant.components.climate import (
    HVACAction,
    HVACMode,
 )
-from homeassistant.const import PRECISION_HALVES, PRECISION_WHOLE, UnitOfTemperature
+from homeassistant.const import (
+    ATTR_TEMPERATURE,
+    PRECISION_HALVES,
+    PRECISION_WHOLE,
+    UnitOfTemperature,
+)
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback

@@ -232,15 +239,15 @@ class AprilaireClimate(BaseAprilaireEntity, ClimateEntity):
        cool_setpoint = 0
        heat_setpoint = 0

-        if temperature := kwargs.get("temperature"):
+        if temperature := kwargs.get(ATTR_TEMPERATURE):
            if self.coordinator.data.get(Attribute.MODE) == 3:
                cool_setpoint = temperature
            else:
                heat_setpoint = temperature
        else:
-            if target_temp_low := kwargs.get("target_temp_low"):
+            if target_temp_low := kwargs.get(ATTR_TARGET_TEMP_LOW):
                heat_setpoint = target_temp_low
-            if target_temp_high := kwargs.get("target_temp_high"):
+            if target_temp_high := kwargs.get(ATTR_TARGET_TEMP_HIGH):
                cool_setpoint = target_temp_high

        if cool_setpoint == 0 and heat_setpoint == 0:
--- a/homeassistant/components/assist_pipeline/init.py
+++ b/homeassistant/components/assist_pipeline/init.py
@@ -41,6 +41,8 @@ from .pipeline import (
    async_setup_pipeline_store,
    async_update_pipeline,
 )
+from .select import AssistPipelineSelect, VadSensitivitySelect
+from .vad import VadSensitivity
 from .websocket_api import async_register_websocket_api

 __all__ = (
@@ -51,16 +53,18 @@ __all__ = (
    "SAMPLE_CHANNELS",
    "SAMPLE_RATE",
    "SAMPLE_WIDTH",
+    "AssistPipelineSelect",
    "AudioSettings",
    "Pipeline",
    "PipelineEvent",
    "PipelineEventType",
    "PipelineNotFound",
+    "VadSensitivity",
+    "VadSensitivitySelect",
    "WakeWordSettings",
    "async_create_default_pipeline",
    "async_get_pipelines",
    "async_pipeline_from_audio_stream",
-    "async_setup",
    "async_update_pipeline",
 )

--- a/homeassistant/components/assist_pipeline/pipeline.py
+++ b/homeassistant/components/assist_pipeline/pipeline.py
@@ -19,7 +19,14 @@ import wave
 import hass_nabucasa
 import voluptuous as vol

-from homeassistant.components import conversation, stt, tts, wake_word, websocket_api
+from homeassistant.components import (
+    conversation,
+    media_player,
+    stt,
+    tts,
+    wake_word,
+    websocket_api,
+)
 from homeassistant.const import ATTR_SUPPORTED_FEATURES, MATCH_ALL
 from homeassistant.core import Context, HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
@@ -130,7 +137,10 @@ SAVE_DELAY = 10
@callback
 def _async_local_fallback_intent_filter(result: RecognizeResult) -> bool:
    """Filter out intents that are not local fallback."""
-    return result.intent.name in (intent.INTENT_GET_STATE)
+    return result.intent.name in (
+        intent.INTENT_GET_STATE,
+        media_player.INTENT_MEDIA_SEARCH_AND_PLAY,
+    )


@callback
--- a/homeassistant/components/asuswrt/bridge.py
+++ b/homeassistant/components/asuswrt/bridge.py
@@ -3,17 +3,17 @@
 from __future__ import annotations

 from abc import ABC, abstractmethod
-from collections import namedtuple
 from collections.abc import Awaitable, Callable, Coroutine
 import functools
 import logging
-from typing import Any, cast
+from typing import Any, NamedTuple

 from aioasuswrt.asuswrt import AsusWrt as AsusWrtLegacy
 from aiohttp import ClientSession
 from asusrouter import AsusRouter, AsusRouterError
 from asusrouter.config import ARConfigKey
 from asusrouter.modules.client import AsusClient
+from asusrouter.modules.connection import ConnectionState
 from asusrouter.modules.data import AsusData
 from asusrouter.modules.homeassistant import convert_to_ha_data, convert_to_ha_sensors
 from asusrouter.tools.connection import get_cookie_jar
@@ -61,11 +61,27 @@ SENSORS_TYPE_RATES = "sensors_rates"
 SENSORS_TYPE_TEMPERATURES = "sensors_temperatures"
 SENSORS_TYPE_UPTIME = "sensors_uptime"

-WrtDevice = namedtuple("WrtDevice", ["ip", "name", "connected_to"])  # noqa: PYI024
+
+class WrtDevice(NamedTuple):
+    """WrtDevice structure."""
+
+    ip: str | None
+    name: str | None
+    conneted_to: str | None
+

 _LOGGER = logging.getLogger(__name__)

-type _FuncType[_T] = Callable[[_T], Awaitable[list[Any] | tuple[Any] | dict[str, Any]]]
+type _FuncType[_T] = Callable[
+    [_T],
+    Awaitable[
+        list[str]
+        | tuple[float | None, float | None]
+        | list[float]
+        | dict[str, float | str | None]
+        | dict[str, float]
+    ],
+]
 type _ReturnFuncType[_T] = Callable[[_T], Coroutine[Any, Any, dict[str, Any]]]


@@ -80,7 +96,9 @@ def handle_errors_and_zip[_AsusWrtBridgeT: AsusWrtBridge](
        """Run library methods and zip results or manage exceptions."""

        @functools.wraps(func)
-        async def _wrapper(self: _AsusWrtBridgeT) -> dict[str, Any]:
+        async def _wrapper(
+            self: _AsusWrtBridgeT,
+        ) -> dict[str, float | str | None] | dict[str, float]:
            try:
                data = await func(self)
            except exceptions as exc:
@@ -107,7 +125,9 @@ class AsusWrtBridge(ABC):

    @staticmethod
    def get_bridge(
-        hass: HomeAssistant, conf: dict[str, Any], options: dict[str, Any] | None = None
+        hass: HomeAssistant,
+        conf: dict[str, str | int],
+        options: dict[str, str | bool | int] | None = None,
    ) -> AsusWrtBridge:
        """Get Bridge instance."""
        if conf[CONF_PROTOCOL] in (PROTOCOL_HTTPS, PROTOCOL_HTTP):
@@ -219,7 +239,7 @@ class AsusWrtLegacyBridge(AsusWrtBridge):
    @property
    def is_connected(self) -> bool:
        """Get connected status."""
-        return cast(bool, self._api.is_connected)
+        return self._api.is_connected

    async def async_connect(self) -> None:
        """Connect to the device."""
@@ -235,8 +255,7 @@ class AsusWrtLegacyBridge(AsusWrtBridge):

    async def async_disconnect(self) -> None:
        """Disconnect to the device."""
-        if self._api is not None and self._protocol == PROTOCOL_TELNET:
-            self._api.connection.disconnect()
+        await self._api.async_disconnect()

    async def async_get_connected_devices(self) -> dict[str, WrtDevice]:
        """Get list of connected devices."""
@@ -307,22 +326,22 @@ class AsusWrtLegacyBridge(AsusWrtBridge):
        return [SENSORS_TEMPERATURES_LEGACY[i] for i in range(3) if availability[i]]

    @handle_errors_and_zip((IndexError, OSError, ValueError), SENSORS_BYTES)
-    async def _get_bytes(self) -> Any:
+    async def _get_bytes(self) -> tuple[float | None, float | None]:
        """Fetch byte information from the router."""
        return await self._api.async_get_bytes_total()

    @handle_errors_and_zip((IndexError, OSError, ValueError), SENSORS_RATES)
-    async def _get_rates(self) -> Any:
+    async def _get_rates(self) -> tuple[float, float]:
        """Fetch rates information from the router."""
        return await self._api.async_get_current_transfer_rates()

    @handle_errors_and_zip((IndexError, OSError, ValueError), SENSORS_LOAD_AVG)
-    async def _get_load_avg(self) -> Any:
+    async def _get_load_avg(self) -> list[float]:
        """Fetch load average information from the router."""
        return await self._api.async_get_loadavg()

    @handle_errors_and_zip((OSError, ValueError), None)
-    async def _get_temperatures(self) -> Any:
+    async def _get_temperatures(self) -> dict[str, float]:
        """Fetch temperatures information from the router."""
        return await self._api.async_get_temperature()

@@ -437,6 +456,7 @@ class AsusWrtHttpBridge(AsusWrtBridge):
            if dev.connection is not None
            and dev.description is not None
            and dev.connection.ip_address is not None
+            and dev.state is ConnectionState.CONNECTED
        }

    async def async_get_available_sensors(self) -> dict[str, dict[str, Any]]:
--- a/homeassistant/components/asuswrt/config_flow.py
+++ b/homeassistant/components/asuswrt/config_flow.py
@@ -175,12 +175,12 @@ class AsusWrtFlowHandler(ConfigFlow, domain=DOMAIN):
        )

    async def _async_check_connection(
-        self, user_input: dict[str, Any]
+        self, user_input: dict[str, str | int]
    ) -> tuple[str, str | None]:
        """Attempt to connect the AsusWrt router."""

        api: AsusWrtBridge
-        host: str = user_input[CONF_HOST]
+        host = user_input[CONF_HOST]
        protocol = user_input[CONF_PROTOCOL]
        error: str | None = None

--- a/homeassistant/components/asuswrt/device_tracker.py
+++ b/homeassistant/components/asuswrt/device_tracker.py
@@ -10,8 +10,6 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from . import AsusWrtConfigEntry
 from .router import AsusWrtDevInfo, AsusWrtRouter

-ATTR_LAST_TIME_REACHABLE = "last_time_reachable"
-
 DEFAULT_DEVICE_NAME = "Unknown device"


@@ -58,8 +56,6 @@ def add_entities(
 class AsusWrtDevice(ScannerEntity):
    """Representation of a AsusWrt device."""

-    _unrecorded_attributes = frozenset({ATTR_LAST_TIME_REACHABLE})
-
    _attr_should_poll = False

    def __init__(self, router: AsusWrtRouter, device: AsusWrtDevInfo) -> None:
@@ -97,11 +93,6 @@ class AsusWrtDevice(ScannerEntity):
    def async_on_demand_update(self) -> None:
        """Update state."""
        self._device = self._router.devices[self._device.mac]
-        self._attr_extra_state_attributes = {}
-        if self._device.last_activity:
-            self._attr_extra_state_attributes[ATTR_LAST_TIME_REACHABLE] = (
-                self._device.last_activity.isoformat(timespec="seconds")
-            )
        self.async_write_ha_state()

    async def async_added_to_hass(self) -> None:
--- a/homeassistant/components/asuswrt/manifest.json
+++ b/homeassistant/components/asuswrt/manifest.json
@@ -7,5 +7,5 @@
  "integration_type": "hub",
  "iot_class": "local_polling",
  "loggers": ["aioasuswrt", "asusrouter", "asyncssh"],
-  "requirements": ["aioasuswrt==1.4.0", "asusrouter==1.21.0"]
+  "requirements": ["aioasuswrt==1.5.1", "asusrouter==1.21.0"]
 }
--- a/homeassistant/components/asuswrt/router.py
+++ b/homeassistant/components/asuswrt/router.py
@@ -176,7 +176,7 @@ class AsusWrtRouter:

        self._on_close: list[Callable] = []

-        self._options: dict[str, Any] = {
+        self._options: dict[str, str | bool | int] = {
            CONF_DNSMASQ: DEFAULT_DNSMASQ,
            CONF_INTERFACE: DEFAULT_INTERFACE,
            CONF_REQUIRE_IP: True,
@@ -299,12 +299,10 @@ class AsusWrtRouter:
            _LOGGER.warning("Reconnected to ASUS router %s", self.host)

        self._connected_devices = len(wrt_devices)
-        consider_home: int = self._options.get(
-            CONF_CONSIDER_HOME, DEFAULT_CONSIDER_HOME.total_seconds()
-        )
-        track_unknown: bool = self._options.get(
-            CONF_TRACK_UNKNOWN, DEFAULT_TRACK_UNKNOWN
+        consider_home = int(
+            self._options.get(CONF_CONSIDER_HOME, DEFAULT_CONSIDER_HOME.total_seconds())
        )
+        track_unknown = self._options.get(CONF_TRACK_UNKNOWN, DEFAULT_TRACK_UNKNOWN)

        for device_mac, device in self._devices.items():
            dev_info = wrt_devices.pop(device_mac, None)
--- a/homeassistant/components/august/init.py
+++ b/homeassistant/components/august/init.py
@@ -36,11 +36,14 @@ async def async_setup_entry(hass: HomeAssistant, entry: AugustConfigEntry) -> bo
        raise ConfigEntryAuthFailed("Migration to OAuth required")

    session = async_create_august_clientsession(hass)
-    implementation = (
-        await config_entry_oauth2_flow.async_get_config_entry_implementation(
-            hass, entry
+    try:
+        implementation = (
+            await config_entry_oauth2_flow.async_get_config_entry_implementation(
+                hass, entry
+            )
        )
-    )
+    except ValueError as err:
+        raise ConfigEntryNotReady("OAuth implementation not available") from err
    oauth_session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation)
    august_gateway = AugustGateway(Path(hass.config.config_dir), session, oauth_session)
    try:
--- a/homeassistant/components/autarco/manifest.json
+++ b/homeassistant/components/autarco/manifest.json
@@ -5,5 +5,5 @@
  "config_flow": true,
  "documentation": "https://www.home-assistant.io/integrations/autarco",
  "iot_class": "cloud_polling",
-  "requirements": ["autarco==3.1.0"]
+  "requirements": ["autarco==3.2.0"]
 }
--- a/homeassistant/components/auth/login_flow.py
+++ b/homeassistant/components/auth/login_flow.py
@@ -136,17 +136,22 @@ class WellKnownOAuthInfoView(HomeAssistantView):
            url_prefix = get_url(hass, require_current_request=True)
        except NoURLAvailableError:
            url_prefix = ""
-        return self.json(
-            {
-                "authorization_endpoint": f"{url_prefix}/auth/authorize",
-                "token_endpoint": f"{url_prefix}/auth/token",
-                "revocation_endpoint": f"{url_prefix}/auth/revoke",
-                "response_types_supported": ["code"],
-                "service_documentation": (
-                    "https://developers.home-assistant.io/docs/auth_api"
-                ),
-            }
-        )
+
+        metadata = {
+            "authorization_endpoint": f"{url_prefix}/auth/authorize",
+            "token_endpoint": f"{url_prefix}/auth/token",
+            "revocation_endpoint": f"{url_prefix}/auth/revoke",
+            "response_types_supported": ["code"],
+            "service_documentation": (
+                "https://developers.home-assistant.io/docs/auth_api"
+            ),
+        }
+
+        # Add issuer only when we have a valid base URL (RFC 8414 compliance)
+        if url_prefix:
+            metadata["issuer"] = url_prefix
+
+        return self.json(metadata)


 class AuthProvidersView(HomeAssistantView):
--- a/homeassistant/components/auth/strings.json
+++ b/homeassistant/components/auth/strings.json
@@ -5,7 +5,7 @@
      "step": {
        "init": {
          "title": "Set up two-factor authentication using TOTP",
-          "description": "To activate two-factor authentication using time-based one-time passwords, scan the QR code with your authentication app. If you don't have one, we recommend either [Google Authenticator](https://support.google.com/accounts/answer/1066447) or [Authy](https://authy.com/).\n\n{qr_code}\n\nAfter scanning the code, enter the six-digit code from your app to verify the setup. If you have problems scanning the QR code, do a manual setup with code **`{code}`**."
+          "description": "To activate two-factor authentication using time-based one-time passwords, scan the QR code with your authentication app. If you don't have one, we recommend either [Google Authenticator]({google_authenticator_url}) or [Authy]({authy_url}).\n\n{qr_code}\n\nAfter scanning the code, enter the six-digit code from your app to verify the setup. If you have problems scanning the QR code, do a manual setup with code **`{code}`**."
        }
      },
      "error": {
--- a/homeassistant/components/bayesian/strings.json
+++ b/homeassistant/components/bayesian/strings.json
@@ -146,7 +146,7 @@
        },
        "state": {
          "title": "Add a Bayesian sensor",
-          "description": "Add an observation which evaluates to `True` when the value of the sensor exactly matches *'To state'*. When `False`, it will update the prior with probabilities that are the inverse of those set below. This behaviour can be overridden by adding observations for the same entity's other states.",
+          "description": "Add an observation which evaluates to `True` when the value of the sensor exactly matches *'To state'*. When `False`, it will update the prior with probabilities that are the inverse of those set below. This behavior can be overridden by adding observations for the same entity's other states.",

          "data": {
            "name": "[%key:common::config_flow::data::name%]",
--- a/homeassistant/components/bluetooth/init.py
+++ b/homeassistant/components/bluetooth/init.py
@@ -57,6 +57,7 @@ from .api import (
    _get_manager,
    async_address_present,
    async_ble_device_from_address,
+    async_clear_address_from_match_history,
    async_current_scanners,
    async_discovered_service_info,
    async_get_advertisement_callback,
@@ -112,9 +113,9 @@ __all__ = [
    "BluetoothServiceInfo",
    "BluetoothServiceInfoBleak",
    "HaBluetoothConnector",
-    "HomeAssistantRemoteScanner",
    "async_address_present",
    "async_ble_device_from_address",
+    "async_clear_address_from_match_history",
    "async_current_scanners",
    "async_discovered_service_info",
    "async_get_advertisement_callback",
--- a/homeassistant/components/bluetooth/api.py
+++ b/homeassistant/components/bluetooth/api.py
@@ -193,6 +193,20 @@ def async_rediscover_address(hass: HomeAssistant, address: str) -> None:
    _get_manager(hass).async_rediscover_address(address)


+@hass_callback
+def async_clear_address_from_match_history(hass: HomeAssistant, address: str) -> None:
+    """Clear an address from the integration matcher history.
+
+    This allows future advertisements from this address to trigger discovery
+    even if the advertisement content has changed but the service data UUIDs
+    remain the same.
+
+    Unlike async_rediscover_address, this does not immediately re-trigger
+    discovery with the current advertisement in history.
+    """
+    _get_manager(hass).async_clear_address_from_match_history(address)
+
+
@hass_callback
 def async_register_scanner(
    hass: HomeAssistant,
--- a/homeassistant/components/bluetooth/manager.py
+++ b/homeassistant/components/bluetooth/manager.py
@@ -120,6 +120,19 @@ class HomeAssistantBluetoothManager(BluetoothManager):
        if service_info := self._all_history.get(address):
            self._async_trigger_matching_discovery(service_info)

+    @hass_callback
+    def async_clear_address_from_match_history(self, address: str) -> None:
+        """Clear an address from the integration matcher history.
+
+        This allows future advertisements from this address to trigger discovery
+        even if the advertisement content has changed but the service data UUIDs
+        remain the same.
+
+        Unlike async_rediscover_address, this does not immediately re-trigger
+        discovery with the current advertisement in history.
+        """
+        self._integration_matcher.async_clear_address(address)
+
    def _discover_service_info(self, service_info: BluetoothServiceInfoBleak) -> None:
        matched_domains = self._integration_matcher.match_domains(service_info)
        if self._debug:
--- a/homeassistant/components/bluetooth/manifest.json
+++ b/homeassistant/components/bluetooth/manifest.json
@@ -19,8 +19,8 @@
    "bleak-retry-connector==4.4.3",
    "bluetooth-adapters==2.1.0",
    "bluetooth-auto-recovery==1.5.3",
-    "bluetooth-data-tools==1.28.2",
-    "dbus-fast==2.44.3",
-    "habluetooth==5.6.4"
+    "bluetooth-data-tools==1.28.3",
+    "dbus-fast==2.44.5",
+    "habluetooth==5.7.0"
  ]
 }
--- a/homeassistant/components/bluetooth/match.py
+++ b/homeassistant/components/bluetooth/match.py
@@ -68,12 +68,17 @@ class IntegrationMatchHistory:
    manufacturer_data: bool
    service_data: set[str]
    service_uuids: set[str]
+    name: str


 def seen_all_fields(
-    previous_match: IntegrationMatchHistory, advertisement_data: AdvertisementData
+    previous_match: IntegrationMatchHistory,
+    advertisement_data: AdvertisementData,
+    name: str,
 ) -> bool:
    """Return if we have seen all fields."""
+    if previous_match.name != name:
+        return False
    if not previous_match.manufacturer_data and advertisement_data.manufacturer_data:
        return False
    if advertisement_data.service_data and (
@@ -122,10 +127,11 @@ class IntegrationMatcher:
        device = service_info.device
        advertisement_data = service_info.advertisement
        connectable = service_info.connectable
+        name = service_info.name
        matched = self._matched_connectable if connectable else self._matched
        matched_domains: set[str] = set()
        if (previous_match := matched.get(device.address)) and seen_all_fields(
-            previous_match, advertisement_data
+            previous_match, advertisement_data, name
        ):
            # We have seen all fields so we can skip the rest of the matchers
            return matched_domains
@@ -140,11 +146,13 @@ class IntegrationMatcher:
            )
            previous_match.service_data |= set(advertisement_data.service_data)
            previous_match.service_uuids |= set(advertisement_data.service_uuids)
+            previous_match.name = name
        else:
            matched[device.address] = IntegrationMatchHistory(
                manufacturer_data=bool(advertisement_data.manufacturer_data),
                service_data=set(advertisement_data.service_data),
                service_uuids=set(advertisement_data.service_uuids),
+                name=name,
            )
        return matched_domains

--- a/homeassistant/components/bring/manifest.json
+++ b/homeassistant/components/bring/manifest.json
@@ -8,5 +8,5 @@
  "iot_class": "cloud_polling",
  "loggers": ["bring_api"],
  "quality_scale": "platinum",
-  "requirements": ["bring-api==1.1.0"]
+  "requirements": ["bring-api==1.1.1"]
 }
--- a/homeassistant/components/brother/manifest.json
+++ b/homeassistant/components/brother/manifest.json
@@ -8,7 +8,7 @@
  "integration_type": "device",
  "iot_class": "local_polling",
  "loggers": ["brother", "pyasn1", "pysmi", "pysnmp"],
-  "requirements": ["brother==5.1.0"],
+  "requirements": ["brother==5.1.1"],
  "zeroconf": [
    {
      "type": "_printer._tcp.local.",
--- a/homeassistant/components/bryant_evolution/climate.py
+++ b/homeassistant/components/bryant_evolution/climate.py
@@ -7,12 +7,14 @@ from typing import Any
 from evolutionhttp import BryantEvolutionLocalClient

 from homeassistant.components.climate import (
+    ATTR_TARGET_TEMP_HIGH,
+    ATTR_TARGET_TEMP_LOW,
    ClimateEntity,
    ClimateEntityFeature,
    HVACAction,
    HVACMode,
 )
-from homeassistant.const import UnitOfTemperature
+from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.device_registry import DeviceInfo
@@ -208,24 +210,24 @@ class BryantEvolutionClimate(ClimateEntity):

    async def async_set_temperature(self, **kwargs: Any) -> None:
        """Set new target temperature."""
-        if kwargs.get("target_temp_high"):
-            temp = int(kwargs["target_temp_high"])
+        if value := kwargs.get(ATTR_TARGET_TEMP_HIGH):
+            temp = int(value)
            if not await self._client.set_cooling_setpoint(temp):
                raise HomeAssistantError(
                    translation_domain=DOMAIN, translation_key="failed_to_set_clsp"
                )
            self._attr_target_temperature_high = temp

-        if kwargs.get("target_temp_low"):
-            temp = int(kwargs["target_temp_low"])
+        if value := kwargs.get(ATTR_TARGET_TEMP_LOW):
+            temp = int(value)
            if not await self._client.set_heating_setpoint(temp):
                raise HomeAssistantError(
                    translation_domain=DOMAIN, translation_key="failed_to_set_htsp"
                )
            self._attr_target_temperature_low = temp

-        if kwargs.get("temperature"):
-            temp = int(kwargs["temperature"])
+        if value := kwargs.get(ATTR_TEMPERATURE):
+            temp = int(value)
            fn = (
                self._client.set_heating_setpoint
                if self.hvac_mode == HVACMode.HEAT
--- a/homeassistant/components/bthome/manifest.json
+++ b/homeassistant/components/bthome/manifest.json
@@ -20,5 +20,5 @@
  "dependencies": ["bluetooth_adapters"],
  "documentation": "https://www.home-assistant.io/integrations/bthome",
  "iot_class": "local_push",
-  "requirements": ["bthome-ble==3.14.2"]
+  "requirements": ["bthome-ble==3.15.0"]
 }
--- a/homeassistant/components/caldav/calendar.py
+++ b/homeassistant/components/caldav/calendar.py
@@ -3,15 +3,20 @@
 from __future__ import annotations

 from datetime import datetime
+from functools import partial
 import logging
+from typing import Any

 import caldav
+from caldav.lib.error import DAVError
+import requests
 import voluptuous as vol

 from homeassistant.components.calendar import (
    ENTITY_ID_FORMAT,
    PLATFORM_SCHEMA as CALENDAR_PLATFORM_SCHEMA,
    CalendarEntity,
+    CalendarEntityFeature,
    CalendarEvent,
    is_offset_reached,
 )
@@ -23,6 +28,7 @@ from homeassistant.const import (
    CONF_VERIFY_SSL,
 )
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity import async_generate_entity_id
 from homeassistant.helpers.entity_platform import (
@@ -175,6 +181,8 @@ async def async_setup_entry(
 class WebDavCalendarEntity(CoordinatorEntity[CalDavUpdateCoordinator], CalendarEntity):
    """A device for getting the next Task from a WebDav Calendar."""

+    _attr_supported_features = CalendarEntityFeature.CREATE_EVENT
+
    def __init__(
        self,
        name: str | None,
@@ -203,6 +211,31 @@ class WebDavCalendarEntity(CoordinatorEntity[CalDavUpdateCoordinator], CalendarE
        """Get all events in a specific time frame."""
        return await self.coordinator.async_get_events(hass, start_date, end_date)

+    async def async_create_event(self, **kwargs: Any) -> None:
+        """Create a new event in the calendar."""
+        _LOGGER.debug("Event: %s", kwargs)
+
+        item_data: dict[str, Any] = {
+            "summary": kwargs["summary"],
+            "dtstart": kwargs["dtstart"],
+            "dtend": kwargs["dtend"],
+        }
+        if description := kwargs.get("description"):
+            item_data["description"] = description
+        if location := kwargs.get("location"):
+            item_data["location"] = location
+        if rrule := kwargs.get("rrule"):
+            item_data["rrule"] = rrule
+
+        _LOGGER.debug("ICS data %s", item_data)
+
+        try:
+            await self.hass.async_add_executor_job(
+                partial(self.coordinator.calendar.add_event, **item_data),
+            )
+        except (requests.ConnectionError, DAVError) as err:
+            raise HomeAssistantError(f"CalDAV save error: {err}") from err
+
    @callback
    def _handle_coordinator_update(self) -> None:
        """Update event data."""
--- a/homeassistant/components/calendar/trigger.py
+++ b/homeassistant/components/calendar/trigger.py
@@ -169,7 +169,7 @@ class CalendarEventListener:
    def __init__(
        self,
        hass: HomeAssistant,
-        job: HassJob[..., Coroutine[Any, Any, None]],
+        job: HassJob[..., Coroutine[Any, Any, None] | Any],
        trigger_data: dict[str, Any],
        fetcher: QueuedEventFetcher,
    ) -> None:
--- a/homeassistant/components/camera/init.py
+++ b/homeassistant/components/camera/init.py
@@ -74,7 +74,10 @@ from .const import (
    StreamType,
 )
 from .helper import get_camera_from_entity_id
-from .img_util import scale_jpeg_camera_image
+from .img_util import (
+    TurboJPEGSingleton,  # noqa: F401
+    scale_jpeg_camera_image,
+)
 from .prefs import (
    CameraPreferences,
    DynamicStreamSettings,  # noqa: F401
--- a/homeassistant/components/canary/alarm_control_panel.py
+++ b/homeassistant/components/canary/alarm_control_panel.py
@@ -31,7 +31,7 @@ async def async_setup_entry(
        for location_id, location in coordinator.data["locations"].items()
    ]

-    async_add_entities(alarms, True)
+    async_add_entities(alarms)


 class CanaryAlarm(
--- a/homeassistant/components/canary/camera.py
+++ b/homeassistant/components/canary/camera.py
@@ -68,8 +68,7 @@ async def async_setup_entry(
            for location_id, location in coordinator.data["locations"].items()
            for device in location.devices
            if device.is_online
-        ),
-        True,
+        )
    )


--- a/homeassistant/components/canary/sensor.py
+++ b/homeassistant/components/canary/sensor.py
@@ -80,7 +80,7 @@ async def async_setup_entry(
                    if device_type.get("name") in sensor_type[4]
                )

-    async_add_entities(sensors, True)
+    async_add_entities(sensors)


 class CanarySensor(CoordinatorEntity[CanaryDataUpdateCoordinator], SensorEntity):
--- a/homeassistant/components/citybikes/manifest.json
+++ b/homeassistant/components/citybikes/manifest.json
@@ -4,5 +4,6 @@
  "codeowners": [],
  "documentation": "https://www.home-assistant.io/integrations/citybikes",
  "iot_class": "cloud_polling",
-  "quality_scale": "legacy"
+  "quality_scale": "legacy",
+  "requirements": ["python-citybikes==0.3.3"]
 }
--- a/homeassistant/components/citybikes/sensor.py
+++ b/homeassistant/components/citybikes/sensor.py
@@ -5,8 +5,11 @@ from __future__ import annotations
 import asyncio
 from datetime import timedelta
 import logging
+import sys

 import aiohttp
+from citybikes import __version__ as CITYBIKES_CLIENT_VERSION
+from citybikes.asyncio import Client as CitybikesClient
 import voluptuous as vol

 from homeassistant.components.sensor import (
@@ -15,21 +18,18 @@ from homeassistant.components.sensor import (
    SensorEntity,
 )
 from homeassistant.const import (
-    ATTR_ID,
-    ATTR_LATITUDE,
-    ATTR_LOCATION,
-    ATTR_LONGITUDE,
-    ATTR_NAME,
+    APPLICATION_NAME,
    CONF_LATITUDE,
    CONF_LONGITUDE,
    CONF_NAME,
    CONF_RADIUS,
+    EVENT_HOMEASSISTANT_CLOSE,
    UnitOfLength,
+    __version__,
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import PlatformNotReady
 from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.entity import async_generate_entity_id
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.event import async_track_time_interval
@@ -40,31 +40,33 @@ from homeassistant.util.unit_system import US_CUSTOMARY_SYSTEM

 _LOGGER = logging.getLogger(__name__)

-ATTR_EMPTY_SLOTS = "empty_slots"
-ATTR_EXTRA = "extra"
-ATTR_FREE_BIKES = "free_bikes"
-ATTR_NETWORK = "network"
-ATTR_NETWORKS_LIST = "networks"
-ATTR_STATIONS_LIST = "stations"
-ATTR_TIMESTAMP = "timestamp"
+HA_USER_AGENT = (
+    f"{APPLICATION_NAME}/{__version__} "
+    f"python-citybikes/{CITYBIKES_CLIENT_VERSION} "
+    f"Python/{sys.version_info[0]}.{sys.version_info[1]}"
+)
+
 ATTR_UID = "uid"
+ATTR_LATITUDE = "latitude"
+ATTR_LONGITUDE = "longitude"
+ATTR_EMPTY_SLOTS = "empty_slots"
+ATTR_TIMESTAMP = "timestamp"

 CONF_NETWORK = "network"
 CONF_STATIONS_LIST = "stations"

-DEFAULT_ENDPOINT = "https://api.citybik.es/{uri}"
 PLATFORM = "citybikes"

 MONITORED_NETWORKS = "monitored-networks"

+DATA_CLIENT = "client"
+
 NETWORKS_URI = "v2/networks"

-REQUEST_TIMEOUT = 5  # In seconds; argument to asyncio.timeout
+REQUEST_TIMEOUT = aiohttp.ClientTimeout(total=5)

 SCAN_INTERVAL = timedelta(minutes=5)  # Timely, and doesn't suffocate the API

-STATIONS_URI = "v2/networks/{uid}?fields=network.stations"
-
 CITYBIKES_ATTRIBUTION = (
    "Information provided by the CityBikes Project (https://citybik.es/#about)"
 )
@@ -87,72 +89,6 @@ PLATFORM_SCHEMA = vol.All(
    ),
 )

-NETWORK_SCHEMA = vol.Schema(
-    {
-        vol.Required(ATTR_ID): cv.string,
-        vol.Required(ATTR_NAME): cv.string,
-        vol.Required(ATTR_LOCATION): vol.Schema(
-            {
-                vol.Required(ATTR_LATITUDE): cv.latitude,
-                vol.Required(ATTR_LONGITUDE): cv.longitude,
-            },
-            extra=vol.REMOVE_EXTRA,
-        ),
-    },
-    extra=vol.REMOVE_EXTRA,
-)
-
-NETWORKS_RESPONSE_SCHEMA = vol.Schema(
-    {vol.Required(ATTR_NETWORKS_LIST): [NETWORK_SCHEMA]}
-)
-
-STATION_SCHEMA = vol.Schema(
-    {
-        vol.Required(ATTR_FREE_BIKES): cv.positive_int,
-        vol.Required(ATTR_EMPTY_SLOTS): vol.Any(cv.positive_int, None),
-        vol.Required(ATTR_LATITUDE): cv.latitude,
-        vol.Required(ATTR_LONGITUDE): cv.longitude,
-        vol.Required(ATTR_ID): cv.string,
-        vol.Required(ATTR_NAME): cv.string,
-        vol.Required(ATTR_TIMESTAMP): cv.string,
-        vol.Optional(ATTR_EXTRA): vol.Schema(
-            {vol.Optional(ATTR_UID): cv.string}, extra=vol.REMOVE_EXTRA
-        ),
-    },
-    extra=vol.REMOVE_EXTRA,
-)
-
-STATIONS_RESPONSE_SCHEMA = vol.Schema(
-    {
-        vol.Required(ATTR_NETWORK): vol.Schema(
-            {vol.Required(ATTR_STATIONS_LIST): [STATION_SCHEMA]}, extra=vol.REMOVE_EXTRA
-        )
-    }
-)
-
-
-class CityBikesRequestError(Exception):
-    """Error to indicate a CityBikes API request has failed."""
-
-
-async def async_citybikes_request(hass, uri, schema):
-    """Perform a request to CityBikes API endpoint, and parse the response."""
-    try:
-        session = async_get_clientsession(hass)
-
-        async with asyncio.timeout(REQUEST_TIMEOUT):
-            req = await session.get(DEFAULT_ENDPOINT.format(uri=uri))
-
-        json_response = await req.json()
-        return schema(json_response)
-    except (TimeoutError, aiohttp.ClientError):
-        _LOGGER.error("Could not connect to CityBikes API endpoint")
-    except ValueError:
-        _LOGGER.error("Received non-JSON data from CityBikes API endpoint")
-    except vol.Invalid as err:
-        _LOGGER.error("Received unexpected JSON from CityBikes API endpoint: %s", err)
-    raise CityBikesRequestError
-

 async def async_setup_platform(
    hass: HomeAssistant,
@@ -175,6 +111,14 @@ async def async_setup_platform(
            radius, UnitOfLength.FEET, UnitOfLength.METERS
        )

+    client = CitybikesClient(user_agent=HA_USER_AGENT, timeout=REQUEST_TIMEOUT)
+    hass.data[PLATFORM][DATA_CLIENT] = client
+
+    async def _async_close_client(event):
+        await client.close()
+
+    hass.bus.async_listen_once(EVENT_HOMEASSISTANT_CLOSE, _async_close_client)
+
    # Create a single instance of CityBikesNetworks.
    networks = hass.data.setdefault(CITYBIKES_NETWORKS, CityBikesNetworks(hass))

@@ -194,10 +138,10 @@ async def async_setup_platform(
    devices = []
    for station in network.stations:
        dist = location_util.distance(
-            latitude, longitude, station[ATTR_LATITUDE], station[ATTR_LONGITUDE]
+            latitude, longitude, station.latitude, station.longitude
        )
-        station_id = station[ATTR_ID]
-        station_uid = str(station.get(ATTR_EXTRA, {}).get(ATTR_UID, ""))
+        station_id = station.id
+        station_uid = str(station.extra.get(ATTR_UID, ""))

        if radius > dist or stations_list.intersection((station_id, station_uid)):
            if name:
@@ -216,6 +160,7 @@ class CityBikesNetworks:
    def __init__(self, hass):
        """Initialize the networks instance."""
        self.hass = hass
+        self.client = hass.data[PLATFORM][DATA_CLIENT]
        self.networks = None
        self.networks_loading = asyncio.Condition()

@@ -224,24 +169,21 @@ class CityBikesNetworks:
        try:
            await self.networks_loading.acquire()
            if self.networks is None:
-                networks = await async_citybikes_request(
-                    self.hass, NETWORKS_URI, NETWORKS_RESPONSE_SCHEMA
-                )
-                self.networks = networks[ATTR_NETWORKS_LIST]
-        except CityBikesRequestError as err:
+                self.networks = await self.client.networks.fetch()
+        except aiohttp.ClientError as err:
            raise PlatformNotReady from err
        else:
            result = None
            minimum_dist = None
            for network in self.networks:
-                network_latitude = network[ATTR_LOCATION][ATTR_LATITUDE]
-                network_longitude = network[ATTR_LOCATION][ATTR_LONGITUDE]
+                network_latitude = network.location.latitude
+                network_longitude = network.location.longitude
                dist = location_util.distance(
                    latitude, longitude, network_latitude, network_longitude
                )
                if minimum_dist is None or dist < minimum_dist:
                    minimum_dist = dist
-                    result = network[ATTR_ID]
+                    result = network.id

            return result
        finally:
@@ -257,22 +199,20 @@ class CityBikesNetwork:
        self.network_id = network_id
        self.stations = []
        self.ready = asyncio.Event()
+        self.client = hass.data[PLATFORM][DATA_CLIENT]

    async def async_refresh(self, now=None):
        """Refresh the state of the network."""
        try:
-            network = await async_citybikes_request(
-                self.hass,
-                STATIONS_URI.format(uid=self.network_id),
-                STATIONS_RESPONSE_SCHEMA,
-            )
-            self.stations = network[ATTR_NETWORK][ATTR_STATIONS_LIST]
-            self.ready.set()
-        except CityBikesRequestError as err:
-            if now is not None:
-                self.ready.clear()
-            else:
+            network = await self.client.network(uid=self.network_id).fetch()
+        except aiohttp.ClientError as err:
+            if now is None:
                raise PlatformNotReady from err
+            self.ready.clear()
+            return
+
+        self.stations = network.stations
+        self.ready.set()


 class CityBikesStation(SensorEntity):
@@ -290,16 +230,13 @@ class CityBikesStation(SensorEntity):

    async def async_update(self) -> None:
        """Update station state."""
-        for station in self._network.stations:
-            if station[ATTR_ID] == self._station_id:
-                station_data = station
-                break
-        self._attr_name = station_data.get(ATTR_NAME)
-        self._attr_native_value = station_data.get(ATTR_FREE_BIKES)
+        station = next(s for s in self._network.stations if s.id == self._station_id)
+        self._attr_name = station.name
+        self._attr_native_value = station.free_bikes
        self._attr_extra_state_attributes = {
-            ATTR_UID: station_data.get(ATTR_EXTRA, {}).get(ATTR_UID),
-            ATTR_LATITUDE: station_data.get(ATTR_LATITUDE),
-            ATTR_LONGITUDE: station_data.get(ATTR_LONGITUDE),
-            ATTR_EMPTY_SLOTS: station_data.get(ATTR_EMPTY_SLOTS),
-            ATTR_TIMESTAMP: station_data.get(ATTR_TIMESTAMP),
+            ATTR_UID: station.extra.get(ATTR_UID),
+            ATTR_LATITUDE: station.latitude,
+            ATTR_LONGITUDE: station.longitude,
+            ATTR_EMPTY_SLOTS: station.empty_slots,
+            ATTR_TIMESTAMP: station.timestamp,
        }
--- a/Show More
+++ b/Show More