Update frontend to 20251001.4

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: Joostlek <joostlek@outlook.com>

.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@e296a935590eb16afc0c0108289f68c87e2a89a5 # v4.30.7
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@3599b3baa15b485a2e49ef411a7a4bb2452e7f93 # v3.30.5
+        uses: github/codeql-action/analyze@e296a935590eb16afc0c0108289f68c87e2a89a5 # v4.30.7
         with:
           category: "/language:python"

.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"

.strict-typing

@@ -221,6 +221,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.*
@@ -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.*

AGENTS.md

@@ -0,0 +1 @@
+.github/copilot-instructions.md

CODEOWNERS

@@ -762,8 +762,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 +1065,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/nilu/ @hfurubotten
 /homeassistant/components/nina/ @DeerMaximum
 /tests/components/nina/ @DeerMaximum
+/homeassistant/components/nintendo_parental/ @pantherale0
+/tests/components/nintendo_parental/ @pantherale0
 /homeassistant/components/nissan_leaf/ @filcole
 /homeassistant/components/noaa_tides/ @jdelaney72
 /homeassistant/components/nobo_hub/ @echoromeo @oyvindwe
@@ -1196,8 +1198,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 +1413,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 +1479,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

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
+
+ENV UV_PYTHON=3.13.2
+RUN uv python install
+
 ENV VIRTUAL_ENV="/home/vscode/.local/ha-venv"
 RUN uv venv $VIRTUAL_ENV
 ENV PATH="$VIRTUAL_ENV/bin:$PATH"

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)
 

homeassistant/brands/ibm.json

@@ -1,5 +0,0 @@
-{
-  "domain": "ibm",
-  "name": "IBM",
-  "integrations": ["watson_iot", "watson_tts"]
-}

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),
         )
 

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)

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"
       },

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

homeassistant/components/airos/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/airos",
   "iot_class": "local_polling",
   "quality_scale": "bronze",
-  "requirements": ["airos==0.5.4"]
+  "requirements": ["airos==0.5.5"]
 }

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")

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"]
 }

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

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"
       }
     }
   }

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:

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()

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

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:

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.0"]
 }

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,

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:

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)

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",

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

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",
 ]

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:

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"]
 }

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."
       }
     }
   }

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:

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"]
 }

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"
   ]
 }

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.",

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

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:

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"]
 }

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,
         }

homeassistant/components/comelit/binary_sensor.py

@@ -15,6 +15,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .coordinator import ComelitConfigEntry, ComelitVedoSystem
+from .utils import DeviceType, new_device_listener
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -29,23 +30,19 @@ async def async_setup_entry(
 
     coordinator = cast(ComelitVedoSystem, config_entry.runtime_data)
 
-    known_devices: set[int] = set()
+    def _add_new_entities(new_devices: list[DeviceType], dev_type: str) -> None:
+        """Add entities for new monitors."""
+        entities = [
+            ComelitVedoBinarySensorEntity(coordinator, device, config_entry.entry_id)
+            for device in coordinator.data["alarm_zones"].values()
+            if device in new_devices
+        ]
+        if entities:
+            async_add_entities(entities)
 
-    def _check_device() -> None:
-        current_devices = set(coordinator.data["alarm_zones"])
-        new_devices = current_devices - known_devices
-        if new_devices:
-            known_devices.update(new_devices)
-            async_add_entities(
-                ComelitVedoBinarySensorEntity(
-                    coordinator, device, config_entry.entry_id
-                )
-                for device in coordinator.data["alarm_zones"].values()
-                if device.index in new_devices
-            )
-
-    _check_device()
-    config_entry.async_on_unload(coordinator.async_add_listener(_check_device))
+    config_entry.async_on_unload(
+        new_device_listener(coordinator, _add_new_entities, "alarm_zones")
+    )
 
 
 class ComelitVedoBinarySensorEntity(

homeassistant/components/comelit/config_flow.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from asyncio.exceptions import TimeoutError
 from collections.abc import Mapping
+import re
 from typing import Any
 
 from aiocomelit import (
@@ -27,25 +28,20 @@ from .utils import async_client_session
 DEFAULT_HOST = "192.168.1.252"
 DEFAULT_PIN = "111111"
 
-
-pin_regex = r"^[0-9]{4,10}$"
-
 USER_SCHEMA = vol.Schema(
     {
         vol.Required(CONF_HOST, default=DEFAULT_HOST): cv.string,
         vol.Required(CONF_PORT, default=DEFAULT_PORT): cv.port,
-        vol.Optional(CONF_PIN, default=DEFAULT_PIN): cv.matches_regex(pin_regex),
+        vol.Optional(CONF_PIN, default=DEFAULT_PIN): cv.string,
         vol.Required(CONF_TYPE, default=BRIDGE): vol.In(DEVICE_TYPE_LIST),
     }
 )
-STEP_REAUTH_DATA_SCHEMA = vol.Schema(
-    {vol.Required(CONF_PIN): cv.matches_regex(pin_regex)}
-)
+STEP_REAUTH_DATA_SCHEMA = vol.Schema({vol.Required(CONF_PIN): cv.string})
 STEP_RECONFIGURE = vol.Schema(
     {
         vol.Required(CONF_HOST): cv.string,
         vol.Required(CONF_PORT): cv.port,
-        vol.Optional(CONF_PIN, default=DEFAULT_PIN): cv.matches_regex(pin_regex),
+        vol.Optional(CONF_PIN, default=DEFAULT_PIN): cv.string,
     }
 )
 
@@ -55,6 +51,9 @@ async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> dict[str,
 
     api: ComelitCommonApi
 
+    if not re.fullmatch(r"[0-9]{4,10}", data[CONF_PIN]):
+        raise InvalidPin
+
     session = await async_client_session(hass)
     if data.get(CONF_TYPE, BRIDGE) == BRIDGE:
         api = ComeliteSerialBridgeApi(
@@ -105,6 +104,8 @@ class ComelitConfigFlow(ConfigFlow, domain=DOMAIN):
             errors["base"] = "cannot_connect"
         except InvalidAuth:
             errors["base"] = "invalid_auth"
+        except InvalidPin:
+            errors["base"] = "invalid_pin"
         except Exception:  # noqa: BLE001
             _LOGGER.exception("Unexpected exception")
             errors["base"] = "unknown"
@@ -146,6 +147,8 @@ class ComelitConfigFlow(ConfigFlow, domain=DOMAIN):
                 errors["base"] = "cannot_connect"
             except InvalidAuth:
                 errors["base"] = "invalid_auth"
+            except InvalidPin:
+                errors["base"] = "invalid_pin"
             except Exception:  # noqa: BLE001
                 _LOGGER.exception("Unexpected exception")
                 errors["base"] = "unknown"
@@ -189,6 +192,8 @@ class ComelitConfigFlow(ConfigFlow, domain=DOMAIN):
             errors["base"] = "cannot_connect"
         except InvalidAuth:
             errors["base"] = "invalid_auth"
+        except InvalidPin:
+            errors["base"] = "invalid_pin"
         except Exception:  # noqa: BLE001
             _LOGGER.exception("Unexpected exception")
             errors["base"] = "unknown"
@@ -210,3 +215,7 @@ class CannotConnect(HomeAssistantError):
 
 class InvalidAuth(HomeAssistantError):
     """Error to indicate there is invalid auth."""
+
+
+class InvalidPin(HomeAssistantError):
+    """Error to indicate an invalid pin."""

homeassistant/components/comelit/coordinator.py

@@ -161,7 +161,7 @@ class ComelitSerialBridge(
         entry: ComelitConfigEntry,
         host: str,
         port: int,
-        pin: int,
+        pin: str,
         session: ClientSession,
     ) -> None:
         """Initialize the scanner."""
@@ -195,7 +195,7 @@ class ComelitVedoSystem(ComelitBaseCoordinator[AlarmDataObject]):
         entry: ComelitConfigEntry,
         host: str,
         port: int,
-        pin: int,
+        pin: str,
         session: ClientSession,
     ) -> None:
         """Initialize the scanner."""

homeassistant/components/comelit/cover.py

@@ -7,14 +7,14 @@ from typing import Any, cast
 from aiocomelit import ComelitSerialBridgeObject
 from aiocomelit.const import COVER, STATE_COVER, STATE_OFF, STATE_ON
 
-from homeassistant.components.cover import CoverDeviceClass, CoverEntity
+from homeassistant.components.cover import CoverDeviceClass, CoverEntity, CoverState
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.restore_state import RestoreEntity
 
 from .coordinator import ComelitConfigEntry, ComelitSerialBridge
 from .entity import ComelitBridgeBaseEntity
-from .utils import bridge_api_call
+from .utils import DeviceType, bridge_api_call, new_device_listener
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -29,21 +29,19 @@ async def async_setup_entry(
 
     coordinator = cast(ComelitSerialBridge, config_entry.runtime_data)
 
-    known_devices: set[int] = set()
+    def _add_new_entities(new_devices: list[DeviceType], dev_type: str) -> None:
+        """Add entities for new monitors."""
+        entities = [
+            ComelitCoverEntity(coordinator, device, config_entry.entry_id)
+            for device in coordinator.data[dev_type].values()
+            if device in new_devices
+        ]
+        if entities:
+            async_add_entities(entities)
 
-    def _check_device() -> None:
-        current_devices = set(coordinator.data[COVER])
-        new_devices = current_devices - known_devices
-        if new_devices:
-            known_devices.update(new_devices)
-            async_add_entities(
-                ComelitCoverEntity(coordinator, device, config_entry.entry_id)
-                for device in coordinator.data[COVER].values()
-                if device.index in new_devices
-            )
-
-    _check_device()
-    config_entry.async_on_unload(coordinator.async_add_listener(_check_device))
+    config_entry.async_on_unload(
+        new_device_listener(coordinator, _add_new_entities, COVER)
+    )
 
 
 class ComelitCoverEntity(ComelitBridgeBaseEntity, RestoreEntity, CoverEntity):
@@ -62,7 +60,6 @@ class ComelitCoverEntity(ComelitBridgeBaseEntity, RestoreEntity, CoverEntity):
         super().__init__(coordinator, device, config_entry_entry_id)
         # Device doesn't provide a status so we assume UNKNOWN at first startup
         self._last_action: int | None = None
-        self._last_state: str | None = None
 
     def _current_action(self, action: str) -> bool:
         """Return the current cover action."""
@@ -98,7 +95,6 @@ class ComelitCoverEntity(ComelitBridgeBaseEntity, RestoreEntity, CoverEntity):
     @bridge_api_call
     async def _cover_set_state(self, action: int, state: int) -> None:
         """Set desired cover state."""
-        self._last_state = self.state
         await self.coordinator.api.set_device_status(COVER, self._device.index, action)
         self.coordinator.data[COVER][self._device.index].status = state
         self.async_write_ha_state()
@@ -124,5 +120,10 @@ class ComelitCoverEntity(ComelitBridgeBaseEntity, RestoreEntity, CoverEntity):
 
         await super().async_added_to_hass()
 
-        if last_state := await self.async_get_last_state():
-            self._last_state = last_state.state
+        if (state := await self.async_get_last_state()) is not None:
+            if state.state == CoverState.CLOSED:
+                self._last_action = STATE_COVER.index(CoverState.CLOSING)
+            if state.state == CoverState.OPEN:
+                self._last_action = STATE_COVER.index(CoverState.OPENING)
+
+            self._attr_is_closed = state.state == CoverState.CLOSED

homeassistant/components/comelit/light.py

@@ -12,7 +12,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .coordinator import ComelitConfigEntry, ComelitSerialBridge
 from .entity import ComelitBridgeBaseEntity
-from .utils import bridge_api_call
+from .utils import DeviceType, bridge_api_call, new_device_listener
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -27,21 +27,19 @@ async def async_setup_entry(
 
     coordinator = cast(ComelitSerialBridge, config_entry.runtime_data)
 
-    known_devices: set[int] = set()
+    def _add_new_entities(new_devices: list[DeviceType], dev_type: str) -> None:
+        """Add entities for new monitors."""
+        entities = [
+            ComelitLightEntity(coordinator, device, config_entry.entry_id)
+            for device in coordinator.data[dev_type].values()
+            if device in new_devices
+        ]
+        if entities:
+            async_add_entities(entities)
 
-    def _check_device() -> None:
-        current_devices = set(coordinator.data[LIGHT])
-        new_devices = current_devices - known_devices
-        if new_devices:
-            known_devices.update(new_devices)
-            async_add_entities(
-                ComelitLightEntity(coordinator, device, config_entry.entry_id)
-                for device in coordinator.data[LIGHT].values()
-                if device.index in new_devices
-            )
-
-    _check_device()
-    config_entry.async_on_unload(coordinator.async_add_listener(_check_device))
+    config_entry.async_on_unload(
+        new_device_listener(coordinator, _add_new_entities, LIGHT)
+    )
 
 
 class ComelitLightEntity(ComelitBridgeBaseEntity, LightEntity):

homeassistant/components/comelit/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "local_polling",
   "loggers": ["aiocomelit"],
   "quality_scale": "platinum",
-  "requirements": ["aiocomelit==0.12.3"]
+  "requirements": ["aiocomelit==1.1.1"]
 }

homeassistant/components/comelit/sensor.py

@@ -20,6 +20,7 @@ from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .coordinator import ComelitConfigEntry, ComelitSerialBridge, ComelitVedoSystem
 from .entity import ComelitBridgeBaseEntity
+from .utils import DeviceType, new_device_listener
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -65,24 +66,22 @@ async def async_setup_bridge_entry(
 
     coordinator = cast(ComelitSerialBridge, config_entry.runtime_data)
 
-    known_devices: set[int] = set()
-
-    def _check_device() -> None:
-        current_devices = set(coordinator.data[OTHER])
-        new_devices = current_devices - known_devices
-        if new_devices:
-            known_devices.update(new_devices)
-            async_add_entities(
-                ComelitBridgeSensorEntity(
-                    coordinator, device, config_entry.entry_id, sensor_desc
-                )
-                for sensor_desc in SENSOR_BRIDGE_TYPES
-                for device in coordinator.data[OTHER].values()
-                if device.index in new_devices
+    def _add_new_entities(new_devices: list[DeviceType], dev_type: str) -> None:
+        """Add entities for new monitors."""
+        entities = [
+            ComelitBridgeSensorEntity(
+                coordinator, device, config_entry.entry_id, sensor_desc
             )
+            for sensor_desc in SENSOR_BRIDGE_TYPES
+            for device in coordinator.data[dev_type].values()
+            if device in new_devices
+        ]
+        if entities:
+            async_add_entities(entities)
 
-    _check_device()
-    config_entry.async_on_unload(coordinator.async_add_listener(_check_device))
+    config_entry.async_on_unload(
+        new_device_listener(coordinator, _add_new_entities, OTHER)
+    )
 
 
 async def async_setup_vedo_entry(
@@ -94,24 +93,22 @@ async def async_setup_vedo_entry(
 
     coordinator = cast(ComelitVedoSystem, config_entry.runtime_data)
 
-    known_devices: set[int] = set()
-
-    def _check_device() -> None:
-        current_devices = set(coordinator.data["alarm_zones"])
-        new_devices = current_devices - known_devices
-        if new_devices:
-            known_devices.update(new_devices)
-            async_add_entities(
-                ComelitVedoSensorEntity(
-                    coordinator, device, config_entry.entry_id, sensor_desc
-                )
-                for sensor_desc in SENSOR_VEDO_TYPES
-                for device in coordinator.data["alarm_zones"].values()
-                if device.index in new_devices
+    def _add_new_entities(new_devices: list[DeviceType], dev_type: str) -> None:
+        """Add entities for new monitors."""
+        entities = [
+            ComelitVedoSensorEntity(
+                coordinator, device, config_entry.entry_id, sensor_desc
             )
+            for sensor_desc in SENSOR_VEDO_TYPES
+            for device in coordinator.data["alarm_zones"].values()
+            if device in new_devices
+        ]
+        if entities:
+            async_add_entities(entities)
 
-    _check_device()
-    config_entry.async_on_unload(coordinator.async_add_listener(_check_device))
+    config_entry.async_on_unload(
+        new_device_listener(coordinator, _add_new_entities, "alarm_zones")
+    )
 
 
 class ComelitBridgeSensorEntity(ComelitBridgeBaseEntity, SensorEntity):

homeassistant/components/comelit/strings.json

@@ -43,11 +43,13 @@
       "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "invalid_pin": "The provided PIN is invalid. It must be a 4-10 digit number.",
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "invalid_pin": "[%key:component::comelit::config::abort::invalid_pin%]",
       "unknown": "[%key:common::config_flow::error::unknown%]"
     }
   },

homeassistant/components/comelit/switch.py

@@ -13,7 +13,7 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .coordinator import ComelitConfigEntry, ComelitSerialBridge
 from .entity import ComelitBridgeBaseEntity
-from .utils import bridge_api_call
+from .utils import DeviceType, bridge_api_call, new_device_listener
 
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
@@ -28,35 +28,20 @@ async def async_setup_entry(
 
     coordinator = cast(ComelitSerialBridge, config_entry.runtime_data)
 
-    entities: list[ComelitSwitchEntity] = []
-    entities.extend(
-        ComelitSwitchEntity(coordinator, device, config_entry.entry_id)
-        for device in coordinator.data[IRRIGATION].values()
-    )
-    entities.extend(
-        ComelitSwitchEntity(coordinator, device, config_entry.entry_id)
-        for device in coordinator.data[OTHER].values()
-    )
-    async_add_entities(entities)
+    def _add_new_entities(new_devices: list[DeviceType], dev_type: str) -> None:
+        """Add entities for new monitors."""
+        entities = [
+            ComelitSwitchEntity(coordinator, device, config_entry.entry_id)
+            for device in coordinator.data[dev_type].values()
+            if device in new_devices
+        ]
+        if entities:
+            async_add_entities(entities)
 
-    known_devices: dict[str, set[int]] = {
-        dev_type: set() for dev_type in (IRRIGATION, OTHER)
-    }
-
-    def _check_device() -> None:
-        for dev_type in (IRRIGATION, OTHER):
-            current_devices = set(coordinator.data[dev_type])
-            new_devices = current_devices - known_devices[dev_type]
-            if new_devices:
-                known_devices[dev_type].update(new_devices)
-                async_add_entities(
-                    ComelitSwitchEntity(coordinator, device, config_entry.entry_id)
-                    for device in coordinator.data[dev_type].values()
-                    if device.index in new_devices
-                )
-
-    _check_device()
-    config_entry.async_on_unload(coordinator.async_add_listener(_check_device))
+    for dev_type in (IRRIGATION, OTHER):
+        config_entry.async_on_unload(
+            new_device_listener(coordinator, _add_new_entities, dev_type)
+        )
 
 
 class ComelitSwitchEntity(ComelitBridgeBaseEntity, SwitchEntity):

homeassistant/components/comelit/utils.py

@@ -4,7 +4,11 @@ from collections.abc import Awaitable, Callable, Coroutine
 from functools import wraps
 from typing import Any, Concatenate
 
-from aiocomelit import ComelitSerialBridgeObject
+from aiocomelit.api import (
+    ComelitSerialBridgeObject,
+    ComelitVedoAreaObject,
+    ComelitVedoZoneObject,
+)
 from aiocomelit.exceptions import CannotAuthenticate, CannotConnect, CannotRetrieveData
 from aiohttp import ClientSession, CookieJar
 
@@ -19,8 +23,11 @@ from homeassistant.helpers import (
 )
 
 from .const import _LOGGER, DOMAIN
+from .coordinator import ComelitBaseCoordinator
 from .entity import ComelitBridgeBaseEntity
 
+DeviceType = ComelitSerialBridgeObject | ComelitVedoAreaObject | ComelitVedoZoneObject
+
 
 async def async_client_session(hass: HomeAssistant) -> ClientSession:
     """Return a new aiohttp session."""
@@ -113,3 +120,41 @@ def bridge_api_call[_T: ComelitBridgeBaseEntity, **_P](
             self.coordinator.config_entry.async_start_reauth(self.hass)
 
     return cmd_wrapper
+
+
+def new_device_listener(
+    coordinator: ComelitBaseCoordinator,
+    new_devices_callback: Callable[
+        [
+            list[
+                ComelitSerialBridgeObject
+                | ComelitVedoAreaObject
+                | ComelitVedoZoneObject
+            ],
+            str,
+        ],
+        None,
+    ],
+    data_type: str,
+) -> Callable[[], None]:
+    """Subscribe to coordinator updates to check for new devices."""
+    known_devices: set[int] = set()
+
+    def _check_devices() -> None:
+        """Check for new devices and call callback with any new monitors."""
+        if not coordinator.data:
+            return
+
+        new_devices: list[DeviceType] = []
+        for _id in coordinator.data[data_type]:
+            if _id not in known_devices:
+                known_devices.add(_id)
+                new_devices.append(coordinator.data[data_type][_id])
+
+        if new_devices:
+            new_devices_callback(new_devices, data_type)
+
+    # Check for devices immediately
+    _check_devices()
+
+    return coordinator.async_add_listener(_check_devices)

homeassistant/components/conversation/chat_log.py

@@ -514,7 +514,7 @@ class ChatLog:
         """Set the LLM system prompt."""
         llm_api: llm.APIInstance | None = None
 
-        if user_llm_hass_api is None:
+        if not user_llm_hass_api:
             pass
         elif isinstance(user_llm_hass_api, llm.API):
             llm_api = await user_llm_hass_api.async_get_api_instance(llm_context)

homeassistant/components/conversation/default_agent.py

@@ -38,22 +38,30 @@ from home_assistant_intents import (
     ErrorKey,
     FuzzyConfig,
     FuzzyLanguageResponses,
+    LanguageScores,
     get_fuzzy_config,
     get_fuzzy_language,
     get_intents,
+    get_language_scores,
     get_languages,
 )
 import yaml
 
-from homeassistant import core
 from homeassistant.components.homeassistant.exposed_entities import (
     async_listen_entity_updates,
     async_should_expose,
 )
 from homeassistant.const import EVENT_STATE_CHANGED, MATCH_ALL
-from homeassistant.core import Event, callback
+from homeassistant.core import (
+    Event,
+    EventStateChangedData,
+    HomeAssistant,
+    State,
+    callback,
+)
 from homeassistant.helpers import (
     area_registry as ar,
+    config_validation as cv,
     device_registry as dr,
     entity_registry as er,
     floor_registry as fr,
@@ -192,7 +200,7 @@ class IntentCache:
 
 
 async def async_setup_default_agent(
-    hass: core.HomeAssistant,
+    hass: HomeAssistant,
     entity_component: EntityComponent[ConversationEntity],
     config_intents: dict[str, Any],
 ) -> None:
@@ -201,15 +209,13 @@ async def async_setup_default_agent(
     await entity_component.async_add_entities([agent])
     await get_agent_manager(hass).async_setup_default_agent(agent)
 
-    @core.callback
-    def async_entity_state_listener(
-        event: core.Event[core.EventStateChangedData],
-    ) -> None:
+    @callback
+    def async_entity_state_listener(event: Event[EventStateChangedData]) -> None:
         """Set expose flag on new entities."""
         async_should_expose(hass, DOMAIN, event.data["entity_id"])
 
-    @core.callback
-    def async_hass_started(hass: core.HomeAssistant) -> None:
+    @callback
+    def async_hass_started(hass: HomeAssistant) -> None:
         """Set expose flag on all entities."""
         for state in hass.states.async_all():
             async_should_expose(hass, DOMAIN, state.entity_id)
@@ -224,9 +230,7 @@ class DefaultAgent(ConversationEntity):
     _attr_name = "Home Assistant"
     _attr_supported_features = ConversationEntityFeature.CONTROL
 
-    def __init__(
-        self, hass: core.HomeAssistant, config_intents: dict[str, Any]
-    ) -> None:
+    def __init__(self, hass: HomeAssistant, config_intents: dict[str, Any]) -> None:
         """Initialize the default agent."""
         self.hass = hass
         self._lang_intents: dict[str, LanguageIntents | object] = {}
@@ -259,7 +263,7 @@ class DefaultAgent(ConversationEntity):
         """Return a list of supported languages."""
         return get_languages()
 
-    @core.callback
+    @callback
     def _filter_entity_registry_changes(
         self, event_data: er.EventEntityRegistryUpdatedData
     ) -> bool:
@@ -268,12 +272,12 @@ class DefaultAgent(ConversationEntity):
             field in event_data["changes"] for field in _ENTITY_REGISTRY_UPDATE_FIELDS
         )
 
-    @core.callback
-    def _filter_state_changes(self, event_data: core.EventStateChangedData) -> bool:
+    @callback
+    def _filter_state_changes(self, event_data: EventStateChangedData) -> bool:
         """Filter state changed events."""
         return not event_data["old_state"] or not event_data["new_state"]
 
-    @core.callback
+    @callback
     def _listen_clear_slot_list(self) -> None:
         """Listen for changes that can invalidate slot list."""
         assert self._unsub_clear_slot_list is None
@@ -342,6 +346,81 @@ class DefaultAgent(ConversationEntity):
 
         return result
 
+    async def async_debug_recognize(
+        self, user_input: ConversationInput
+    ) -> dict[str, Any] | None:
+        """Debug recognize from user input."""
+        result_dict: dict[str, Any] | None = None
+
+        if trigger_result := await self.async_recognize_sentence_trigger(user_input):
+            result_dict = {
+                # Matched a user-defined sentence trigger.
+                # We can't provide the response here without executing the
+                # trigger.
+                "match": True,
+                "source": "trigger",
+                "sentence_template": trigger_result.sentence_template or "",
+            }
+        elif intent_result := await self.async_recognize_intent(user_input):
+            successful_match = not intent_result.unmatched_entities
+            result_dict = {
+                # Name of the matching intent (or the closest)
+                "intent": {
+                    "name": intent_result.intent.name,
+                },
+                # Slot values that would be received by the intent
+                "slots": {  # direct access to values
+                    entity_key: entity.text or entity.value
+                    for entity_key, entity in intent_result.entities.items()
+                },
+                # Extra slot details, such as the originally matched text
+                "details": {
+                    entity_key: {
+                        "name": entity.name,
+                        "value": entity.value,
+                        "text": entity.text,
+                    }
+                    for entity_key, entity in intent_result.entities.items()
+                },
+                # Entities/areas/etc. that would be targeted
+                "targets": {},
+                # True if match was successful
+                "match": successful_match,
+                # Text of the sentence template that matched (or was closest)
+                "sentence_template": "",
+                # When match is incomplete, this will contain the best slot guesses
+                "unmatched_slots": _get_unmatched_slots(intent_result),
+                # True if match was not exact
+                "fuzzy_match": False,
+            }
+
+            if successful_match:
+                result_dict["targets"] = {
+                    state.entity_id: {"matched": is_matched}
+                    for state, is_matched in _get_debug_targets(
+                        self.hass, intent_result
+                    )
+                }
+
+            if intent_result.intent_sentence is not None:
+                result_dict["sentence_template"] = intent_result.intent_sentence.text
+
+            if intent_result.intent_metadata:
+                # Inspect metadata to determine if this matched a custom sentence
+                if intent_result.intent_metadata.get(METADATA_CUSTOM_SENTENCE):
+                    result_dict["source"] = "custom"
+                    result_dict["file"] = intent_result.intent_metadata.get(
+                        METADATA_CUSTOM_FILE
+                    )
+                else:
+                    result_dict["source"] = "builtin"
+
+                result_dict["fuzzy_match"] = intent_result.intent_metadata.get(
+                    METADATA_FUZZY_MATCH, False
+                )
+
+        return result_dict
+
     async def _async_handle_message(
         self,
         user_input: ConversationInput,
@@ -890,7 +969,7 @@ class DefaultAgent(ConversationEntity):
     ) -> str:
         # Get first matched or unmatched state.
         # This is available in the response template as "state".
-        state1: core.State | None = None
+        state1: State | None = None
         if intent_response.matched_states:
             state1 = intent_response.matched_states[0]
         elif intent_response.unmatched_states:
@@ -1528,6 +1607,10 @@ class DefaultAgent(ConversationEntity):
             return None
         return response
 
+    async def async_get_language_scores(self) -> dict[str, LanguageScores]:
+        """Get support scores per language."""
+        return await self.hass.async_add_executor_job(get_language_scores)
+
 
 def _make_error_result(
     language: str,
@@ -1589,7 +1672,7 @@ def _get_unmatched_response(result: RecognizeResult) -> tuple[ErrorKey, dict[str
 
 
 def _get_match_error_response(
-    hass: core.HomeAssistant,
+    hass: HomeAssistant,
     match_error: intent.MatchFailedError,
 ) -> tuple[ErrorKey, dict[str, Any]]:
     """Return key and template arguments for error when target matching fails."""
@@ -1724,3 +1807,75 @@ def _collect_list_references(expression: Expression, list_names: set[str]) -> No
     elif isinstance(expression, ListReference):
         # {list}
         list_names.add(expression.slot_name)
+
+
+def _get_debug_targets(
+    hass: HomeAssistant,
+    result: RecognizeResult,
+) -> Iterable[tuple[State, bool]]:
+    """Yield state/is_matched pairs for a hassil recognition."""
+    entities = result.entities
+
+    name: str | None = None
+    area_name: str | None = None
+    domains: set[str] | None = None
+    device_classes: set[str] | None = None
+    state_names: set[str] | None = None
+
+    if "name" in entities:
+        name = str(entities["name"].value)
+
+    if "area" in entities:
+        area_name = str(entities["area"].value)
+
+    if "domain" in entities:
+        domains = set(cv.ensure_list(entities["domain"].value))
+
+    if "device_class" in entities:
+        device_classes = set(cv.ensure_list(entities["device_class"].value))
+
+    if "state" in entities:
+        # HassGetState only
+        state_names = set(cv.ensure_list(entities["state"].value))
+
+    if (
+        (name is None)
+        and (area_name is None)
+        and (not domains)
+        and (not device_classes)
+        and (not state_names)
+    ):
+        # Avoid "matching" all entities when there is no filter
+        return
+
+    states = intent.async_match_states(
+        hass,
+        name=name,
+        area_name=area_name,
+        domains=domains,
+        device_classes=device_classes,
+    )
+
+    for state in states:
+        # For queries, a target is "matched" based on its state
+        is_matched = (state_names is None) or (state.state in state_names)
+        yield state, is_matched
+
+
+def _get_unmatched_slots(
+    result: RecognizeResult,
+) -> dict[str, str | int | float]:
+    """Return a dict of unmatched text/range slot entities."""
+    unmatched_slots: dict[str, str | int | float] = {}
+    for entity in result.unmatched_entities_list:
+        if isinstance(entity, UnmatchedTextEntity):
+            if entity.text == MISSING_ENTITY:
+                # Don't report <missing> since these are just missing context
+                # slots.
+                continue
+
+            unmatched_slots[entity.name] = entity.text
+        elif isinstance(entity, UnmatchedRangeEntity):
+            unmatched_slots[entity.name] = entity.value
+
+    return unmatched_slots

homeassistant/components/conversation/http.py

@@ -2,21 +2,16 @@
 
 from __future__ import annotations
 
-from collections.abc import Iterable
 from dataclasses import asdict
 from typing import Any
 
 from aiohttp import web
-from hassil.recognize import MISSING_ENTITY, RecognizeResult
-from hassil.string_matcher import UnmatchedRangeEntity, UnmatchedTextEntity
-from home_assistant_intents import get_language_scores
 import voluptuous as vol
 
 from homeassistant.components import http, websocket_api
 from homeassistant.components.http.data_validator import RequestDataValidator
 from homeassistant.const import MATCH_ALL
-from homeassistant.core import HomeAssistant, State, callback
-from homeassistant.helpers import config_validation as cv, intent
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.util import language as language_util
 
 from .agent_manager import (
@@ -26,11 +21,6 @@ from .agent_manager import (
     get_agent_manager,
 )
 from .const import DATA_COMPONENT
-from .default_agent import (
-    METADATA_CUSTOM_FILE,
-    METADATA_CUSTOM_SENTENCE,
-    METADATA_FUZZY_MATCH,
-)
 from .entity import ConversationEntity
 from .models import ConversationInput
 
@@ -206,150 +196,12 @@ async def websocket_hass_agent_debug(
             language=msg.get("language", hass.config.language),
             agent_id=agent.entity_id,
         )
-        result_dict: dict[str, Any] | None = None
-
-        if trigger_result := await agent.async_recognize_sentence_trigger(user_input):
-            result_dict = {
-                # Matched a user-defined sentence trigger.
-                # We can't provide the response here without executing the
-                # trigger.
-                "match": True,
-                "source": "trigger",
-                "sentence_template": trigger_result.sentence_template or "",
-            }
-        elif intent_result := await agent.async_recognize_intent(user_input):
-            successful_match = not intent_result.unmatched_entities
-            result_dict = {
-                # Name of the matching intent (or the closest)
-                "intent": {
-                    "name": intent_result.intent.name,
-                },
-                # Slot values that would be received by the intent
-                "slots": {  # direct access to values
-                    entity_key: entity.text or entity.value
-                    for entity_key, entity in intent_result.entities.items()
-                },
-                # Extra slot details, such as the originally matched text
-                "details": {
-                    entity_key: {
-                        "name": entity.name,
-                        "value": entity.value,
-                        "text": entity.text,
-                    }
-                    for entity_key, entity in intent_result.entities.items()
-                },
-                # Entities/areas/etc. that would be targeted
-                "targets": {},
-                # True if match was successful
-                "match": successful_match,
-                # Text of the sentence template that matched (or was closest)
-                "sentence_template": "",
-                # When match is incomplete, this will contain the best slot guesses
-                "unmatched_slots": _get_unmatched_slots(intent_result),
-                # True if match was not exact
-                "fuzzy_match": False,
-            }
-
-            if successful_match:
-                result_dict["targets"] = {
-                    state.entity_id: {"matched": is_matched}
-                    for state, is_matched in _get_debug_targets(hass, intent_result)
-                }
-
-            if intent_result.intent_sentence is not None:
-                result_dict["sentence_template"] = intent_result.intent_sentence.text
-
-            if intent_result.intent_metadata:
-                # Inspect metadata to determine if this matched a custom sentence
-                if intent_result.intent_metadata.get(METADATA_CUSTOM_SENTENCE):
-                    result_dict["source"] = "custom"
-                    result_dict["file"] = intent_result.intent_metadata.get(
-                        METADATA_CUSTOM_FILE
-                    )
-                else:
-                    result_dict["source"] = "builtin"
-
-                result_dict["fuzzy_match"] = intent_result.intent_metadata.get(
-                    METADATA_FUZZY_MATCH, False
-                )
-
+        result_dict = await agent.async_debug_recognize(user_input)
         result_dicts.append(result_dict)
 
     connection.send_result(msg["id"], {"results": result_dicts})
 
 
-def _get_debug_targets(
-    hass: HomeAssistant,
-    result: RecognizeResult,
-) -> Iterable[tuple[State, bool]]:
-    """Yield state/is_matched pairs for a hassil recognition."""
-    entities = result.entities
-
-    name: str | None = None
-    area_name: str | None = None
-    domains: set[str] | None = None
-    device_classes: set[str] | None = None
-    state_names: set[str] | None = None
-
-    if "name" in entities:
-        name = str(entities["name"].value)
-
-    if "area" in entities:
-        area_name = str(entities["area"].value)
-
-    if "domain" in entities:
-        domains = set(cv.ensure_list(entities["domain"].value))
-
-    if "device_class" in entities:
-        device_classes = set(cv.ensure_list(entities["device_class"].value))
-
-    if "state" in entities:
-        # HassGetState only
-        state_names = set(cv.ensure_list(entities["state"].value))
-
-    if (
-        (name is None)
-        and (area_name is None)
-        and (not domains)
-        and (not device_classes)
-        and (not state_names)
-    ):
-        # Avoid "matching" all entities when there is no filter
-        return
-
-    states = intent.async_match_states(
-        hass,
-        name=name,
-        area_name=area_name,
-        domains=domains,
-        device_classes=device_classes,
-    )
-
-    for state in states:
-        # For queries, a target is "matched" based on its state
-        is_matched = (state_names is None) or (state.state in state_names)
-        yield state, is_matched
-
-
-def _get_unmatched_slots(
-    result: RecognizeResult,
-) -> dict[str, str | int | float]:
-    """Return a dict of unmatched text/range slot entities."""
-    unmatched_slots: dict[str, str | int | float] = {}
-    for entity in result.unmatched_entities_list:
-        if isinstance(entity, UnmatchedTextEntity):
-            if entity.text == MISSING_ENTITY:
-                # Don't report <missing> since these are just missing context
-                # slots.
-                continue
-
-            unmatched_slots[entity.name] = entity.text
-        elif isinstance(entity, UnmatchedRangeEntity):
-            unmatched_slots[entity.name] = entity.value
-
-    return unmatched_slots
-
-
 @websocket_api.websocket_command(
     {
         vol.Required("type"): "conversation/agent/homeassistant/language_scores",
@@ -364,10 +216,13 @@ async def websocket_hass_agent_language_scores(
     msg: dict[str, Any],
 ) -> None:
     """Get support scores per language."""
+    agent = get_agent_manager(hass).default_agent
+    assert agent is not None
+
     language = msg.get("language", hass.config.language)
     country = msg.get("country", hass.config.country)
 
-    scores = await hass.async_add_executor_job(get_language_scores)
+    scores = await agent.async_get_language_scores()
     matching_langs = language_util.matches(language, scores.keys(), country=country)
     preferred_lang = matching_langs[0] if matching_langs else language
     result = {

homeassistant/components/cover/__init__.py

@@ -13,7 +13,7 @@ from propcache.api import cached_property
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (  # noqa: F401
+from homeassistant.const import (
     SERVICE_CLOSE_COVER,
     SERVICE_CLOSE_COVER_TILT,
     SERVICE_OPEN_COVER,
@@ -24,19 +24,9 @@ from homeassistant.const import (  # noqa: F401
     SERVICE_STOP_COVER_TILT,
     SERVICE_TOGGLE,
     SERVICE_TOGGLE_COVER_TILT,
-    STATE_CLOSED,
-    STATE_CLOSING,
-    STATE_OPEN,
-    STATE_OPENING,
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.deprecation import (
-    DeprecatedConstantEnum,
-    all_with_deprecated_constants,
-    check_if_deprecated_constant,
-    dir_with_deprecated_constants,
-)
 from homeassistant.helpers.entity import Entity, EntityDescription
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.typing import ConfigType
@@ -63,15 +53,6 @@ class CoverState(StrEnum):
     OPENING = "opening"
 
 
-# STATE_* below are deprecated as of 2024.11
-# when imported from homeassistant.components.cover
-# use the CoverState enum instead.
-_DEPRECATED_STATE_CLOSED = DeprecatedConstantEnum(CoverState.CLOSED, "2025.11")
-_DEPRECATED_STATE_CLOSING = DeprecatedConstantEnum(CoverState.CLOSING, "2025.11")
-_DEPRECATED_STATE_OPEN = DeprecatedConstantEnum(CoverState.OPEN, "2025.11")
-_DEPRECATED_STATE_OPENING = DeprecatedConstantEnum(CoverState.OPENING, "2025.11")
-
-
 class CoverDeviceClass(StrEnum):
     """Device class for cover."""
 
@@ -463,11 +444,3 @@ class CoverEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
         return (
             fns["close"] if self._cover_is_last_toggle_direction_open else fns["open"]
         )
-
-
-# These can be removed if no deprecated constant are in this module anymore
-__getattr__ = ft.partial(check_if_deprecated_constant, module_globals=globals())
-__dir__ = ft.partial(
-    dir_with_deprecated_constants, module_globals_keys=[*globals().keys()]
-)
-__all__ = all_with_deprecated_constants(globals())

homeassistant/components/daikin/__init__.py

@@ -23,7 +23,7 @@ from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC
 from homeassistant.util.ssl import client_context_no_verify
 
-from .const import KEY_MAC, TIMEOUT
+from .const import KEY_MAC, TIMEOUT_SEC
 from .coordinator import DaikinConfigEntry, DaikinCoordinator
 
 _LOGGER = logging.getLogger(__name__)
@@ -42,7 +42,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: DaikinConfigEntry) -> bo
     session = async_get_clientsession(hass)
     host = conf[CONF_HOST]
     try:
-        async with asyncio.timeout(TIMEOUT):
+        async with asyncio.timeout(TIMEOUT_SEC):
             device: Appliance = await DaikinFactory(
                 host,
                 session,
@@ -53,7 +53,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: DaikinConfigEntry) -> bo
             )
         _LOGGER.debug("Connection to %s successful", host)
     except TimeoutError as err:
-        _LOGGER.debug("Connection to %s timed out in 60 seconds", host)
+        _LOGGER.debug("Connection to %s timed out in %s seconds", host, TIMEOUT_SEC)
         raise ConfigEntryNotReady from err
     except ClientConnectionError as err:
         _LOGGER.debug("ClientConnectionError to %s", host)

homeassistant/components/daikin/config_flow.py

@@ -20,7 +20,7 @@ from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
 from homeassistant.util.ssl import client_context_no_verify
 
-from .const import DOMAIN, KEY_MAC, TIMEOUT
+from .const import DOMAIN, KEY_MAC, TIMEOUT_SEC
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -84,7 +84,7 @@ class FlowHandler(ConfigFlow, domain=DOMAIN):
             password = None
 
         try:
-            async with asyncio.timeout(TIMEOUT):
+            async with asyncio.timeout(TIMEOUT_SEC):
                 device: Appliance = await DaikinFactory(
                     host,
                     async_get_clientsession(self.hass),

homeassistant/components/daikin/const.py

@@ -24,4 +24,4 @@ ATTR_STATE_OFF = "off"
 KEY_MAC = "mac"
 KEY_IP = "ip"
 
-TIMEOUT = 60
+TIMEOUT_SEC = 120

homeassistant/components/daikin/coordinator.py

@@ -9,7 +9,7 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 
-from .const import DOMAIN
+from .const import DOMAIN, TIMEOUT_SEC
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -28,7 +28,7 @@ class DaikinCoordinator(DataUpdateCoordinator[None]):
             _LOGGER,
             config_entry=entry,
             name=device.values.get("name", DOMAIN),
-            update_interval=timedelta(seconds=60),
+            update_interval=timedelta(seconds=TIMEOUT_SEC),
         )
         self.device = device
 

homeassistant/components/daikin/manifest.json

@@ -6,6 +6,6 @@
   "documentation": "https://www.home-assistant.io/integrations/daikin",
   "iot_class": "local_polling",
   "loggers": ["pydaikin"],
-  "requirements": ["pydaikin==2.16.0"],
+  "requirements": ["pydaikin==2.17.1"],
   "zeroconf": ["_dkapi._tcp.local."]
 }

homeassistant/components/dhcp/manifest.json

@@ -17,6 +17,6 @@
   "requirements": [
     "aiodhcpwatcher==1.2.1",
     "aiodiscover==2.7.1",
-    "cached-ipaddress==0.10.0"
+    "cached-ipaddress==1.0.1"
   ]
 }

homeassistant/components/duke_energy/coordinator.py

@@ -24,6 +24,7 @@ from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 from homeassistant.util import dt as dt_util
+from homeassistant.util.unit_conversion import EnergyConverter
 
 from .const import DOMAIN
 
@@ -146,6 +147,7 @@ class DukeEnergyCoordinator(DataUpdateCoordinator[None]):
                 name=f"{name_prefix} Consumption",
                 source=DOMAIN,
                 statistic_id=consumption_statistic_id,
+                unit_class=EnergyConverter.UNIT_CLASS,
                 unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR
                 if meter["serviceType"] == "ELECTRIC"
                 else UnitOfVolume.CENTUM_CUBIC_FEET,

homeassistant/components/ecovacs/icons.json

@@ -116,6 +116,9 @@
       }
     },
     "select": {
+      "active_map": {
+        "default": "mdi:floor-plan"
+      },
       "water_amount": {
         "default": "mdi:water"
       },

homeassistant/components/ecovacs/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/ecovacs",
   "iot_class": "cloud_push",
   "loggers": ["sleekxmppfs", "sucks", "deebot_client"],
-  "requirements": ["py-sucks==0.9.11", "deebot-client==15.0.0"]
+  "requirements": ["py-sucks==0.9.11", "deebot-client==15.1.0"]
 }

homeassistant/components/ecovacs/select.py

@@ -2,12 +2,13 @@
 
 from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
-from deebot_client.capabilities import CapabilitySetTypes
+from deebot_client.capabilities import CapabilityMap, CapabilitySet, CapabilitySetTypes
 from deebot_client.device import Device
 from deebot_client.events import WorkModeEvent
 from deebot_client.events.base import Event
+from deebot_client.events.map import CachedMapInfoEvent, MajorMapEvent
 from deebot_client.events.water_info import WaterAmountEvent
 
 from homeassistant.components.select import SelectEntity, SelectEntityDescription
@@ -16,7 +17,11 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import EcovacsConfigEntry
-from .entity import EcovacsCapabilityEntityDescription, EcovacsDescriptionEntity
+from .entity import (
+    EcovacsCapabilityEntityDescription,
+    EcovacsDescriptionEntity,
+    EcovacsEntity,
+)
 from .util import get_name_key, get_supported_entities
 
 
@@ -66,6 +71,12 @@ async def async_setup_entry(
     entities = get_supported_entities(
         controller, EcovacsSelectEntity, ENTITY_DESCRIPTIONS
     )
+    entities.extend(
+        EcovacsActiveMapSelectEntity(device, device.capabilities.map)
+        for device in controller.devices
+        if (map_cap := device.capabilities.map)
+        and isinstance(map_cap.major, CapabilitySet)
+    )
     if entities:
         async_add_entities(entities)
 
@@ -103,3 +114,76 @@ class EcovacsSelectEntity[EventT: Event](
     async def async_select_option(self, option: str) -> None:
         """Change the selected option."""
         await self._device.execute_command(self._capability.set(option))
+
+
+class EcovacsActiveMapSelectEntity(
+    EcovacsEntity[CapabilityMap],
+    SelectEntity,
+):
+    """Ecovacs active map select entity."""
+
+    entity_description = SelectEntityDescription(
+        key="active_map",
+        translation_key="active_map",
+        entity_category=EntityCategory.CONFIG,
+    )
+
+    def __init__(
+        self,
+        device: Device,
+        capability: CapabilityMap,
+        **kwargs: Any,
+    ) -> None:
+        """Initialize entity."""
+        super().__init__(device, capability, **kwargs)
+        self._option_to_id: dict[str, str] = {}
+        self._id_to_option: dict[str, str] = {}
+
+        self._handle_on_cached_map(
+            device.events.get_last_event(CachedMapInfoEvent)
+            or CachedMapInfoEvent(set())
+        )
+
+    def _handle_on_cached_map(self, event: CachedMapInfoEvent) -> None:
+        self._id_to_option.clear()
+        self._option_to_id.clear()
+
+        for map_info in event.maps:
+            name = map_info.name if map_info.name else map_info.id
+            self._id_to_option[map_info.id] = name
+            self._option_to_id[name] = map_info.id
+
+            if map_info.using:
+                self._attr_current_option = name
+
+        if self._attr_current_option not in self._option_to_id:
+            self._attr_current_option = None
+
+        # Sort named maps first, then numeric IDs (unnamed maps during building) in ascending order.
+        self._attr_options = sorted(
+            self._option_to_id.keys(), key=lambda x: (x.isdigit(), x.lower())
+        )
+
+    async def async_added_to_hass(self) -> None:
+        """Set up the event listeners now that hass is ready."""
+        await super().async_added_to_hass()
+
+        async def on_cached_map(event: CachedMapInfoEvent) -> None:
+            self._handle_on_cached_map(event)
+            self.async_write_ha_state()
+
+        self._subscribe(self._capability.cached_info.event, on_cached_map)
+
+        async def on_major_map(event: MajorMapEvent) -> None:
+            self._attr_current_option = self._id_to_option.get(event.map_id)
+            self.async_write_ha_state()
+
+        self._subscribe(self._capability.major.event, on_major_map)
+
+    async def async_select_option(self, option: str) -> None:
+        """Change the selected option."""
+        if TYPE_CHECKING:
+            assert isinstance(self._capability.major, CapabilitySet)
+        await self._device.execute_command(
+            self._capability.major.set(self._option_to_id[option])
+        )

homeassistant/components/ecovacs/strings.json

@@ -178,6 +178,9 @@
       }
     },
     "select": {
+      "active_map": {
+        "name": "Active map"
+      },
       "water_amount": {
         "name": "[%key:component::ecovacs::entity::number::water_amount::name%]",
         "state": {

homeassistant/components/elvia/importer.py

@@ -20,6 +20,7 @@ from homeassistant.components.recorder.statistics import (
 from homeassistant.components.recorder.util import get_instance
 from homeassistant.const import UnitOfEnergy
 from homeassistant.util import dt as dt_util
+from homeassistant.util.unit_conversion import EnergyConverter
 
 from .const import DOMAIN, LOGGER
 
@@ -153,6 +154,7 @@ class ElviaImporter:
                 name=f"{self.metering_point_id} Consumption",
                 source=DOMAIN,
                 statistic_id=statistic_id,
+                unit_class=EnergyConverter.UNIT_CLASS,
                 unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
             ),
             statistics=statistics,

homeassistant/components/enphase_envoy/manifest.json

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

homeassistant/components/enphase_envoy/sensor.py

@@ -396,6 +396,7 @@ class EnvoyCTSensorEntityDescription(SensorEntityDescription):
         int | float | str | CtType | CtMeterStatus | CtStatusFlags | CtState | None,
     ]
     on_phase: str | None
+    cttype: str | None = None
 
 
 CT_NET_CONSUMPTION_SENSORS = (
@@ -409,6 +410,7 @@ CT_NET_CONSUMPTION_SENSORS = (
         suggested_display_precision=3,
         value_fn=attrgetter("energy_delivered"),
         on_phase=None,
+        cttype=CtType.NET_CONSUMPTION,
     ),
     EnvoyCTSensorEntityDescription(
         key="lifetime_net_production",
@@ -420,6 +422,7 @@ CT_NET_CONSUMPTION_SENSORS = (
         suggested_display_precision=3,
         value_fn=attrgetter("energy_received"),
         on_phase=None,
+        cttype=CtType.NET_CONSUMPTION,
     ),
     EnvoyCTSensorEntityDescription(
         key="net_consumption",
@@ -431,6 +434,7 @@ CT_NET_CONSUMPTION_SENSORS = (
         suggested_display_precision=3,
         value_fn=attrgetter("active_power"),
         on_phase=None,
+        cttype=CtType.NET_CONSUMPTION,
     ),
     EnvoyCTSensorEntityDescription(
         key="frequency",
@@ -442,6 +446,7 @@ CT_NET_CONSUMPTION_SENSORS = (
         entity_registry_enabled_default=False,
         value_fn=attrgetter("frequency"),
         on_phase=None,
+        cttype=CtType.NET_CONSUMPTION,
     ),
     EnvoyCTSensorEntityDescription(
         key="voltage",
@@ -454,6 +459,7 @@ CT_NET_CONSUMPTION_SENSORS = (
         entity_registry_enabled_default=False,
         value_fn=attrgetter("voltage"),
         on_phase=None,
+        cttype=CtType.NET_CONSUMPTION,
     ),
     EnvoyCTSensorEntityDescription(
         key="net_ct_current",
@@ -466,6 +472,7 @@ CT_NET_CONSUMPTION_SENSORS = (
         entity_registry_enabled_default=False,
         value_fn=attrgetter("current"),
         on_phase=None,
+        cttype=CtType.NET_CONSUMPTION,
     ),
     EnvoyCTSensorEntityDescription(
         key="net_ct_powerfactor",
@@ -476,6 +483,7 @@ CT_NET_CONSUMPTION_SENSORS = (
         entity_registry_enabled_default=False,
         value_fn=attrgetter("power_factor"),
         on_phase=None,
+        cttype=CtType.NET_CONSUMPTION,
     ),
     EnvoyCTSensorEntityDescription(
         key="net_consumption_ct_metering_status",
@@ -486,6 +494,7 @@ CT_NET_CONSUMPTION_SENSORS = (
         entity_registry_enabled_default=False,
         value_fn=attrgetter("metering_status"),
         on_phase=None,
+        cttype=CtType.NET_CONSUMPTION,
     ),
     EnvoyCTSensorEntityDescription(
         key="net_consumption_ct_status_flags",
@@ -495,6 +504,7 @@ CT_NET_CONSUMPTION_SENSORS = (
         entity_registry_enabled_default=False,
         value_fn=lambda ct: 0 if ct.status_flags is None else len(ct.status_flags),
         on_phase=None,
+        cttype=CtType.NET_CONSUMPTION,
     ),
 )
 
@@ -525,6 +535,7 @@ CT_PRODUCTION_SENSORS = (
         entity_registry_enabled_default=False,
         value_fn=attrgetter("frequency"),
         on_phase=None,
+        cttype=CtType.PRODUCTION,
     ),
     EnvoyCTSensorEntityDescription(
         key="production_ct_voltage",
@@ -537,6 +548,7 @@ CT_PRODUCTION_SENSORS = (
         entity_registry_enabled_default=False,
         value_fn=attrgetter("voltage"),
         on_phase=None,
+        cttype=CtType.PRODUCTION,
     ),
     EnvoyCTSensorEntityDescription(
         key="production_ct_current",
@@ -549,6 +561,7 @@ CT_PRODUCTION_SENSORS = (
         entity_registry_enabled_default=False,
         value_fn=attrgetter("current"),
         on_phase=None,
+        cttype=CtType.PRODUCTION,
     ),
     EnvoyCTSensorEntityDescription(
         key="production_ct_powerfactor",
@@ -559,6 +572,7 @@ CT_PRODUCTION_SENSORS = (
         entity_registry_enabled_default=False,
         value_fn=attrgetter("power_factor"),
         on_phase=None,
+        cttype=CtType.PRODUCTION,
     ),
     EnvoyCTSensorEntityDescription(
         key="production_ct_metering_status",
@@ -569,6 +583,7 @@ CT_PRODUCTION_SENSORS = (
         entity_registry_enabled_default=False,
         value_fn=attrgetter("metering_status"),
         on_phase=None,
+        cttype=CtType.PRODUCTION,
     ),
     EnvoyCTSensorEntityDescription(
         key="production_ct_status_flags",
@@ -578,6 +593,7 @@ CT_PRODUCTION_SENSORS = (
         entity_registry_enabled_default=False,
         value_fn=lambda ct: 0 if ct.status_flags is None else len(ct.status_flags),
         on_phase=None,
+        cttype=CtType.PRODUCTION,
     ),
 )
 
@@ -607,6 +623,7 @@ CT_STORAGE_SENSORS = (
         suggested_display_precision=3,
         value_fn=attrgetter("energy_delivered"),
         on_phase=None,
+        cttype=CtType.STORAGE,
     ),
     EnvoyCTSensorEntityDescription(
         key="lifetime_battery_charged",
@@ -618,6 +635,7 @@ CT_STORAGE_SENSORS = (
         suggested_display_precision=3,
         value_fn=attrgetter("energy_received"),
         on_phase=None,
+        cttype=CtType.STORAGE,
     ),
     EnvoyCTSensorEntityDescription(
         key="battery_discharge",
@@ -629,6 +647,7 @@ CT_STORAGE_SENSORS = (
         suggested_display_precision=3,
         value_fn=attrgetter("active_power"),
         on_phase=None,
+        cttype=CtType.STORAGE,
     ),
     EnvoyCTSensorEntityDescription(
         key="storage_ct_frequency",
@@ -640,6 +659,7 @@ CT_STORAGE_SENSORS = (
         entity_registry_enabled_default=False,
         value_fn=attrgetter("frequency"),
         on_phase=None,
+        cttype=CtType.STORAGE,
     ),
     EnvoyCTSensorEntityDescription(
         key="storage_voltage",
@@ -652,6 +672,7 @@ CT_STORAGE_SENSORS = (
         entity_registry_enabled_default=False,
         value_fn=attrgetter("voltage"),
         on_phase=None,
+        cttype=CtType.STORAGE,
     ),
     EnvoyCTSensorEntityDescription(
         key="storage_ct_current",
@@ -664,6 +685,7 @@ CT_STORAGE_SENSORS = (
         entity_registry_enabled_default=False,
         value_fn=attrgetter("current"),
         on_phase=None,
+        cttype=CtType.STORAGE,
     ),
     EnvoyCTSensorEntityDescription(
         key="storage_ct_powerfactor",
@@ -674,6 +696,7 @@ CT_STORAGE_SENSORS = (
         entity_registry_enabled_default=False,
         value_fn=attrgetter("power_factor"),
         on_phase=None,
+        cttype=CtType.STORAGE,
     ),
     EnvoyCTSensorEntityDescription(
         key="storage_ct_metering_status",
@@ -684,6 +707,7 @@ CT_STORAGE_SENSORS = (
         entity_registry_enabled_default=False,
         value_fn=attrgetter("metering_status"),
         on_phase=None,
+        cttype=CtType.STORAGE,
     ),
     EnvoyCTSensorEntityDescription(
         key="storage_ct_status_flags",
@@ -693,6 +717,7 @@ CT_STORAGE_SENSORS = (
         entity_registry_enabled_default=False,
         value_fn=lambda ct: 0 if ct.status_flags is None else len(ct.status_flags),
         on_phase=None,
+        cttype=CtType.STORAGE,
     ),
 )
 
@@ -1015,50 +1040,31 @@ async def async_setup_entry(
             for description in NET_CONSUMPTION_PHASE_SENSORS[use_phase]
             if phase is not None
         )
-    # Add net consumption CT entities
-    if ctmeter := envoy_data.ctmeter_consumption:
+    # Add Current Transformer entities
+    if envoy_data.ctmeters:
         entities.extend(
-            EnvoyConsumptionCTEntity(coordinator, description)
-            for description in CT_NET_CONSUMPTION_SENSORS
-            if ctmeter.measurement_type == CtType.NET_CONSUMPTION
+            EnvoyCTEntity(coordinator, description)
+            for sensors in (
+                CT_NET_CONSUMPTION_SENSORS,
+                CT_PRODUCTION_SENSORS,
+                CT_STORAGE_SENSORS,
+            )
+            for description in sensors
+            if description.cttype in envoy_data.ctmeters
         )
-    # For each net consumption ct phase reported add net consumption entities
-    if phase_data := envoy_data.ctmeter_consumption_phases:
+    # Add Current Transformer phase entities
+    if ctmeters_phases := envoy_data.ctmeters_phases:
         entities.extend(
-            EnvoyConsumptionCTPhaseEntity(coordinator, description)
-            for use_phase, phase in phase_data.items()
-            for description in CT_NET_CONSUMPTION_PHASE_SENSORS[use_phase]
-            if phase.measurement_type == CtType.NET_CONSUMPTION
-        )
-    # Add production CT entities
-    if ctmeter := envoy_data.ctmeter_production:
-        entities.extend(
-            EnvoyProductionCTEntity(coordinator, description)
-            for description in CT_PRODUCTION_SENSORS
-            if ctmeter.measurement_type == CtType.PRODUCTION
-        )
-    # For each production ct phase reported add production ct entities
-    if phase_data := envoy_data.ctmeter_production_phases:
-        entities.extend(
-            EnvoyProductionCTPhaseEntity(coordinator, description)
-            for use_phase, phase in phase_data.items()
-            for description in CT_PRODUCTION_PHASE_SENSORS[use_phase]
-            if phase.measurement_type == CtType.PRODUCTION
-        )
-    # Add storage CT entities
-    if ctmeter := envoy_data.ctmeter_storage:
-        entities.extend(
-            EnvoyStorageCTEntity(coordinator, description)
-            for description in CT_STORAGE_SENSORS
-            if ctmeter.measurement_type == CtType.STORAGE
-        )
-    # For each storage ct phase reported add storage ct entities
-    if phase_data := envoy_data.ctmeter_storage_phases:
-        entities.extend(
-            EnvoyStorageCTPhaseEntity(coordinator, description)
-            for use_phase, phase in phase_data.items()
-            for description in CT_STORAGE_PHASE_SENSORS[use_phase]
-            if phase.measurement_type == CtType.STORAGE
+            EnvoyCTPhaseEntity(coordinator, description)
+            for sensors in (
+                CT_NET_CONSUMPTION_PHASE_SENSORS,
+                CT_PRODUCTION_PHASE_SENSORS,
+                CT_STORAGE_PHASE_SENSORS,
+            )
+            for phase, descriptions in sensors.items()
+            for description in descriptions
+            if (cttype := description.cttype) in ctmeters_phases
+            and phase in ctmeters_phases[cttype]
         )
 
     if envoy_data.inverters:
@@ -1245,8 +1251,8 @@ class EnvoyNetConsumptionPhaseEntity(EnvoySystemSensorEntity):
         return self.entity_description.value_fn(system_net_consumption)
 
 
-class EnvoyConsumptionCTEntity(EnvoySystemSensorEntity):
-    """Envoy net consumption CT entity."""
+class EnvoyCTEntity(EnvoySystemSensorEntity):
+    """Envoy CT entity."""
 
     entity_description: EnvoyCTSensorEntityDescription
 
@@ -1255,13 +1261,13 @@ class EnvoyConsumptionCTEntity(EnvoySystemSensorEntity):
         self,
     ) -> int | float | str | CtType | CtMeterStatus | CtStatusFlags | None:
         """Return the state of the CT sensor."""
-        if (ctmeter := self.data.ctmeter_consumption) is None:
+        if (cttype := self.entity_description.cttype) not in self.data.ctmeters:
             return None
-        return self.entity_description.value_fn(ctmeter)
+        return self.entity_description.value_fn(self.data.ctmeters[cttype])
 
 
-class EnvoyConsumptionCTPhaseEntity(EnvoySystemSensorEntity):
-    """Envoy net consumption CT phase entity."""
+class EnvoyCTPhaseEntity(EnvoySystemSensorEntity):
+    """Envoy CT phase entity."""
 
     entity_description: EnvoyCTSensorEntityDescription
 
@@ -1272,78 +1278,14 @@ class EnvoyConsumptionCTPhaseEntity(EnvoySystemSensorEntity):
         """Return the state of the CT phase sensor."""
         if TYPE_CHECKING:
             assert self.entity_description.on_phase
-        if (ctmeter := self.data.ctmeter_consumption_phases) is None:
+        if (cttype := self.entity_description.cttype) not in self.data.ctmeters_phases:
+            return None
+        if (phase := self.entity_description.on_phase) not in self.data.ctmeters_phases[
+            cttype
+        ]:
             return None
         return self.entity_description.value_fn(
-            ctmeter[self.entity_description.on_phase]
-        )
-
-
-class EnvoyProductionCTEntity(EnvoySystemSensorEntity):
-    """Envoy net consumption CT entity."""
-
-    entity_description: EnvoyCTSensorEntityDescription
-
-    @property
-    def native_value(
-        self,
-    ) -> int | float | str | CtType | CtMeterStatus | CtStatusFlags | None:
-        """Return the state of the CT sensor."""
-        if (ctmeter := self.data.ctmeter_production) is None:
-            return None
-        return self.entity_description.value_fn(ctmeter)
-
-
-class EnvoyProductionCTPhaseEntity(EnvoySystemSensorEntity):
-    """Envoy net consumption CT phase entity."""
-
-    entity_description: EnvoyCTSensorEntityDescription
-
-    @property
-    def native_value(
-        self,
-    ) -> int | float | str | CtType | CtMeterStatus | CtStatusFlags | None:
-        """Return the state of the CT phase sensor."""
-        if TYPE_CHECKING:
-            assert self.entity_description.on_phase
-        if (ctmeter := self.data.ctmeter_production_phases) is None:
-            return None
-        return self.entity_description.value_fn(
-            ctmeter[self.entity_description.on_phase]
-        )
-
-
-class EnvoyStorageCTEntity(EnvoySystemSensorEntity):
-    """Envoy net storage CT entity."""
-
-    entity_description: EnvoyCTSensorEntityDescription
-
-    @property
-    def native_value(
-        self,
-    ) -> int | float | str | CtType | CtMeterStatus | CtStatusFlags | None:
-        """Return the state of the CT sensor."""
-        if (ctmeter := self.data.ctmeter_storage) is None:
-            return None
-        return self.entity_description.value_fn(ctmeter)
-
-
-class EnvoyStorageCTPhaseEntity(EnvoySystemSensorEntity):
-    """Envoy net storage CT phase entity."""
-
-    entity_description: EnvoyCTSensorEntityDescription
-
-    @property
-    def native_value(
-        self,
-    ) -> int | float | str | CtType | CtMeterStatus | CtStatusFlags | None:
-        """Return the state of the CT phase sensor."""
-        if TYPE_CHECKING:
-            assert self.entity_description.on_phase
-        if (ctmeter := self.data.ctmeter_storage_phases) is None:
-            return None
-        return self.entity_description.value_fn(
-            ctmeter[self.entity_description.on_phase]
+            self.data.ctmeters_phases[cttype][phase]
         )
 
 

homeassistant/components/environment_canada/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/environment_canada",
   "iot_class": "cloud_polling",
   "loggers": ["env_canada"],
-  "requirements": ["env-canada==0.11.2"]
+  "requirements": ["env-canada==0.11.3"]
 }

homeassistant/components/esphome/config_flow.py

@@ -22,19 +22,23 @@ import voluptuous as vol
 
 from homeassistant.components import zeroconf
 from homeassistant.config_entries import (
+    SOURCE_ESPHOME,
     SOURCE_IGNORE,
     SOURCE_REAUTH,
     SOURCE_RECONFIGURE,
     ConfigEntry,
     ConfigFlow,
     ConfigFlowResult,
+    FlowType,
     OptionsFlow,
 )
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_PORT
 from homeassistant.core import callback
-from homeassistant.data_entry_flow import AbortFlow
+from homeassistant.data_entry_flow import AbortFlow, FlowResultType
+from homeassistant.helpers import discovery_flow
 from homeassistant.helpers.device_registry import format_mac
 from homeassistant.helpers.service_info.dhcp import DhcpServiceInfo
+from homeassistant.helpers.service_info.esphome import ESPHomeServiceInfo
 from homeassistant.helpers.service_info.hassio import HassioServiceInfo
 from homeassistant.helpers.service_info.mqtt import MqttServiceInfo
 from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
@@ -75,6 +79,7 @@ class EsphomeFlowHandler(ConfigFlow, domain=DOMAIN):
     def __init__(self) -> None:
         """Initialize flow."""
         self._host: str | None = None
+        self._connected_address: str | None = None
         self.__name: str | None = None
         self._port: int | None = None
         self._password: str | None = None
@@ -498,18 +503,55 @@ class EsphomeFlowHandler(ConfigFlow, domain=DOMAIN):
         await self.hass.config_entries.async_remove(
             self._entry_with_name_conflict.entry_id
         )
-        return self._async_create_entry()
+        return await self._async_create_entry()
 
-    @callback
-    def _async_create_entry(self) -> ConfigFlowResult:
+    async def _async_create_entry(self) -> ConfigFlowResult:
         """Create the config entry."""
         assert self._name is not None
+        assert self._device_info is not None
+
+        # Check if Z-Wave capabilities are present and start discovery flow
+        next_flow_id: str | None = None
+        if self._device_info.zwave_proxy_feature_flags:
+            assert self._connected_address is not None
+            assert self._port is not None
+
+            # Start Z-Wave discovery flow and get the flow ID
+            zwave_result = await self.hass.config_entries.flow.async_init(
+                "zwave_js",
+                context={
+                    "source": SOURCE_ESPHOME,
+                    "discovery_key": discovery_flow.DiscoveryKey(
+                        domain=DOMAIN,
+                        key=self._device_info.mac_address,
+                        version=1,
+                    ),
+                },
+                data=ESPHomeServiceInfo(
+                    name=self._device_info.name,
+                    zwave_home_id=self._device_info.zwave_home_id or None,
+                    ip_address=self._connected_address,
+                    port=self._port,
+                    noise_psk=self._noise_psk,
+                ),
+            )
+            if zwave_result["type"] in (
+                FlowResultType.ABORT,
+                FlowResultType.CREATE_ENTRY,
+            ):
+                _LOGGER.debug(
+                    "Unable to continue created Z-Wave JS config flow: %s", zwave_result
+                )
+            else:
+                next_flow_id = zwave_result["flow_id"]
+
         return self.async_create_entry(
             title=self._name,
             data=self._async_make_config_data(),
             options={
                 CONF_ALLOW_SERVICE_CALLS: DEFAULT_NEW_CONFIG_ALLOW_ALLOW_SERVICE_CALLS,
             },
+            next_flow=(FlowType.CONFIG_FLOW, next_flow_id) if next_flow_id else None,
         )
 
     @callback
@@ -556,7 +598,7 @@ class EsphomeFlowHandler(ConfigFlow, domain=DOMAIN):
             if entry.data.get(CONF_DEVICE_NAME) == self._device_name:
                 self._entry_with_name_conflict = entry
                 return await self.async_step_name_conflict()
-        return self._async_create_entry()
+        return await self._async_create_entry()
 
     async def _async_reauth_validated_connection(self) -> ConfigFlowResult:
         """Handle reauth validated connection."""
@@ -703,6 +745,7 @@ class EsphomeFlowHandler(ConfigFlow, domain=DOMAIN):
         try:
             await cli.connect()
             self._device_info = await cli.device_info()
+            self._connected_address = cli.connected_address
         except InvalidAuthAPIError:
             return ERROR_INVALID_PASSWORD_AUTH
         except RequiresEncryptionAPIError:

homeassistant/components/esphome/manifest.json

@@ -17,9 +17,9 @@
   "mqtt": ["esphome/discover/#"],
   "quality_scale": "platinum",
   "requirements": [
-    "aioesphomeapi==41.11.0",
+    "aioesphomeapi==41.13.0",
     "esphome-dashboard-api==1.3.0",
-    "bleak-esphome==3.3.0"
+    "bleak-esphome==3.4.0"
   ],
   "zeroconf": ["_esphomelib._tcp.local."]
 }

homeassistant/components/evohome/climate.py

@@ -29,7 +29,12 @@ from homeassistant.components.climate import (
     ClimateEntityFeature,
     HVACMode,
 )
-from homeassistant.const import ATTR_MODE, PRECISION_TENTHS, UnitOfTemperature
+from homeassistant.const import (
+    ATTR_MODE,
+    ATTR_TEMPERATURE,
+    PRECISION_TENTHS,
+    UnitOfTemperature,
+)
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
@@ -243,7 +248,7 @@ class EvoZone(EvoChild, EvoClimateEntity):
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set a new target temperature."""
 
-        temperature = kwargs["temperature"]
+        temperature = kwargs[ATTR_TEMPERATURE]
 
         if (until := kwargs.get("until")) is None:
             if self._evo_device.mode == EvoZoneMode.TEMPORARY_OVERRIDE:

homeassistant/components/fritzbox/climate.py

@@ -13,27 +13,14 @@ from homeassistant.components.climate import (
     ClimateEntityFeature,
     HVACMode,
 )
-from homeassistant.const import (
-    ATTR_BATTERY_LEVEL,
-    ATTR_TEMPERATURE,
-    PRECISION_HALVES,
-    UnitOfTemperature,
-)
+from homeassistant.const import ATTR_TEMPERATURE, PRECISION_HALVES, UnitOfTemperature
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import (
-    ATTR_STATE_BATTERY_LOW,
-    ATTR_STATE_HOLIDAY_MODE,
-    ATTR_STATE_SUMMER_MODE,
-    ATTR_STATE_WINDOW_OPEN,
-    DOMAIN,
-    LOGGER,
-)
+from .const import DOMAIN, LOGGER
 from .coordinator import FritzboxConfigEntry, FritzboxDataUpdateCoordinator
 from .entity import FritzBoxDeviceEntity
-from .model import ClimateExtraAttributes
 from .sensor import value_scheduled_preset
 
 HVAC_MODES = [HVACMode.HEAT, HVACMode.OFF]
@@ -202,26 +189,6 @@ class FritzboxThermostat(FritzBoxDeviceEntity, ClimateEntity):
         self.check_active_or_lock_mode()
         await self.async_set_hkr_state(PRESET_API_HKR_STATE_MAPPING[preset_mode])
 
-    @property
-    def extra_state_attributes(self) -> ClimateExtraAttributes:
-        """Return the device specific state attributes."""
-        # deprecated with #143394, can be removed in 2025.11
-        attrs: ClimateExtraAttributes = {
-            ATTR_STATE_BATTERY_LOW: self.data.battery_low,
-        }
-
-        # the following attributes are available since fritzos 7
-        if self.data.battery_level is not None:
-            attrs[ATTR_BATTERY_LEVEL] = self.data.battery_level
-        if self.data.holiday_active is not None:
-            attrs[ATTR_STATE_HOLIDAY_MODE] = self.data.holiday_active
-        if self.data.summer_active is not None:
-            attrs[ATTR_STATE_SUMMER_MODE] = self.data.summer_active
-        if self.data.window_open is not None:
-            attrs[ATTR_STATE_WINDOW_OPEN] = self.data.window_open
-
-        return attrs
-
     def check_active_or_lock_mode(self) -> None:
         """Check if in summer/vacation mode or lock enabled."""
         if self.data.holiday_active or self.data.summer_active:

homeassistant/components/fritzbox/sensor.py

@@ -67,7 +67,7 @@ def suitable_nextchange_time(device: FritzhomeDevice) -> bool:
 
 def suitable_temperature(device: FritzhomeDevice) -> bool:
     """Check suitablity for temperature sensor."""
-    return device.has_temperature_sensor and not device.has_thermostat
+    return bool(device.has_temperature_sensor)
 
 
 def entity_category_temperature(device: FritzhomeDevice) -> EntityCategory | None:

homeassistant/components/frontend/manifest.json

@@ -20,5 +20,5 @@
   "documentation": "https://www.home-assistant.io/integrations/frontend",
   "integration_type": "system",
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20251001.0"]
+  "requirements": ["home-assistant-frontend==20251001.4"]
 }

homeassistant/components/github/coordinator.py

@@ -167,6 +167,6 @@ class GitHubDataUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
         )
         self.hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, self.unsubscribe)
 
-    def unsubscribe(self, *args) -> None:
+    def unsubscribe(self, *args: Any) -> None:
         """Unsubscribe to repository events."""
         self._client.repos.events.unsubscribe(subscription_id=self._subscription_id)

homeassistant/components/google_assistant/trait.py

@@ -182,10 +182,10 @@ FAN_SPEED_MAX_SPEED_COUNT = 5
 
 COVER_VALVE_STATES = {
     cover.DOMAIN: {
-        "closed": cover.STATE_CLOSED,
-        "closing": cover.STATE_CLOSING,
-        "open": cover.STATE_OPEN,
-        "opening": cover.STATE_OPENING,
+        "closed": cover.CoverState.CLOSED.value,
+        "closing": cover.CoverState.CLOSING.value,
+        "open": cover.CoverState.OPEN.value,
+        "opening": cover.CoverState.OPENING.value,
     },
     valve.DOMAIN: {
         "closed": valve.STATE_CLOSED,

homeassistant/components/google_assistant_sdk/__init__.py

@@ -54,7 +54,7 @@ async def async_setup_entry(
     except aiohttp.ClientResponseError as err:
         if 400 <= err.status < 500:
             raise ConfigEntryAuthFailed(
-                "OAuth session is not valid, reauth required"
+                translation_domain=DOMAIN, translation_key="reauth_required"
             ) from err
         raise ConfigEntryNotReady from err
     except aiohttp.ClientError as err:
@@ -76,10 +76,6 @@ async def async_unload_entry(
     hass: HomeAssistant, entry: GoogleAssistantSDKConfigEntry
 ) -> bool:
     """Unload a config entry."""
-    if not hass.config_entries.async_loaded_entries(DOMAIN):
-        for service_name in hass.services.async_services_for_domain(DOMAIN):
-            hass.services.async_remove(DOMAIN, service_name)
-
     conversation.async_unset_agent(hass, entry)
 
     return True

homeassistant/components/google_assistant_sdk/config_flow.py

@@ -8,7 +8,12 @@ from typing import Any
 
 import voluptuous as vol
 
-from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlowResult, OptionsFlow
+from homeassistant.config_entries import (
+    SOURCE_REAUTH,
+    SOURCE_RECONFIGURE,
+    ConfigFlowResult,
+    OptionsFlow,
+)
 from homeassistant.core import callback
 from homeassistant.helpers import config_entry_oauth2_flow
 
@@ -40,6 +45,12 @@ class OAuth2FlowHandler(
             "prompt": "consent",
         }
 
+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle a reconfiguration flow."""
+        return await self.async_step_user(user_input)
+
     async def async_step_reauth(
         self, entry_data: Mapping[str, Any]
     ) -> ConfigFlowResult:
@@ -60,6 +71,10 @@ class OAuth2FlowHandler(
             return self.async_update_reload_and_abort(
                 self._get_reauth_entry(), data=data
             )
+        if self.source == SOURCE_RECONFIGURE:
+            return self.async_update_reload_and_abort(
+                self._get_reconfigure_entry(), data=data
+            )
 
         return self.async_create_entry(
             title=DEFAULT_NAME,

homeassistant/components/google_assistant_sdk/helpers.py

@@ -26,7 +26,7 @@ from homeassistant.components.media_player import (
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_ENTITY_ID, CONF_ACCESS_TOKEN
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
+from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers.config_entry_oauth2_flow import OAuth2Session
 from homeassistant.helpers.event import async_call_later
 
@@ -68,7 +68,13 @@ async def async_send_text_commands(
 ) -> list[CommandResponse]:
     """Send text commands to Google Assistant Service."""
     # There can only be 1 entry (config_flow has single_instance_allowed)
-    entry: GoogleAssistantSDKConfigEntry = hass.config_entries.async_entries(DOMAIN)[0]
+    entries = hass.config_entries.async_loaded_entries(DOMAIN)
+    if not entries:
+        raise ServiceValidationError(
+            translation_domain=DOMAIN,
+            translation_key="entry_not_loaded",
+        )
+    entry: GoogleAssistantSDKConfigEntry = entries[0]
 
     session = entry.runtime_data.session
     try:

homeassistant/components/google_assistant_sdk/services.py

@@ -1,4 +1,4 @@
-"""Support for Google Assistant SDK."""
+"""Services for the Google Assistant SDK integration."""
 
 from __future__ import annotations
 

homeassistant/components/google_assistant_sdk/strings.json

@@ -30,7 +30,8 @@
       "oauth_failed": "[%key:common::config_flow::abort::oauth2_failed%]",
       "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
       "already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
     },
     "create_entry": {
       "default": "[%key:common::config_flow::create_entry::authenticated%]"
@@ -59,14 +60,20 @@
         },
         "media_player": {
           "name": "Media player entity",
-          "description": "Name(s) of media player entities to play response on."
+          "description": "Name(s) of media player entities to play the Google Assistant's audio response on. This does not target the device for the command itself."
         }
       }
     }
   },
   "exceptions": {
+    "entry_not_loaded": {
+      "message": "Entry not loaded"
+    },
     "grpc_error": {
       "message": "Failed to communicate with Google Assistant"
+    },
+    "reauth_required": {
+      "message": "Credentials are invalid, re-authentication required"
     }
   }
 }

homeassistant/components/google_drive/api.py

@@ -22,6 +22,7 @@ from homeassistant.exceptions import (
 from homeassistant.helpers import config_entry_oauth2_flow
 
 _UPLOAD_AND_DOWNLOAD_TIMEOUT = 12 * 3600
+_UPLOAD_MAX_RETRIES = 20
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -150,6 +151,7 @@ class DriveClient:
             backup_metadata,
             open_stream,
             backup.size,
+            max_retries=_UPLOAD_MAX_RETRIES,
             timeout=ClientTimeout(total=_UPLOAD_AND_DOWNLOAD_TIMEOUT),
         )
         _LOGGER.debug(

homeassistant/components/google_generative_ai_conversation/entity.py

@@ -456,6 +456,7 @@ class GoogleGenerativeAILLMBaseEntity(Entity):
         """Initialize the agent."""
         self.entry = entry
         self.subentry = subentry
+        self.default_model = default_model
         self._attr_name = subentry.title
         self._genai_client = entry.runtime_data
         self._attr_unique_id = subentry.subentry_id
@@ -489,7 +490,7 @@ class GoogleGenerativeAILLMBaseEntity(Entity):
             tools = tools or []
             tools.append(Tool(google_search=GoogleSearch()))
 
-        model_name = options.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL)
+        model_name = options.get(CONF_CHAT_MODEL, self.default_model)
         # Avoid INVALID_ARGUMENT Developer instruction is not enabled for <model>
         supports_system_instruction = (
             "gemma" not in model_name
@@ -620,7 +621,7 @@ class GoogleGenerativeAILLMBaseEntity(Entity):
     def create_generate_content_config(self) -> GenerateContentConfig:
         """Create the GenerateContentConfig for the LLM."""
         options = self.subentry.data
-        model = options.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL)
+        model = options.get(CONF_CHAT_MODEL, self.default_model)
         thinking_config: ThinkingConfig | None = None
         if model.startswith("models/gemini-2.5") and not model.endswith(
             ("tts", "image", "image-preview")

homeassistant/components/google_travel_time/sensor.py

@@ -22,6 +22,7 @@ from google.protobuf import timestamp_pb2
 from homeassistant.components.sensor import (
     SensorDeviceClass,
     SensorEntity,
+    SensorEntityDescription,
     SensorStateClass,
 )
 from homeassistant.config_entries import ConfigEntry
@@ -91,6 +92,16 @@ def convert_time(time_str: str) -> timestamp_pb2.Timestamp | None:
     return timestamp
 
 
+SENSOR_DESCRIPTIONS = [
+    SensorEntityDescription(
+        key="duration",
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.DURATION,
+        native_unit_of_measurement=UnitOfTime.MINUTES,
+    )
+]
+
+
 async def async_setup_entry(
     hass: HomeAssistant,
     config_entry: ConfigEntry,
@@ -105,20 +116,20 @@ async def async_setup_entry(
     client_options = ClientOptions(api_key=api_key)
     client = RoutesAsyncClient(client_options=client_options)
 
-    sensor = GoogleTravelTimeSensor(
-        config_entry, name, api_key, origin, destination, client
-    )
+    sensors = [
+        GoogleTravelTimeSensor(
+            config_entry, name, api_key, origin, destination, client, sensor_description
+        )
+        for sensor_description in SENSOR_DESCRIPTIONS
+    ]
 
-    async_add_entities([sensor], False)
+    async_add_entities(sensors, False)
 
 
 class GoogleTravelTimeSensor(SensorEntity):
     """Representation of a Google travel time sensor."""
 
     _attr_attribution = ATTRIBUTION
-    _attr_native_unit_of_measurement = UnitOfTime.MINUTES
-    _attr_device_class = SensorDeviceClass.DURATION
-    _attr_state_class = SensorStateClass.MEASUREMENT
 
     def __init__(
         self,
@@ -128,8 +139,10 @@ class GoogleTravelTimeSensor(SensorEntity):
         origin: str,
         destination: str,
         client: RoutesAsyncClient,
+        sensor_description: SensorEntityDescription,
     ) -> None:
         """Initialize the sensor."""
+        self.entity_description = sensor_description
         self._attr_name = name
         self._attr_unique_id = config_entry.entry_id
         self._attr_device_info = DeviceInfo(

homeassistant/components/hassio/switch.py

@@ -73,7 +73,6 @@ class HassioAddonSwitch(HassioAddonEntity, SwitchEntity):
         try:
             await supervisor_client.addons.start_addon(self._addon_slug)
         except SupervisorError as err:
-            _LOGGER.error("Failed to start addon %s: %s", self._addon_slug, err)
             raise HomeAssistantError(err) from err
 
         await self.coordinator.force_addon_info_data_refresh(self._addon_slug)

homeassistant/components/holiday/manifest.json

@@ -5,5 +5,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/holiday",
   "iot_class": "local_polling",
-  "requirements": ["holidays==0.81", "babel==2.15.0"]
+  "requirements": ["holidays==0.82", "babel==2.15.0"]
 }

homeassistant/components/home_connect/const.py

@@ -99,6 +99,20 @@ CLEANING_MODE_OPTIONS = {
         "ConsumerProducts.CleaningRobot.EnumType.CleaningModes.Silent",
         "ConsumerProducts.CleaningRobot.EnumType.CleaningModes.Standard",
         "ConsumerProducts.CleaningRobot.EnumType.CleaningModes.Power",
+        "ConsumerProducts.CleaningRobot.EnumType.CleaningMode.IntelligentMode",
+        "ConsumerProducts.CleaningRobot.EnumType.CleaningMode.VacuumOnly",
+        "ConsumerProducts.CleaningRobot.EnumType.CleaningMode.MopOnly",
+        "ConsumerProducts.CleaningRobot.EnumType.CleaningMode.VacuumAndMop",
+        "ConsumerProducts.CleaningRobot.EnumType.CleaningMode.MopAfterVacuum",
+    )
+}
+
+SUCTION_POWER_OPTIONS = {
+    bsh_key_to_translation_key(option): option
+    for option in (
+        "ConsumerProducts.CleaningRobot.EnumType.SuctionPower.Silent",
+        "ConsumerProducts.CleaningRobot.EnumType.SuctionPower.Standard",
+        "ConsumerProducts.CleaningRobot.EnumType.SuctionPower.Max",
     )
 }
 
@@ -309,6 +323,10 @@ PROGRAM_ENUM_OPTIONS = {
             OptionKey.CONSUMER_PRODUCTS_CLEANING_ROBOT_CLEANING_MODE,
             CLEANING_MODE_OPTIONS,
         ),
+        (
+            OptionKey.CONSUMER_PRODUCTS_CLEANING_ROBOT_SUCTION_POWER,
+            SUCTION_POWER_OPTIONS,
+        ),
         (OptionKey.CONSUMER_PRODUCTS_COFFEE_MAKER_BEAN_AMOUNT, BEAN_AMOUNT_OPTIONS),
         (
             OptionKey.CONSUMER_PRODUCTS_COFFEE_MAKER_COFFEE_TEMPERATURE,

homeassistant/components/home_connect/select.py

@@ -30,6 +30,7 @@ from .const import (
     INTENSIVE_LEVEL_OPTIONS,
     PROGRAMS_TRANSLATION_KEYS_MAP,
     SPIN_SPEED_OPTIONS,
+    SUCTION_POWER_OPTIONS,
     TEMPERATURE_OPTIONS,
     TRANSLATION_KEYS_PROGRAMS_MAP,
     VARIO_PERFECT_OPTIONS,
@@ -168,6 +169,16 @@ PROGRAM_SELECT_OPTION_ENTITY_DESCRIPTIONS = (
             for translation_key, value in CLEANING_MODE_OPTIONS.items()
         },
     ),
+    HomeConnectSelectEntityDescription(
+        key=OptionKey.CONSUMER_PRODUCTS_CLEANING_ROBOT_SUCTION_POWER,
+        translation_key="suction_power",
+        options=list(SUCTION_POWER_OPTIONS),
+        translation_key_values=SUCTION_POWER_OPTIONS,
+        values_translation_key={
+            value: translation_key
+            for translation_key, value in SUCTION_POWER_OPTIONS.items()
+        },
+    ),
     HomeConnectSelectEntityDescription(
         key=OptionKey.CONSUMER_PRODUCTS_COFFEE_MAKER_BEAN_AMOUNT,
         translation_key="bean_amount",

homeassistant/components/home_connect/services.yaml

@@ -202,6 +202,22 @@ set_program_and_options:
                 - consumer_products_cleaning_robot_enum_type_cleaning_modes_silent
                 - consumer_products_cleaning_robot_enum_type_cleaning_modes_standard
                 - consumer_products_cleaning_robot_enum_type_cleaning_modes_power
+                - consumer_products_cleaning_robot_enum_type_cleaning_mode_intelligent_mode
+                - consumer_products_cleaning_robot_enum_type_cleaning_mode_vacuum_only
+                - consumer_products_cleaning_robot_enum_type_cleaning_mode_mop_only
+                - consumer_products_cleaning_robot_enum_type_cleaning_mode_vacuum_and_mop
+                - consumer_products_cleaning_robot_enum_type_cleaning_mode_mop_after_vacuum
+        consumer_products_cleaning_robot_option_suction_power:
+          example: consumer_products_cleaning_robot_enum_type_suction_power_standard
+          required: false
+          selector:
+            select:
+              mode: dropdown
+              translation_key: suction_power
+              options:
+                - consumer_products_cleaning_robot_enum_type_suction_power_silent
+                - consumer_products_cleaning_robot_enum_type_suction_power_standard
+                - consumer_products_cleaning_robot_enum_type_suction_power_max
     coffee_maker_options:
       collapsed: true
       fields:

homeassistant/components/home_connect/strings.json

@@ -324,7 +324,19 @@
       "options": {
         "consumer_products_cleaning_robot_enum_type_cleaning_modes_silent": "Silent",
         "consumer_products_cleaning_robot_enum_type_cleaning_modes_standard": "Standard",
-        "consumer_products_cleaning_robot_enum_type_cleaning_modes_power": "Power"
+        "consumer_products_cleaning_robot_enum_type_cleaning_modes_power": "Power",
+        "consumer_products_cleaning_robot_enum_type_cleaning_mode_intelligent_mode": "Intelligent mode",
+        "consumer_products_cleaning_robot_enum_type_cleaning_mode_vacuum_only": "Vacuum only",
+        "consumer_products_cleaning_robot_enum_type_cleaning_mode_mop_only": "Mop only",
+        "consumer_products_cleaning_robot_enum_type_cleaning_mode_vacuum_and_mop": "Vacuum and mop",
+        "consumer_products_cleaning_robot_enum_type_cleaning_mode_mop_after_vacuum": "Mop after vacuum"
+      }
+    },
+    "suction_power": {
+      "options": {
+        "consumer_products_cleaning_robot_enum_type_suction_power_silent": "Silent",
+        "consumer_products_cleaning_robot_enum_type_suction_power_standard": "Standard",
+        "consumer_products_cleaning_robot_enum_type_suction_power_max": "Max"
       }
     },
     "bean_amount": {
@@ -519,6 +531,10 @@
           "name": "Cleaning mode",
           "description": "Defines the favored cleaning mode."
         },
+        "consumer_products_cleaning_robot_option_suction_power": {
+          "name": "Suction power",
+          "description": "Defines the suction power."
+        },
         "consumer_products_coffee_maker_option_bean_amount": {
           "name": "Bean amount",
           "description": "Describes the amount of coffee beans used in a coffee machine program."
@@ -1196,7 +1212,20 @@
         "state": {
           "consumer_products_cleaning_robot_enum_type_cleaning_modes_silent": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_modes_silent%]",
           "consumer_products_cleaning_robot_enum_type_cleaning_modes_standard": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_modes_standard%]",
-          "consumer_products_cleaning_robot_enum_type_cleaning_modes_power": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_modes_power%]"
+          "consumer_products_cleaning_robot_enum_type_cleaning_modes_power": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_modes_power%]",
+          "consumer_products_cleaning_robot_enum_type_cleaning_mode_intelligent_mode": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_mode_intelligent_mode%]",
+          "consumer_products_cleaning_robot_enum_type_cleaning_mode_vacuum_only": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_mode_vacuum_only%]",
+          "consumer_products_cleaning_robot_enum_type_cleaning_mode_mop_only": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_mode_mop_only%]",
+          "consumer_products_cleaning_robot_enum_type_cleaning_mode_vacuum_and_mop": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_mode_vacuum_and_mop%]",
+          "consumer_products_cleaning_robot_enum_type_cleaning_mode_mop_after_vacuum": "[%key:component::home_connect::selector::cleaning_mode::options::consumer_products_cleaning_robot_enum_type_cleaning_mode_mop_after_vacuum%]"
+        }
+      },
+      "suction_power": {
+        "name": "[%key:component::home_connect::services::set_program_and_options::fields::consumer_products_cleaning_robot_option_suction_power::name%]",
+        "state": {
+          "consumer_products_cleaning_robot_enum_type_suction_power_silent": "[%key:component::home_connect::selector::suction_power::options::consumer_products_cleaning_robot_enum_type_suction_power_silent%]",
+          "consumer_products_cleaning_robot_enum_type_suction_power_standard": "[%key:component::home_connect::selector::suction_power::options::consumer_products_cleaning_robot_enum_type_suction_power_standard%]",
+          "consumer_products_cleaning_robot_enum_type_suction_power_max": "[%key:component::home_connect::selector::suction_power::options::consumer_products_cleaning_robot_enum_type_suction_power_max%]"
         }
       },
       "bean_amount": {

homeassistant/components/homeassistant_connect_zbt2/manifest.json

@@ -13,6 +13,12 @@
       "pid": "4001",
       "description": "*zbt-2*",
       "known_devices": ["ZBT-2"]
+    },
+    {
+      "vid": "303A",
+      "pid": "831A",
+      "description": "*zbt-2*",
+      "known_devices": ["ZBT-2"]
     }
   ]
 }

homeassistant/components/homeassistant_hardware/helpers.py

@@ -1,15 +1,20 @@
 """Home Assistant Hardware integration helpers."""
 
+from __future__ import annotations
+
 from collections import defaultdict
 from collections.abc import AsyncIterator, Awaitable, Callable
+from contextlib import asynccontextmanager
 import logging
-from typing import Protocol
+from typing import TYPE_CHECKING, Protocol
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import CALLBACK_TYPE, HomeAssistant, callback as hass_callback
 
 from . import DATA_COMPONENT
-from .util import FirmwareInfo
+
+if TYPE_CHECKING:
+    from .util import FirmwareInfo
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -51,6 +56,7 @@ class HardwareInfoDispatcher:
         self._notification_callbacks: defaultdict[
             str, set[Callable[[FirmwareInfo], None]]
         ] = defaultdict(set)
+        self._active_firmware_updates: dict[str, str] = {}
 
     def register_firmware_info_provider(
         self, domain: str, platform: HardwareFirmwareInfoModule
@@ -118,6 +124,36 @@ class HardwareInfoDispatcher:
                 if fw_info is not None:
                     yield fw_info
 
+    def register_firmware_update_in_progress(
+        self, device: str, source_domain: str
+    ) -> None:
+        """Register that a firmware update is in progress for a device."""
+        if device in self._active_firmware_updates:
+            current_domain = self._active_firmware_updates[device]
+            raise ValueError(
+                f"Firmware update already in progress for {device} by {current_domain}"
+            )
+        self._active_firmware_updates[device] = source_domain
+
+    def unregister_firmware_update_in_progress(
+        self, device: str, source_domain: str
+    ) -> None:
+        """Unregister a firmware update for a device."""
+        if device not in self._active_firmware_updates:
+            raise ValueError(f"No firmware update in progress for {device}")
+
+        if self._active_firmware_updates[device] != source_domain:
+            current_domain = self._active_firmware_updates[device]
+            raise ValueError(
+                f"Firmware update for {device} is owned by {current_domain}, not {source_domain}"
+            )
+
+        del self._active_firmware_updates[device]
+
+    def is_firmware_update_in_progress(self, device: str) -> bool:
+        """Check if a firmware update is in progress for a device."""
+        return device in self._active_firmware_updates
+
 
 @hass_callback
 def async_register_firmware_info_provider(
@@ -141,3 +177,42 @@ def async_notify_firmware_info(
 ) -> Awaitable[None]:
     """Notify the dispatcher of new firmware information."""
     return hass.data[DATA_COMPONENT].notify_firmware_info(domain, firmware_info)
+
+
+@hass_callback
+def async_register_firmware_update_in_progress(
+    hass: HomeAssistant, device: str, source_domain: str
+) -> None:
+    """Register that a firmware update is in progress for a device."""
+    return hass.data[DATA_COMPONENT].register_firmware_update_in_progress(
+        device, source_domain
+    )
+
+
+@hass_callback
+def async_unregister_firmware_update_in_progress(
+    hass: HomeAssistant, device: str, source_domain: str
+) -> None:
+    """Unregister a firmware update for a device."""
+    return hass.data[DATA_COMPONENT].unregister_firmware_update_in_progress(
+        device, source_domain
+    )
+
+
+@hass_callback
+def async_is_firmware_update_in_progress(hass: HomeAssistant, device: str) -> bool:
+    """Check if a firmware update is in progress for a device."""
+    return hass.data[DATA_COMPONENT].is_firmware_update_in_progress(device)
+
+
+@asynccontextmanager
+async def async_firmware_update_context(
+    hass: HomeAssistant, device: str, source_domain: str
+) -> AsyncIterator[None]:
+    """Register a device as having its firmware being actively updated."""
+    async_register_firmware_update_in_progress(hass, device, source_domain)
+
+    try:
+        yield
+    finally:
+        async_unregister_firmware_update_in_progress(hass, device, source_domain)

homeassistant/components/homeassistant_hardware/strings.json

@@ -67,7 +67,7 @@
         }
       },
       "abort": {
-        "not_hassio_thread": "The OpenThread Border Router add-on can only be installed with Home Assistant OS. If you would like to use the {model} as a Thread border router, please flash the firmware manually using the [web flasher]({docs_web_flasher_url}) and set up OpenThread Border Router to communicate with it.",
+        "not_hassio_thread": "The OpenThread Border Router add-on can only be installed with Home Assistant OS. If you would like to use the {model} as a Thread border router, please manually set up OpenThread Border Router to communicate with it.",
         "otbr_addon_already_running": "The OpenThread Border Router add-on is already running, it cannot be installed again.",
         "zha_still_using_stick": "This {model} is in use by the Zigbee Home Automation integration. Please migrate your Zigbee network to another adapter or delete the integration and try again.",
         "otbr_still_using_stick": "This {model} is in use by the OpenThread Border Router add-on. If you use the Thread network, make sure you have alternative border routers. Uninstall the add-on and try again.",

homeassistant/components/homeassistant_hardware/update.py

@@ -275,6 +275,7 @@ class BaseFirmwareUpdateEntity(
                 expected_installed_firmware_type=self.entity_description.expected_firmware_type,
                 bootloader_reset_methods=self.bootloader_reset_methods,
                 progress_callback=self._update_progress,
+                domain=self._config_entry.domain,
             )
         finally:
             self._attr_in_progress = False

homeassistant/components/homeassistant_hardware/util.py

@@ -26,6 +26,7 @@ from homeassistant.helpers.singleton import singleton
 
 from . import DATA_COMPONENT
 from .const import (
+    DOMAIN,
     OTBR_ADDON_MANAGER_DATA,
     OTBR_ADDON_NAME,
     OTBR_ADDON_SLUG,
@@ -33,6 +34,7 @@ from .const import (
     ZIGBEE_FLASHER_ADDON_NAME,
     ZIGBEE_FLASHER_ADDON_SLUG,
 )
+from .helpers import async_firmware_update_context
 from .silabs_multiprotocol_addon import (
     WaitingAddonManager,
     get_multiprotocol_addon_manager,
@@ -359,45 +361,50 @@ async def async_flash_silabs_firmware(
     expected_installed_firmware_type: ApplicationType,
     bootloader_reset_methods: Sequence[ResetTarget] = (),
     progress_callback: Callable[[int, int], None] | None = None,
+    *,
+    domain: str = DOMAIN,
 ) -> FirmwareInfo:
     """Flash firmware to the SiLabs device."""
-    firmware_info = await guess_firmware_info(hass, device)
-    _LOGGER.debug("Identified firmware info: %s", firmware_info)
+    async with async_firmware_update_context(hass, device, domain):
+        firmware_info = await guess_firmware_info(hass, device)
+        _LOGGER.debug("Identified firmware info: %s", firmware_info)
 
-    fw_image = await hass.async_add_executor_job(parse_firmware_image, fw_data)
+        fw_image = await hass.async_add_executor_job(parse_firmware_image, fw_data)
 
-    flasher = Flasher(
-        device=device,
-        probe_methods=(
-            ApplicationType.GECKO_BOOTLOADER.as_flasher_application_type(),
-            ApplicationType.EZSP.as_flasher_application_type(),
-            ApplicationType.SPINEL.as_flasher_application_type(),
-            ApplicationType.CPC.as_flasher_application_type(),
-        ),
-        bootloader_reset=tuple(
-            m.as_flasher_reset_target() for m in bootloader_reset_methods
-        ),
-    )
-
-    async with AsyncExitStack() as stack:
-        for owner in firmware_info.owners:
-            await stack.enter_async_context(owner.temporarily_stop(hass))
-
-        try:
-            # Enter the bootloader with indeterminate progress
-            await flasher.enter_bootloader()
-
-            # Flash the firmware, with progress
-            await flasher.flash_firmware(fw_image, progress_callback=progress_callback)
-        except Exception as err:
-            raise HomeAssistantError("Failed to flash firmware") from err
-
-        probed_firmware_info = await probe_silabs_firmware_info(
-            device,
-            probe_methods=(expected_installed_firmware_type,),
+        flasher = Flasher(
+            device=device,
+            probe_methods=(
+                ApplicationType.GECKO_BOOTLOADER.as_flasher_application_type(),
+                ApplicationType.EZSP.as_flasher_application_type(),
+                ApplicationType.SPINEL.as_flasher_application_type(),
+                ApplicationType.CPC.as_flasher_application_type(),
+            ),
+            bootloader_reset=tuple(
+                m.as_flasher_reset_target() for m in bootloader_reset_methods
+            ),
         )
 
-    if probed_firmware_info is None:
-        raise HomeAssistantError("Failed to probe the firmware after flashing")
+        async with AsyncExitStack() as stack:
+            for owner in firmware_info.owners:
+                await stack.enter_async_context(owner.temporarily_stop(hass))
 
-    return probed_firmware_info
+            try:
+                # Enter the bootloader with indeterminate progress
+                await flasher.enter_bootloader()
+
+                # Flash the firmware, with progress
+                await flasher.flash_firmware(
+                    fw_image, progress_callback=progress_callback
+                )
+            except Exception as err:
+                raise HomeAssistantError("Failed to flash firmware") from err
+
+            probed_firmware_info = await probe_silabs_firmware_info(
+                device,
+                probe_methods=(expected_installed_firmware_type,),
+            )
+
+        if probed_firmware_info is None:
+            raise HomeAssistantError("Failed to probe the firmware after flashing")
+
+        return probed_firmware_info

homeassistant/components/homekit/accessories.py

@@ -456,7 +456,7 @@ class HomeAccessory(Accessory):  # type: ignore[misc]
         return self._available
 
     @ha_callback
-    @pyhap_callback  # type: ignore[misc]
+    @pyhap_callback  # type: ignore[untyped-decorator]
     def run(self) -> None:
         """Handle accessory driver started event."""
         if state := self.hass.states.get(self.entity_id):
@@ -725,7 +725,7 @@ class HomeDriver(AccessoryDriver):  # type: ignore[misc]
         self._entry_title = entry_title
         self.iid_storage = iid_storage
 
-    @pyhap_callback  # type: ignore[misc]
+    @pyhap_callback  # type: ignore[untyped-decorator]
     def pair(
         self, client_username_bytes: bytes, client_public: str, client_permissions: int
     ) -> bool:
@@ -735,7 +735,7 @@ class HomeDriver(AccessoryDriver):  # type: ignore[misc]
             async_dismiss_setup_message(self.hass, self.entry_id)
         return cast(bool, success)
 
-    @pyhap_callback  # type: ignore[misc]
+    @pyhap_callback  # type: ignore[untyped-decorator]
     def unpair(self, client_uuid: UUID) -> None:
         """Override super function to show setup message if unpaired."""
         super().unpair(client_uuid)

homeassistant/components/homekit/doorbell.py

@@ -71,7 +71,7 @@ class HomeDoorbellAccessory(HomeAccessory):
         self.async_update_doorbell_state(None, state)
 
     @ha_callback
-    @pyhap_callback  # type: ignore[misc]
+    @pyhap_callback  # type: ignore[untyped-decorator]
     def run(self) -> None:
         """Handle doorbell event."""
         if self._char_doorbell_detected:

homeassistant/components/homekit/manifest.json

@@ -10,7 +10,7 @@
   "loggers": ["pyhap"],
   "requirements": [
     "HAP-python==5.0.0",
-    "fnv-hash-fast==1.5.0",
+    "fnv-hash-fast==1.6.0",
     "PyQRCode==1.2.1",
     "base36==0.1.1"
   ],

homeassistant/components/homekit/type_air_purifiers.py

@@ -219,7 +219,7 @@ class AirPurifier(Fan):
         return preset_mode.lower() != "auto"
 
     @callback
-    @pyhap_callback  # type: ignore[misc]
+    @pyhap_callback  # type: ignore[untyped-decorator]
     def run(self) -> None:
         """Handle accessory driver started event.