Remove async_setup/async_setup_entry/async_unload_entry from __all__ (#154674)

Signed-off-by: Alistair Francis <alistair@alistair23.me>

.github/workflows/builder.yml

@@ -326,7 +326,7 @@ jobs:
         uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - name: Install Cosign
-        uses: sigstore/cosign-installer@d7543c93d881b35a8faa02e8e3605f69b7a1ce62 # v3.10.0
+        uses: sigstore/cosign-installer@faadad0cce49287aee09b3a48701e75088a2c6ad # v4.0.0
         with:
           cosign-release: "v2.2.3"
 

.github/workflows/ci.yaml

@@ -37,12 +37,12 @@ on:
         type: boolean
 
 env:
-  CACHE_VERSION: 8
+  CACHE_VERSION: 9
   UV_CACHE_VERSION: 1
   MYPY_CACHE_VERSION: 1
   HA_SHORT_VERSION: "2025.11"
   DEFAULT_PYTHON: "3.13"
-  ALL_PYTHON_VERSIONS: "['3.13']"
+  ALL_PYTHON_VERSIONS: "['3.13', '3.14']"
   # 10.3 is the oldest supported version
   # - 10.3.32 is the version currently shipped with Synology (as of 17 Feb 2022)
   # 10.6 is the current long-term-support
@@ -525,7 +525,7 @@ jobs:
           . venv/bin/activate
           python --version
           pip install "$(grep '^uv' < requirements.txt)"
-          uv pip install -U "pip>=21.3.1" setuptools wheel
+          uv pip install -U "pip>=25.2"
           uv pip install -r requirements.txt
           python -m script.gen_requirements_all ci
           uv pip install -r requirements_all_pytest.txt -r requirements_test.txt
@@ -625,7 +625,7 @@ jobs:
     steps:
       - *checkout
       - name: Dependency review
-        uses: actions/dependency-review-action@56339e523c0409420f6c2c9a2f4292bbb3c07dd3 # v4.8.0
+        uses: actions/dependency-review-action@40c09b7dc99638e5ddb0bfd91c1673effc064d8a # v4.8.1
         with:
           license-check: false # We use our own license audit checks
 

.github/workflows/codeql.yml

@@ -24,11 +24,11 @@ jobs:
         uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@e296a935590eb16afc0c0108289f68c87e2a89a5 # v4.30.7
+        uses: github/codeql-action/init@f443b600d91635bebf5b0d9ebc620189c0d6fba5 # v4.30.8
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@e296a935590eb16afc0c0108289f68c87e2a89a5 # v4.30.7
+        uses: github/codeql-action/analyze@f443b600d91635bebf5b0d9ebc620189c0d6fba5 # v4.30.8
         with:
           category: "/language:python"

.gitignore

@@ -79,7 +79,6 @@ junit.xml
 .project
 .pydevproject
 
-.python-version
 .tool-versions
 
 # emacs auto backups

.python-version

@@ -0,0 +1 @@
+3.13

CODEOWNERS

@@ -46,6 +46,8 @@ build.json @home-assistant/supervisor
 /tests/components/accuweather/ @bieniu
 /homeassistant/components/acmeda/ @atmurray
 /tests/components/acmeda/ @atmurray
+/homeassistant/components/actron_air/ @kclif9 @JagadishDhanamjayam
+/tests/components/actron_air/ @kclif9 @JagadishDhanamjayam
 /homeassistant/components/adax/ @danielhiversen @lazytarget
 /tests/components/adax/ @danielhiversen @lazytarget
 /homeassistant/components/adguard/ @frenck
@@ -617,6 +619,8 @@ build.json @home-assistant/supervisor
 /tests/components/greeneye_monitor/ @jkeljo
 /homeassistant/components/group/ @home-assistant/core
 /tests/components/group/ @home-assistant/core
+/homeassistant/components/growatt_server/ @johanzander
+/tests/components/growatt_server/ @johanzander
 /homeassistant/components/guardian/ @bachya
 /tests/components/guardian/ @bachya
 /homeassistant/components/habitica/ @tr4nt0r
@@ -762,8 +766,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/intent/ @home-assistant/core @synesthesiam @arturpragacz
 /tests/components/intent/ @home-assistant/core @synesthesiam @arturpragacz
 /homeassistant/components/intesishome/ @jnimmo
-/homeassistant/components/iometer/ @MaestroOnICe
-/tests/components/iometer/ @MaestroOnICe
+/homeassistant/components/iometer/ @jukrebs
+/tests/components/iometer/ @jukrebs
 /homeassistant/components/ios/ @robbiet480
 /tests/components/ios/ @robbiet480
 /homeassistant/components/iotawatt/ @gtdiehl @jyavenard
@@ -1065,8 +1069,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/nintendo_parental_controls/ @pantherale0
+/tests/components/nintendo_parental_controls/ @pantherale0
 /homeassistant/components/nissan_leaf/ @filcole
 /homeassistant/components/noaa_tides/ @jdelaney72
 /homeassistant/components/nobo_hub/ @echoromeo @oyvindwe
@@ -1135,6 +1139,8 @@ build.json @home-assistant/supervisor
 /tests/components/opengarage/ @danielhiversen
 /homeassistant/components/openhome/ @bazwilliams
 /tests/components/openhome/ @bazwilliams
+/homeassistant/components/openrgb/ @felipecrs
+/tests/components/openrgb/ @felipecrs
 /homeassistant/components/opensky/ @joostlek
 /tests/components/opensky/ @joostlek
 /homeassistant/components/opentherm_gw/ @mvn23
@@ -1479,8 +1485,8 @@ build.json @home-assistant/supervisor
 /tests/components/snoo/ @Lash-L
 /homeassistant/components/snooz/ @AustinBrunkhorst
 /tests/components/snooz/ @AustinBrunkhorst
-/homeassistant/components/solaredge/ @frenck @bdraco
-/tests/components/solaredge/ @frenck @bdraco
+/homeassistant/components/solaredge/ @frenck @bdraco @tronikos
+/tests/components/solaredge/ @frenck @bdraco @tronikos
 /homeassistant/components/solaredge_local/ @drobtravels @scheric
 /homeassistant/components/solarlog/ @Ernst79 @dontinelli
 /tests/components/solarlog/ @Ernst79 @dontinelli

Dockerfile.dev

@@ -36,7 +36,8 @@ COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
 
 USER vscode
 
-RUN uv python install 3.13.2
+COPY .python-version ./
+RUN uv python install
 
 ENV VIRTUAL_ENV="/home/vscode/.local/ha-venv"
 RUN uv venv $VIRTUAL_ENV

build.yaml

@@ -1,10 +1,10 @@
 image: ghcr.io/home-assistant/{arch}-homeassistant
 build_from:
-  aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2025.10.0
-  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2025.10.0
-  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2025.10.0
-  amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2025.10.0
-  i386: ghcr.io/home-assistant/i386-homeassistant-base:2025.10.0
+  aarch64: ghcr.io/home-assistant/aarch64-homeassistant-base:2025.10.1
+  armhf: ghcr.io/home-assistant/armhf-homeassistant-base:2025.10.1
+  armv7: ghcr.io/home-assistant/armv7-homeassistant-base:2025.10.1
+  amd64: ghcr.io/home-assistant/amd64-homeassistant-base:2025.10.1
+  i386: ghcr.io/home-assistant/i386-homeassistant-base:2025.10.1
 codenotary:
   signer: notary@home-assistant.io
   base_image: notary@home-assistant.io

homeassistant/components/actron_air/__init__.py

@@ -0,0 +1,57 @@
+"""The Actron Air integration."""
+
+from actron_neo_api import (
+    ActronAirNeoACSystem,
+    ActronNeoAPI,
+    ActronNeoAPIError,
+    ActronNeoAuthError,
+)
+
+from homeassistant.const import CONF_API_TOKEN, Platform
+from homeassistant.core import HomeAssistant
+
+from .const import _LOGGER
+from .coordinator import (
+    ActronAirConfigEntry,
+    ActronAirRuntimeData,
+    ActronAirSystemCoordinator,
+)
+
+PLATFORM = [Platform.CLIMATE]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: ActronAirConfigEntry) -> bool:
+    """Set up Actron Air integration from a config entry."""
+
+    api = ActronNeoAPI(refresh_token=entry.data[CONF_API_TOKEN])
+    systems: list[ActronAirNeoACSystem] = []
+
+    try:
+        systems = await api.get_ac_systems()
+        await api.update_status()
+    except ActronNeoAuthError:
+        _LOGGER.error("Authentication error while setting up Actron Air integration")
+        raise
+    except ActronNeoAPIError as err:
+        _LOGGER.error("API error while setting up Actron Air integration: %s", err)
+        raise
+
+    system_coordinators: dict[str, ActronAirSystemCoordinator] = {}
+    for system in systems:
+        coordinator = ActronAirSystemCoordinator(hass, entry, api, system)
+        _LOGGER.debug("Setting up coordinator for system: %s", system["serial"])
+        await coordinator.async_config_entry_first_refresh()
+        system_coordinators[system["serial"]] = coordinator
+
+    entry.runtime_data = ActronAirRuntimeData(
+        api=api,
+        system_coordinators=system_coordinators,
+    )
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORM)
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ActronAirConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORM)

homeassistant/components/actron_air/climate.py

@@ -0,0 +1,259 @@
+"""Climate platform for Actron Air integration."""
+
+from typing import Any
+
+from actron_neo_api import ActronAirNeoStatus, ActronAirNeoZone
+
+from homeassistant.components.climate import (
+    FAN_AUTO,
+    FAN_HIGH,
+    FAN_LOW,
+    FAN_MEDIUM,
+    ClimateEntity,
+    ClimateEntityFeature,
+    HVACMode,
+)
+from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import ActronAirConfigEntry, ActronAirSystemCoordinator
+
+PARALLEL_UPDATES = 0
+
+FAN_MODE_MAPPING_ACTRONAIR_TO_HA = {
+    "AUTO": FAN_AUTO,
+    "LOW": FAN_LOW,
+    "MED": FAN_MEDIUM,
+    "HIGH": FAN_HIGH,
+}
+FAN_MODE_MAPPING_HA_TO_ACTRONAIR = {
+    v: k for k, v in FAN_MODE_MAPPING_ACTRONAIR_TO_HA.items()
+}
+HVAC_MODE_MAPPING_ACTRONAIR_TO_HA = {
+    "COOL": HVACMode.COOL,
+    "HEAT": HVACMode.HEAT,
+    "FAN": HVACMode.FAN_ONLY,
+    "AUTO": HVACMode.AUTO,
+    "OFF": HVACMode.OFF,
+}
+HVAC_MODE_MAPPING_HA_TO_ACTRONAIR = {
+    v: k for k, v in HVAC_MODE_MAPPING_ACTRONAIR_TO_HA.items()
+}
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: ActronAirConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Actron Air climate entities."""
+    system_coordinators = entry.runtime_data.system_coordinators
+    entities: list[ClimateEntity] = []
+
+    for coordinator in system_coordinators.values():
+        status = coordinator.data
+        name = status.ac_system.system_name
+        entities.append(ActronSystemClimate(coordinator, name))
+
+        entities.extend(
+            ActronZoneClimate(coordinator, zone)
+            for zone in status.remote_zone_info
+            if zone.exists
+        )
+
+    async_add_entities(entities)
+
+
+class BaseClimateEntity(CoordinatorEntity[ActronAirSystemCoordinator], ClimateEntity):
+    """Base class for Actron Air climate entities."""
+
+    _attr_has_entity_name = True
+    _attr_temperature_unit = UnitOfTemperature.CELSIUS
+    _attr_supported_features = (
+        ClimateEntityFeature.TARGET_TEMPERATURE
+        | ClimateEntityFeature.FAN_MODE
+        | ClimateEntityFeature.TURN_ON
+        | ClimateEntityFeature.TURN_OFF
+    )
+    _attr_name = None
+    _attr_fan_modes = list(FAN_MODE_MAPPING_ACTRONAIR_TO_HA.values())
+    _attr_hvac_modes = list(HVAC_MODE_MAPPING_ACTRONAIR_TO_HA.values())
+
+    def __init__(
+        self,
+        coordinator: ActronAirSystemCoordinator,
+        name: str,
+    ) -> None:
+        """Initialize an Actron Air unit."""
+        super().__init__(coordinator)
+        self._serial_number = coordinator.serial_number
+
+
+class ActronSystemClimate(BaseClimateEntity):
+    """Representation of the Actron Air system."""
+
+    _attr_supported_features = (
+        ClimateEntityFeature.TARGET_TEMPERATURE
+        | ClimateEntityFeature.FAN_MODE
+        | ClimateEntityFeature.TURN_ON
+        | ClimateEntityFeature.TURN_OFF
+    )
+
+    def __init__(
+        self,
+        coordinator: ActronAirSystemCoordinator,
+        name: str,
+    ) -> None:
+        """Initialize an Actron Air unit."""
+        super().__init__(coordinator, name)
+        serial_number = coordinator.serial_number
+        self._attr_unique_id = serial_number
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, serial_number)},
+            name=self._status.ac_system.system_name,
+            manufacturer="Actron Air",
+            model_id=self._status.ac_system.master_wc_model,
+            sw_version=self._status.ac_system.master_wc_firmware_version,
+            serial_number=serial_number,
+        )
+
+    @property
+    def min_temp(self) -> float:
+        """Return the minimum temperature that can be set."""
+        return self._status.min_temp
+
+    @property
+    def max_temp(self) -> float:
+        """Return the maximum temperature that can be set."""
+        return self._status.max_temp
+
+    @property
+    def _status(self) -> ActronAirNeoStatus:
+        """Get the current status from the coordinator."""
+        return self.coordinator.data
+
+    @property
+    def hvac_mode(self) -> HVACMode | None:
+        """Return the current HVAC mode."""
+        if not self._status.user_aircon_settings.is_on:
+            return HVACMode.OFF
+
+        mode = self._status.user_aircon_settings.mode
+        return HVAC_MODE_MAPPING_ACTRONAIR_TO_HA.get(mode)
+
+    @property
+    def fan_mode(self) -> str | None:
+        """Return the current fan mode."""
+        fan_mode = self._status.user_aircon_settings.fan_mode
+        return FAN_MODE_MAPPING_ACTRONAIR_TO_HA.get(fan_mode)
+
+    @property
+    def current_humidity(self) -> float:
+        """Return the current humidity."""
+        return self._status.master_info.live_humidity_pc
+
+    @property
+    def current_temperature(self) -> float:
+        """Return the current temperature."""
+        return self._status.master_info.live_temp_c
+
+    @property
+    def target_temperature(self) -> float:
+        """Return the target temperature."""
+        return self._status.user_aircon_settings.temperature_setpoint_cool_c
+
+    async def async_set_fan_mode(self, fan_mode: str) -> None:
+        """Set a new fan mode."""
+        api_fan_mode = FAN_MODE_MAPPING_HA_TO_ACTRONAIR.get(fan_mode.lower())
+        await self._status.user_aircon_settings.set_fan_mode(api_fan_mode)
+
+    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
+        """Set the HVAC mode."""
+        ac_mode = HVAC_MODE_MAPPING_HA_TO_ACTRONAIR.get(hvac_mode)
+        await self._status.ac_system.set_system_mode(ac_mode)
+
+    async def async_set_temperature(self, **kwargs: Any) -> None:
+        """Set the temperature."""
+        temp = kwargs.get(ATTR_TEMPERATURE)
+        await self._status.user_aircon_settings.set_temperature(temperature=temp)
+
+
+class ActronZoneClimate(BaseClimateEntity):
+    """Representation of a zone within the Actron Air system."""
+
+    _attr_supported_features = (
+        ClimateEntityFeature.TARGET_TEMPERATURE
+        | ClimateEntityFeature.TURN_ON
+        | ClimateEntityFeature.TURN_OFF
+    )
+
+    def __init__(
+        self,
+        coordinator: ActronAirSystemCoordinator,
+        zone: ActronAirNeoZone,
+    ) -> None:
+        """Initialize an Actron Air unit."""
+        super().__init__(coordinator, zone.title)
+        serial_number = coordinator.serial_number
+        self._zone_id: int = zone.zone_id
+        self._attr_unique_id: str = f"{serial_number}_zone_{zone.zone_id}"
+        self._attr_device_info: DeviceInfo = DeviceInfo(
+            identifiers={(DOMAIN, self._attr_unique_id)},
+            name=zone.title,
+            manufacturer="Actron Air",
+            model="Zone",
+            suggested_area=zone.title,
+            via_device=(DOMAIN, serial_number),
+        )
+
+    @property
+    def min_temp(self) -> float:
+        """Return the minimum temperature that can be set."""
+        return self._zone.min_temp
+
+    @property
+    def max_temp(self) -> float:
+        """Return the maximum temperature that can be set."""
+        return self._zone.max_temp
+
+    @property
+    def _zone(self) -> ActronAirNeoZone:
+        """Get the current zone data from the coordinator."""
+        status = self.coordinator.data
+        return status.zones[self._zone_id]
+
+    @property
+    def hvac_mode(self) -> HVACMode | None:
+        """Return the current HVAC mode."""
+        if self._zone.is_active:
+            mode = self._zone.hvac_mode
+            return HVAC_MODE_MAPPING_ACTRONAIR_TO_HA.get(mode)
+        return HVACMode.OFF
+
+    @property
+    def current_humidity(self) -> float | None:
+        """Return the current humidity."""
+        return self._zone.humidity
+
+    @property
+    def current_temperature(self) -> float | None:
+        """Return the current temperature."""
+        return self._zone.live_temp_c
+
+    @property
+    def target_temperature(self) -> float | None:
+        """Return the target temperature."""
+        return self._zone.temperature_setpoint_cool_c
+
+    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
+        """Set the HVAC mode."""
+        is_enabled = hvac_mode != HVACMode.OFF
+        await self._zone.enable(is_enabled)
+
+    async def async_set_temperature(self, **kwargs: Any) -> None:
+        """Set the temperature."""
+        await self._zone.set_temperature(temperature=kwargs["temperature"])

homeassistant/components/actron_air/config_flow.py

@@ -0,0 +1,132 @@
+"""Setup config flow for Actron Air integration."""
+
+import asyncio
+from typing import Any
+
+from actron_neo_api import ActronNeoAPI, ActronNeoAuthError
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_API_TOKEN
+from homeassistant.exceptions import HomeAssistantError
+
+from .const import _LOGGER, DOMAIN
+
+
+class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Actron Air."""
+
+    def __init__(self) -> None:
+        """Initialize the config flow."""
+        self._api: ActronNeoAPI | None = None
+        self._device_code: str | None = None
+        self._user_code: str = ""
+        self._verification_uri: str = ""
+        self._expires_minutes: str = "30"
+        self.login_task: asyncio.Task | None = None
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        if self._api is None:
+            _LOGGER.debug("Initiating device authorization")
+            self._api = ActronNeoAPI()
+            try:
+                device_code_response = await self._api.request_device_code()
+            except ActronNeoAuthError as err:
+                _LOGGER.error("OAuth2 flow failed: %s", err)
+                return self.async_abort(reason="oauth2_error")
+
+            self._device_code = device_code_response["device_code"]
+            self._user_code = device_code_response["user_code"]
+            self._verification_uri = device_code_response["verification_uri_complete"]
+            self._expires_minutes = str(device_code_response["expires_in"] // 60)
+
+        async def _wait_for_authorization() -> None:
+            """Wait for the user to authorize the device."""
+            assert self._api is not None
+            assert self._device_code is not None
+            _LOGGER.debug("Waiting for device authorization")
+            try:
+                await self._api.poll_for_token(self._device_code)
+                _LOGGER.debug("Authorization successful")
+            except ActronNeoAuthError as ex:
+                _LOGGER.exception("Error while waiting for device authorization")
+                raise CannotConnect from ex
+
+        _LOGGER.debug("Checking login task")
+        if self.login_task is None:
+            _LOGGER.debug("Creating task for device authorization")
+            self.login_task = self.hass.async_create_task(_wait_for_authorization())
+
+        if self.login_task.done():
+            _LOGGER.debug("Login task is done, checking results")
+            if exception := self.login_task.exception():
+                if isinstance(exception, CannotConnect):
+                    return self.async_show_progress_done(
+                        next_step_id="connection_error"
+                    )
+                return self.async_show_progress_done(next_step_id="timeout")
+            return self.async_show_progress_done(next_step_id="finish_login")
+
+        return self.async_show_progress(
+            step_id="user",
+            progress_action="wait_for_authorization",
+            description_placeholders={
+                "user_code": self._user_code,
+                "verification_uri": self._verification_uri,
+                "expires_minutes": self._expires_minutes,
+            },
+            progress_task=self.login_task,
+        )
+
+    async def async_step_finish_login(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the finalization of login."""
+        _LOGGER.debug("Finalizing authorization")
+        assert self._api is not None
+
+        try:
+            user_data = await self._api.get_user_info()
+        except ActronNeoAuthError as err:
+            _LOGGER.error("Error getting user info: %s", err)
+            return self.async_abort(reason="oauth2_error")
+
+        unique_id = str(user_data["id"])
+        await self.async_set_unique_id(unique_id)
+        self._abort_if_unique_id_configured()
+
+        return self.async_create_entry(
+            title=user_data["email"],
+            data={CONF_API_TOKEN: self._api.refresh_token_value},
+        )
+
+    async def async_step_timeout(
+        self,
+        user_input: dict[str, Any] | None = None,
+    ) -> ConfigFlowResult:
+        """Handle issues that need transition await from progress step."""
+        if user_input is None:
+            return self.async_show_form(
+                step_id="timeout",
+            )
+        del self.login_task
+        return await self.async_step_user()
+
+    async def async_step_connection_error(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle connection error from progress step."""
+        if user_input is None:
+            return self.async_show_form(step_id="connection_error")
+
+        # Reset state and try again
+        self._api = None
+        self._device_code = None
+        self.login_task = None
+        return await self.async_step_user()
+
+
+class CannotConnect(HomeAssistantError):
+    """Error to indicate we cannot connect."""

homeassistant/components/actron_air/const.py

@@ -0,0 +1,6 @@
+"""Constants used by Actron Air integration."""
+
+import logging
+
+_LOGGER = logging.getLogger(__package__)
+DOMAIN = "actron_air"

homeassistant/components/actron_air/coordinator.py

@@ -0,0 +1,69 @@
+"""Coordinator for Actron Air integration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import timedelta
+
+from actron_neo_api import ActronAirNeoACSystem, ActronAirNeoStatus, ActronNeoAPI
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+from homeassistant.util import dt as dt_util
+
+from .const import _LOGGER
+
+STALE_DEVICE_TIMEOUT = timedelta(hours=24)
+ERROR_NO_SYSTEMS_FOUND = "no_systems_found"
+ERROR_UNKNOWN = "unknown_error"
+
+
+@dataclass
+class ActronAirRuntimeData:
+    """Runtime data for the Actron Air integration."""
+
+    api: ActronNeoAPI
+    system_coordinators: dict[str, ActronAirSystemCoordinator]
+
+
+type ActronAirConfigEntry = ConfigEntry[ActronAirRuntimeData]
+
+AUTH_ERROR_THRESHOLD = 3
+SCAN_INTERVAL = timedelta(seconds=30)
+
+
+class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirNeoACSystem]):
+    """System coordinator for Actron Air integration."""
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        entry: ActronAirConfigEntry,
+        api: ActronNeoAPI,
+        system: ActronAirNeoACSystem,
+    ) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            name="Actron Air Status",
+            update_interval=SCAN_INTERVAL,
+            config_entry=entry,
+        )
+        self.system = system
+        self.serial_number = system["serial"]
+        self.api = api
+        self.status = self.api.state_manager.get_status(self.serial_number)
+        self.last_seen = dt_util.utcnow()
+
+    async def _async_update_data(self) -> ActronAirNeoStatus:
+        """Fetch updates and merge incremental changes into the full state."""
+        await self.api.update_status()
+        self.status = self.api.state_manager.get_status(self.serial_number)
+        self.last_seen = dt_util.utcnow()
+        return self.status
+
+    def is_device_stale(self) -> bool:
+        """Check if a device is stale (not seen for a while)."""
+        return (dt_util.utcnow() - self.last_seen) > STALE_DEVICE_TIMEOUT

homeassistant/components/actron_air/manifest.json

@@ -0,0 +1,16 @@
+{
+  "domain": "actron_air",
+  "name": "Actron Air",
+  "codeowners": ["@kclif9", "@JagadishDhanamjayam"],
+  "config_flow": true,
+  "dhcp": [
+    {
+      "hostname": "neo-*",
+      "macaddress": "FC0FE7*"
+    }
+  ],
+  "documentation": "https://www.home-assistant.io/integrations/actron_air",
+  "iot_class": "cloud_polling",
+  "quality_scale": "bronze",
+  "requirements": ["actron-neo-api==0.1.84"]
+}

homeassistant/components/actron_air/quality_scale.yaml

@@ -0,0 +1,78 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: This integration does not have custom service actions.
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: This integration does not have custom service actions.
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: This integration does not subscribe to external events.
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions: todo
+  config-entry-unloading: done
+  docs-configuration-parameters:
+    status: exempt
+    comment: No options flow
+  docs-installation-parameters: done
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: done
+  reauthentication-flow: todo
+  test-coverage: todo
+
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info:
+    status: exempt
+    comment: This integration uses DHCP discovery, however is cloud polling. Therefore there is no information to update.
+  discovery: done
+  docs-data-update: done
+  docs-examples: done
+  docs-known-limitations: done
+  docs-supported-devices: done
+  docs-supported-functions: done
+  docs-troubleshooting: done
+  docs-use-cases: done
+  dynamic-devices: todo
+  entity-category:
+    status: exempt
+    comment: This integration does not use entity categories.
+  entity-device-class:
+    status: exempt
+    comment: This integration does not use entity device classes.
+  entity-disabled-by-default:
+    status: exempt
+    comment: Not required for this integration at this stage.
+  entity-translations: todo
+  exception-translations: todo
+  icon-translations: todo
+  reconfiguration-flow: todo
+  repair-issues:
+    status: exempt
+    comment: This integration does not have any known issues that require repair.
+  stale-devices: todo
+
+  # Platinum
+  async-dependency: done
+  inject-websession: todo
+  strict-typing: todo

homeassistant/components/actron_air/strings.json

@@ -0,0 +1,29 @@
+{
+  "config": {
+    "step": {
+      "user": {
+        "title": "Actron Air OAuth2 Authorization"
+      },
+      "timeout": {
+        "title": "Authorization timeout",
+        "description": "The authorization process timed out. Please try again.",
+        "data": {}
+      },
+      "connection_error": {
+        "title": "Connection error",
+        "description": "Failed to connect to Actron Air. Please check your internet connection and try again.",
+        "data": {}
+      }
+    },
+    "progress": {
+      "wait_for_authorization": "To authenticate, open the following URL and login at Actron Air:\n{verification_uri}\nIf the code is not automatically copied, paste the following code to authorize the integration:\n\n```{user_code}```\n\n\nThe login attempt will time out after {expires_minutes} minutes."
+    },
+    "error": {
+      "oauth2_error": "Failed to start OAuth2 flow. Please try again later."
+    },
+    "abort": {
+      "oauth2_error": "Failed to start OAuth2 flow",
+      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]"
+    }
+  }
+}

homeassistant/components/aemet/config_flow.py

@@ -71,7 +71,14 @@ class AemetConfigFlow(ConfigFlow, domain=DOMAIN):
             }
         )
 
-        return self.async_show_form(step_id="user", data_schema=schema, errors=errors)
+        return self.async_show_form(
+            step_id="user",
+            data_schema=schema,
+            errors=errors,
+            description_placeholders={
+                "api_key_url": "https://opendata.aemet.es/centrodedescargas/altaUsuario"
+            },
+        )
 
     @staticmethod
     @callback

homeassistant/components/aemet/strings.json

@@ -14,7 +14,7 @@
           "longitude": "[%key:common::config_flow::data::longitude%]",
           "name": "Name of the integration"
         },
-        "description": "To generate API key go to https://opendata.aemet.es/centrodedescargas/altaUsuario"
+        "description": "To generate API key go to {api_key_url}"
       }
     }
   },

homeassistant/components/ai_task/__init__.py

@@ -53,9 +53,6 @@ __all__ = [
     "GenImageTaskResult",
     "async_generate_data",
     "async_generate_image",
-    "async_setup",
-    "async_setup_entry",
-    "async_unload_entry",
 ]
 
 _LOGGER = logging.getLogger(__name__)

homeassistant/components/airly/config_flow.py

@@ -18,6 +18,10 @@ from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
 from .const import CONF_USE_NEAREST, DOMAIN, NO_AIRLY_SENSORS
 
+DESCRIPTION_PLACEHOLDERS = {
+    "developer_registration_url": "https://developer.airly.eu/register",
+}
+
 
 class AirlyFlowHandler(ConfigFlow, domain=DOMAIN):
     """Config flow for Airly."""
@@ -85,6 +89,7 @@ class AirlyFlowHandler(ConfigFlow, domain=DOMAIN):
                 }
             ),
             errors=errors,
+            description_placeholders=DESCRIPTION_PLACEHOLDERS,
         )
 
 

homeassistant/components/airly/strings.json

@@ -2,7 +2,7 @@
   "config": {
     "step": {
       "user": {
-        "description": "To generate API key go to https://developer.airly.eu/register",
+        "description": "To generate API key go to {developer_registration_url}",
         "data": {
           "name": "[%key:common::config_flow::data::name%]",
           "api_key": "[%key:common::config_flow::data::api_key%]",

homeassistant/components/airos/__init__.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import logging
+
 from airos.airos8 import AirOS8
 
 from homeassistant.const import (
@@ -12,10 +14,11 @@ from homeassistant.const import (
     CONF_VERIFY_SSL,
     Platform,
 )
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
-from .const import DEFAULT_SSL, DEFAULT_VERIFY_SSL, SECTION_ADVANCED_SETTINGS
+from .const import DEFAULT_SSL, DEFAULT_VERIFY_SSL, DOMAIN, SECTION_ADVANCED_SETTINGS
 from .coordinator import AirOSConfigEntry, AirOSDataUpdateCoordinator
 
 _PLATFORMS: list[Platform] = [
@@ -23,6 +26,8 @@ _PLATFORMS: list[Platform] = [
     Platform.SENSOR,
 ]
 
+_LOGGER = logging.getLogger(__name__)
+
 
 async def async_setup_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> bool:
     """Set up Ubiquiti airOS from a config entry."""
@@ -54,11 +59,13 @@ async def async_setup_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> boo
 async def async_migrate_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> bool:
     """Migrate old config entry."""
 
-    if entry.version > 1:
-        # This means the user has downgraded from a future version
+    # This means the user has downgraded from a future version
+    if entry.version > 2:
         return False
 
+    # 1.1 Migrate config_entry to add advanced ssl settings
     if entry.version == 1 and entry.minor_version == 1:
+        new_minor_version = 2
         new_data = {**entry.data}
         advanced_data = {
             CONF_SSL: DEFAULT_SSL,
@@ -69,7 +76,52 @@ async def async_migrate_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> b
         hass.config_entries.async_update_entry(
             entry,
             data=new_data,
-            minor_version=2,
+            minor_version=new_minor_version,
+        )
+
+    # 2.1 Migrate binary_sensor entity unique_id from device_id to mac_address
+    #     Step 1 - migrate binary_sensor entity unique_id
+    #     Step 2 - migrate device entity identifier
+    if entry.version == 1:
+        new_version = 2
+        new_minor_version = 1
+
+        mac_adress = dr.format_mac(entry.unique_id)
+
+        device_registry = dr.async_get(hass)
+        if device_entry := device_registry.async_get_device(
+            connections={(dr.CONNECTION_NETWORK_MAC, mac_adress)}
+        ):
+            old_device_id = next(
+                (
+                    device_id
+                    for domain, device_id in device_entry.identifiers
+                    if domain == DOMAIN
+                ),
+            )
+
+            @callback
+            def update_unique_id(
+                entity_entry: er.RegistryEntry,
+            ) -> dict[str, str] | None:
+                """Update unique id from device_id to mac address."""
+                if old_device_id and entity_entry.unique_id.startswith(old_device_id):
+                    suffix = entity_entry.unique_id.removeprefix(old_device_id)
+                    new_unique_id = f"{mac_adress}{suffix}"
+                    return {"new_unique_id": new_unique_id}
+                return None
+
+            await er.async_migrate_entries(hass, entry.entry_id, update_unique_id)
+
+            new_identifiers = device_entry.identifiers.copy()
+            new_identifiers.discard((DOMAIN, old_device_id))
+            new_identifiers.add((DOMAIN, mac_adress))
+            device_registry.async_update_device(
+                device_entry.id, new_identifiers=new_identifiers
+            )
+
+        hass.config_entries.async_update_entry(
+            entry, version=new_version, minor_version=new_minor_version
         )
 
     return True

homeassistant/components/airos/binary_sensor.py

@@ -98,7 +98,7 @@ class AirOSBinarySensor(AirOSEntity, BinarySensorEntity):
         super().__init__(coordinator)
 
         self.entity_description = description
-        self._attr_unique_id = f"{coordinator.data.host.device_id}_{description.key}"
+        self._attr_unique_id = f"{coordinator.data.derived.mac}_{description.key}"
 
     @property
     def is_on(self) -> bool:

homeassistant/components/airos/config_flow.py

@@ -15,7 +15,12 @@ from airos.exceptions import (
 )
 import voluptuous as vol
 
-from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlow, ConfigFlowResult
+from homeassistant.config_entries import (
+    SOURCE_REAUTH,
+    SOURCE_RECONFIGURE,
+    ConfigFlow,
+    ConfigFlowResult,
+)
 from homeassistant.const import (
     CONF_HOST,
     CONF_PASSWORD,
@@ -57,8 +62,8 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
 class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Ubiquiti airOS."""
 
-    VERSION = 1
-    MINOR_VERSION = 2
+    VERSION = 2
+    MINOR_VERSION = 1
 
     def __init__(self) -> None:
         """Initialize the config flow."""
@@ -119,7 +124,7 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
         else:
             await self.async_set_unique_id(airos_data.derived.mac)
 
-            if self.source == SOURCE_REAUTH:
+            if self.source in [SOURCE_REAUTH, SOURCE_RECONFIGURE]:
                 self._abort_if_unique_id_mismatch()
             else:
                 self._abort_if_unique_id_configured()
@@ -164,3 +169,54 @@ class AirOSConfigFlow(ConfigFlow, domain=DOMAIN):
             ),
             errors=self.errors,
         )
+
+    async def async_step_reconfigure(
+        self,
+        user_input: Mapping[str, Any] | None = None,
+    ) -> ConfigFlowResult:
+        """Handle reconfiguration of airOS."""
+        self.errors = {}
+        entry = self._get_reconfigure_entry()
+        current_data = entry.data
+
+        if user_input is not None:
+            validate_data = {**current_data, **user_input}
+            if await self._validate_and_get_device_info(config_data=validate_data):
+                return self.async_update_reload_and_abort(
+                    entry,
+                    data_updates=validate_data,
+                )
+
+        return self.async_show_form(
+            step_id="reconfigure",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_PASSWORD): TextSelector(
+                        TextSelectorConfig(
+                            type=TextSelectorType.PASSWORD,
+                            autocomplete="current-password",
+                        )
+                    ),
+                    vol.Required(SECTION_ADVANCED_SETTINGS): section(
+                        vol.Schema(
+                            {
+                                vol.Required(
+                                    CONF_SSL,
+                                    default=current_data[SECTION_ADVANCED_SETTINGS][
+                                        CONF_SSL
+                                    ],
+                                ): bool,
+                                vol.Required(
+                                    CONF_VERIFY_SSL,
+                                    default=current_data[SECTION_ADVANCED_SETTINGS][
+                                        CONF_VERIFY_SSL
+                                    ],
+                                ): bool,
+                            }
+                        ),
+                        {"collapsed": True},
+                    ),
+                }
+            ),
+            errors=self.errors,
+        )

homeassistant/components/airos/entity.py

@@ -33,9 +33,14 @@ class AirOSEntity(CoordinatorEntity[AirOSDataUpdateCoordinator]):
         self._attr_device_info = DeviceInfo(
             connections={(CONNECTION_NETWORK_MAC, airos_data.derived.mac)},
             configuration_url=configuration_url,
-            identifiers={(DOMAIN, str(airos_data.host.device_id))},
+            identifiers={(DOMAIN, airos_data.derived.mac)},
             manufacturer=MANUFACTURER,
             model=airos_data.host.devmodel,
+            model_id=(
+                sku
+                if (sku := airos_data.derived.sku) not in ["UNKNOWN", "AMBIGUOUS"]
+                else None
+            ),
             name=airos_data.host.hostname,
             sw_version=airos_data.host.fwversion,
         )

homeassistant/components/airos/manifest.json

@@ -4,7 +4,8 @@
   "codeowners": ["@CoMPaTech"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/airos",
+  "integration_type": "device",
   "iot_class": "local_polling",
-  "quality_scale": "bronze",
-  "requirements": ["airos==0.5.5"]
+  "quality_scale": "silver",
+  "requirements": ["airos==0.5.6"]
 }

homeassistant/components/airos/quality_scale.yaml

@@ -32,11 +32,11 @@ rules:
   config-entry-unloading: done
   docs-configuration-parameters: done
   docs-installation-parameters: done
-  entity-unavailable: todo
+  entity-unavailable: done
   integration-owner: done
-  log-when-unavailable: todo
-  parallel-updates: todo
-  reauthentication-flow: todo
+  log-when-unavailable: done
+  parallel-updates: done
+  reauthentication-flow: done
   test-coverage: done
 
   # Gold
@@ -48,9 +48,9 @@ rules:
   docs-examples: todo
   docs-known-limitations: done
   docs-supported-devices: done
-  docs-supported-functions: todo
+  docs-supported-functions: done
   docs-troubleshooting: done
-  docs-use-cases: todo
+  docs-use-cases: done
   dynamic-devices: todo
   entity-category: done
   entity-device-class: done
@@ -60,7 +60,7 @@ rules:
   icon-translations:
     status: exempt
     comment: no (custom) icons used or envisioned
-  reconfiguration-flow: todo
+  reconfiguration-flow: done
   repair-issues: todo
   stale-devices: todo
 

homeassistant/components/airos/strings.json

@@ -10,6 +10,27 @@
           "password": "[%key:component::airos::config::step::user::data_description::password%]"
         }
       },
+      "reconfigure": {
+        "data": {
+          "password": "[%key:common::config_flow::data::password%]"
+        },
+        "data_description": {
+          "password": "[%key:component::airos::config::step::user::data_description::password%]"
+        },
+        "sections": {
+          "advanced_settings": {
+            "name": "[%key:component::airos::config::step::user::sections::advanced_settings::name%]",
+            "data": {
+              "ssl": "[%key:component::airos::config::step::user::sections::advanced_settings::data::ssl%]",
+              "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
+            },
+            "data_description": {
+              "ssl": "[%key:component::airos::config::step::user::sections::advanced_settings::data_description::ssl%]",
+              "verify_ssl": "[%key:component::airos::config::step::user::sections::advanced_settings::data_description::verify_ssl%]"
+            }
+          }
+        }
+      },
       "user": {
         "data": {
           "host": "[%key:common::config_flow::data::host%]",
@@ -23,6 +44,7 @@
         },
         "sections": {
           "advanced_settings": {
+            "name": "Advanced settings",
             "data": {
               "ssl": "Use HTTPS",
               "verify_ssl": "[%key:common::config_flow::data::verify_ssl%]"
@@ -44,6 +66,7 @@
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
       "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]",
       "unique_id_mismatch": "Re-authentication should be used for the same device not a new one"
     }
   },

homeassistant/components/airq/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["aioairq"],
-  "requirements": ["aioairq==0.4.6"]
+  "requirements": ["aioairq==0.4.7"]
 }

homeassistant/components/airq/strings.json

@@ -29,7 +29,7 @@
         },
         "data_description": {
           "return_average": "air-Q allows to poll both the noisy sensor readings as well as the values averaged on the device (default)",
-          "clip_negatives": "For baseline calibration purposes, certain sensor values may briefly become negative. The default behaviour is to clip such values to 0"
+          "clip_negatives": "For baseline calibration purposes, certain sensor values may briefly become negative. The default behavior is to clip such values to 0"
         }
       }
     }

homeassistant/components/alexa_devices/manifest.json

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

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,9 +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"
 
 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,6 +64,13 @@ 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,
@@ -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,8 +575,8 @@ 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 (
             not model.startswith(tuple(NON_THINKING_MODELS))
             and thinking_budget >= MIN_THINKING_BUDGET
@@ -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/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/apple_tv/__init__.py

@@ -5,14 +5,9 @@ from __future__ import annotations
 import asyncio
 import logging
 from random import randrange
+import sys
 from typing import Any, cast
 
-from pyatv import connect, exceptions, scan
-from pyatv.conf import AppleTV
-from pyatv.const import DeviceModel, Protocol
-from pyatv.convert import model_str
-from pyatv.interface import AppleTV as AppleTVInterface, DeviceListener
-
 from homeassistant.components import zeroconf
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
@@ -29,7 +24,11 @@ from homeassistant.const import (
     Platform,
 )
 from homeassistant.core import Event, HomeAssistant, callback
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
+from homeassistant.exceptions import (
+    ConfigEntryAuthFailed,
+    ConfigEntryNotReady,
+    HomeAssistantError,
+)
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.dispatcher import async_dispatcher_send
@@ -43,6 +42,18 @@ from .const import (
     SIGNAL_DISCONNECTED,
 )
 
+if sys.version_info < (3, 14):
+    from pyatv import connect, exceptions, scan
+    from pyatv.conf import AppleTV
+    from pyatv.const import DeviceModel, Protocol
+    from pyatv.convert import model_str
+    from pyatv.interface import AppleTV as AppleTVInterface, DeviceListener
+else:
+
+    class DeviceListener:
+        """Dummy class."""
+
+
 _LOGGER = logging.getLogger(__name__)
 
 DEFAULT_NAME_TV = "Apple TV"
@@ -53,31 +64,41 @@ BACKOFF_TIME_UPPER_LIMIT = 300  # Five minutes
 
 PLATFORMS = [Platform.MEDIA_PLAYER, Platform.REMOTE]
 
-AUTH_EXCEPTIONS = (
-    exceptions.AuthenticationError,
-    exceptions.InvalidCredentialsError,
-    exceptions.NoCredentialsError,
-)
-CONNECTION_TIMEOUT_EXCEPTIONS = (
-    OSError,
-    asyncio.CancelledError,
-    TimeoutError,
-    exceptions.ConnectionLostError,
-    exceptions.ConnectionFailedError,
-)
-DEVICE_EXCEPTIONS = (
-    exceptions.ProtocolError,
-    exceptions.NoServiceError,
-    exceptions.PairingError,
-    exceptions.BackOffError,
-    exceptions.DeviceIdMissingError,
-)
+if sys.version_info < (3, 14):
+    AUTH_EXCEPTIONS = (
+        exceptions.AuthenticationError,
+        exceptions.InvalidCredentialsError,
+        exceptions.NoCredentialsError,
+    )
+    CONNECTION_TIMEOUT_EXCEPTIONS = (
+        OSError,
+        asyncio.CancelledError,
+        TimeoutError,
+        exceptions.ConnectionLostError,
+        exceptions.ConnectionFailedError,
+    )
+    DEVICE_EXCEPTIONS = (
+        exceptions.ProtocolError,
+        exceptions.NoServiceError,
+        exceptions.PairingError,
+        exceptions.BackOffError,
+        exceptions.DeviceIdMissingError,
+    )
+else:
+    AUTH_EXCEPTIONS = ()
+    CONNECTION_TIMEOUT_EXCEPTIONS = ()
+    DEVICE_EXCEPTIONS = ()
+
 
 type AppleTvConfigEntry = ConfigEntry[AppleTVManager]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: AppleTvConfigEntry) -> bool:
     """Set up a config entry for Apple TV."""
+    if sys.version_info >= (3, 14):
+        raise HomeAssistantError(
+            "Apple TV is not supported on Python 3.14. Please use Python 3.13."
+        )
     manager = AppleTVManager(hass, entry)
 
     if manager.is_on:

homeassistant/components/apple_tv/manifest.json

@@ -7,7 +7,7 @@
   "documentation": "https://www.home-assistant.io/integrations/apple_tv",
   "iot_class": "local_push",
   "loggers": ["pyatv", "srptools"],
-  "requirements": ["pyatv==0.16.1"],
+  "requirements": ["pyatv==0.16.1;python_version<'3.14'"],
   "zeroconf": [
     "_mediaremotetv._tcp.local.",
     "_companion-link._tcp.local.",

homeassistant/components/assist_pipeline/__init__.py

@@ -41,6 +41,8 @@ from .pipeline import (
     async_setup_pipeline_store,
     async_update_pipeline,
 )
+from .select import AssistPipelineSelect, VadSensitivitySelect
+from .vad import VadSensitivity
 from .websocket_api import async_register_websocket_api
 
 __all__ = (
@@ -51,16 +53,18 @@ __all__ = (
     "SAMPLE_CHANNELS",
     "SAMPLE_RATE",
     "SAMPLE_WIDTH",
+    "AssistPipelineSelect",
     "AudioSettings",
     "Pipeline",
     "PipelineEvent",
     "PipelineEventType",
     "PipelineNotFound",
+    "VadSensitivity",
+    "VadSensitivitySelect",
     "WakeWordSettings",
     "async_create_default_pipeline",
     "async_get_pipelines",
     "async_pipeline_from_audio_stream",
-    "async_setup",
     "async_update_pipeline",
 )
 

homeassistant/components/assist_pipeline/pipeline.py

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

homeassistant/components/asuswrt/bridge.py

@@ -3,17 +3,17 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from collections import namedtuple
 from collections.abc import Awaitable, Callable, Coroutine
 import functools
 import logging
-from typing import Any, cast
+from typing import Any, NamedTuple
 
 from aioasuswrt.asuswrt import AsusWrt as AsusWrtLegacy
 from aiohttp import ClientSession
 from asusrouter import AsusRouter, AsusRouterError
 from asusrouter.config import ARConfigKey
 from asusrouter.modules.client import AsusClient
+from asusrouter.modules.connection import ConnectionState
 from asusrouter.modules.data import AsusData
 from asusrouter.modules.homeassistant import convert_to_ha_data, convert_to_ha_sensors
 from asusrouter.tools.connection import get_cookie_jar
@@ -61,11 +61,27 @@ SENSORS_TYPE_RATES = "sensors_rates"
 SENSORS_TYPE_TEMPERATURES = "sensors_temperatures"
 SENSORS_TYPE_UPTIME = "sensors_uptime"
 
-WrtDevice = namedtuple("WrtDevice", ["ip", "name", "connected_to"])  # noqa: PYI024
+
+class WrtDevice(NamedTuple):
+    """WrtDevice structure."""
+
+    ip: str | None
+    name: str | None
+    conneted_to: str | None
+
 
 _LOGGER = logging.getLogger(__name__)
 
-type _FuncType[_T] = Callable[[_T], Awaitable[list[Any] | tuple[Any] | dict[str, Any]]]
+type _FuncType[_T] = Callable[
+    [_T],
+    Awaitable[
+        list[str]
+        | tuple[float | None, float | None]
+        | list[float]
+        | dict[str, float | str | None]
+        | dict[str, float]
+    ],
+]
 type _ReturnFuncType[_T] = Callable[[_T], Coroutine[Any, Any, dict[str, Any]]]
 
 
@@ -80,7 +96,9 @@ def handle_errors_and_zip[_AsusWrtBridgeT: AsusWrtBridge](
         """Run library methods and zip results or manage exceptions."""
 
         @functools.wraps(func)
-        async def _wrapper(self: _AsusWrtBridgeT) -> dict[str, Any]:
+        async def _wrapper(
+            self: _AsusWrtBridgeT,
+        ) -> dict[str, float | str | None] | dict[str, float]:
             try:
                 data = await func(self)
             except exceptions as exc:
@@ -107,7 +125,9 @@ class AsusWrtBridge(ABC):
 
     @staticmethod
     def get_bridge(
-        hass: HomeAssistant, conf: dict[str, Any], options: dict[str, Any] | None = None
+        hass: HomeAssistant,
+        conf: dict[str, str | int],
+        options: dict[str, str | bool | int] | None = None,
     ) -> AsusWrtBridge:
         """Get Bridge instance."""
         if conf[CONF_PROTOCOL] in (PROTOCOL_HTTPS, PROTOCOL_HTTP):
@@ -219,7 +239,7 @@ class AsusWrtLegacyBridge(AsusWrtBridge):
     @property
     def is_connected(self) -> bool:
         """Get connected status."""
-        return cast(bool, self._api.is_connected)
+        return self._api.is_connected
 
     async def async_connect(self) -> None:
         """Connect to the device."""
@@ -235,8 +255,7 @@ class AsusWrtLegacyBridge(AsusWrtBridge):
 
     async def async_disconnect(self) -> None:
         """Disconnect to the device."""
-        if self._api is not None and self._protocol == PROTOCOL_TELNET:
-            self._api.connection.disconnect()
+        await self._api.async_disconnect()
 
     async def async_get_connected_devices(self) -> dict[str, WrtDevice]:
         """Get list of connected devices."""
@@ -307,22 +326,22 @@ class AsusWrtLegacyBridge(AsusWrtBridge):
         return [SENSORS_TEMPERATURES_LEGACY[i] for i in range(3) if availability[i]]
 
     @handle_errors_and_zip((IndexError, OSError, ValueError), SENSORS_BYTES)
-    async def _get_bytes(self) -> Any:
+    async def _get_bytes(self) -> tuple[float | None, float | None]:
         """Fetch byte information from the router."""
         return await self._api.async_get_bytes_total()
 
     @handle_errors_and_zip((IndexError, OSError, ValueError), SENSORS_RATES)
-    async def _get_rates(self) -> Any:
+    async def _get_rates(self) -> tuple[float, float]:
         """Fetch rates information from the router."""
         return await self._api.async_get_current_transfer_rates()
 
     @handle_errors_and_zip((IndexError, OSError, ValueError), SENSORS_LOAD_AVG)
-    async def _get_load_avg(self) -> Any:
+    async def _get_load_avg(self) -> list[float]:
         """Fetch load average information from the router."""
         return await self._api.async_get_loadavg()
 
     @handle_errors_and_zip((OSError, ValueError), None)
-    async def _get_temperatures(self) -> Any:
+    async def _get_temperatures(self) -> dict[str, float]:
         """Fetch temperatures information from the router."""
         return await self._api.async_get_temperature()
 
@@ -437,6 +456,7 @@ class AsusWrtHttpBridge(AsusWrtBridge):
             if dev.connection is not None
             and dev.description is not None
             and dev.connection.ip_address is not None
+            and dev.state is ConnectionState.CONNECTED
         }
 
     async def async_get_available_sensors(self) -> dict[str, dict[str, Any]]:

homeassistant/components/asuswrt/config_flow.py

@@ -175,12 +175,12 @@ class AsusWrtFlowHandler(ConfigFlow, domain=DOMAIN):
         )
 
     async def _async_check_connection(
-        self, user_input: dict[str, Any]
+        self, user_input: dict[str, str | int]
     ) -> tuple[str, str | None]:
         """Attempt to connect the AsusWrt router."""
 
         api: AsusWrtBridge
-        host: str = user_input[CONF_HOST]
+        host = user_input[CONF_HOST]
         protocol = user_input[CONF_PROTOCOL]
         error: str | None = None
 

homeassistant/components/asuswrt/device_tracker.py

@@ -10,8 +10,6 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from . import AsusWrtConfigEntry
 from .router import AsusWrtDevInfo, AsusWrtRouter
 
-ATTR_LAST_TIME_REACHABLE = "last_time_reachable"
-
 DEFAULT_DEVICE_NAME = "Unknown device"
 
 
@@ -58,8 +56,6 @@ def add_entities(
 class AsusWrtDevice(ScannerEntity):
     """Representation of a AsusWrt device."""
 
-    _unrecorded_attributes = frozenset({ATTR_LAST_TIME_REACHABLE})
-
     _attr_should_poll = False
 
     def __init__(self, router: AsusWrtRouter, device: AsusWrtDevInfo) -> None:
@@ -97,11 +93,6 @@ class AsusWrtDevice(ScannerEntity):
     def async_on_demand_update(self) -> None:
         """Update state."""
         self._device = self._router.devices[self._device.mac]
-        self._attr_extra_state_attributes = {}
-        if self._device.last_activity:
-            self._attr_extra_state_attributes[ATTR_LAST_TIME_REACHABLE] = (
-                self._device.last_activity.isoformat(timespec="seconds")
-            )
         self.async_write_ha_state()
 
     async def async_added_to_hass(self) -> None:

homeassistant/components/asuswrt/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["aioasuswrt", "asusrouter", "asyncssh"],
-  "requirements": ["aioasuswrt==1.4.0", "asusrouter==1.21.0"]
+  "requirements": ["aioasuswrt==1.5.1", "asusrouter==1.21.0"]
 }

homeassistant/components/asuswrt/router.py

@@ -176,7 +176,7 @@ class AsusWrtRouter:
 
         self._on_close: list[Callable] = []
 
-        self._options: dict[str, Any] = {
+        self._options: dict[str, str | bool | int] = {
             CONF_DNSMASQ: DEFAULT_DNSMASQ,
             CONF_INTERFACE: DEFAULT_INTERFACE,
             CONF_REQUIRE_IP: True,
@@ -299,12 +299,10 @@ class AsusWrtRouter:
             _LOGGER.warning("Reconnected to ASUS router %s", self.host)
 
         self._connected_devices = len(wrt_devices)
-        consider_home: int = self._options.get(
-            CONF_CONSIDER_HOME, DEFAULT_CONSIDER_HOME.total_seconds()
-        )
-        track_unknown: bool = self._options.get(
-            CONF_TRACK_UNKNOWN, DEFAULT_TRACK_UNKNOWN
+        consider_home = int(
+            self._options.get(CONF_CONSIDER_HOME, DEFAULT_CONSIDER_HOME.total_seconds())
         )
+        track_unknown = self._options.get(CONF_TRACK_UNKNOWN, DEFAULT_TRACK_UNKNOWN)
 
         for device_mac, device in self._devices.items():
             dev_info = wrt_devices.pop(device_mac, None)

homeassistant/components/august/__init__.py

@@ -36,11 +36,14 @@ async def async_setup_entry(hass: HomeAssistant, entry: AugustConfigEntry) -> bo
         raise ConfigEntryAuthFailed("Migration to OAuth required")
 
     session = async_create_august_clientsession(hass)
-    implementation = (
-        await config_entry_oauth2_flow.async_get_config_entry_implementation(
-            hass, entry
+    try:
+        implementation = (
+            await config_entry_oauth2_flow.async_get_config_entry_implementation(
+                hass, entry
+            )
         )
-    )
+    except ValueError as err:
+        raise ConfigEntryNotReady("OAuth implementation not available") from err
     oauth_session = config_entry_oauth2_flow.OAuth2Session(hass, entry, implementation)
     august_gateway = AugustGateway(Path(hass.config.config_dir), session, oauth_session)
     try:

homeassistant/components/auth/login_flow.py

@@ -136,17 +136,22 @@ class WellKnownOAuthInfoView(HomeAssistantView):
             url_prefix = get_url(hass, require_current_request=True)
         except NoURLAvailableError:
             url_prefix = ""
-        return self.json(
-            {
-                "authorization_endpoint": f"{url_prefix}/auth/authorize",
-                "token_endpoint": f"{url_prefix}/auth/token",
-                "revocation_endpoint": f"{url_prefix}/auth/revoke",
-                "response_types_supported": ["code"],
-                "service_documentation": (
-                    "https://developers.home-assistant.io/docs/auth_api"
-                ),
-            }
-        )
+
+        metadata = {
+            "authorization_endpoint": f"{url_prefix}/auth/authorize",
+            "token_endpoint": f"{url_prefix}/auth/token",
+            "revocation_endpoint": f"{url_prefix}/auth/revoke",
+            "response_types_supported": ["code"],
+            "service_documentation": (
+                "https://developers.home-assistant.io/docs/auth_api"
+            ),
+        }
+
+        # Add issuer only when we have a valid base URL (RFC 8414 compliance)
+        if url_prefix:
+            metadata["issuer"] = url_prefix
+
+        return self.json(metadata)
 
 
 class AuthProvidersView(HomeAssistantView):

homeassistant/components/bayesian/strings.json

@@ -146,7 +146,7 @@
         },
         "state": {
           "title": "Add a Bayesian sensor",
-          "description": "Add an observation which evaluates to `True` when the value of the sensor exactly matches *'To state'*. When `False`, it will update the prior with probabilities that are the inverse of those set below. This behaviour can be overridden by adding observations for the same entity's other states.",
+          "description": "Add an observation which evaluates to `True` when the value of the sensor exactly matches *'To state'*. When `False`, it will update the prior with probabilities that are the inverse of those set below. This behavior can be overridden by adding observations for the same entity's other states.",
 
           "data": {
             "name": "[%key:common::config_flow::data::name%]",

homeassistant/components/bluetooth/__init__.py

@@ -57,6 +57,7 @@ from .api import (
     _get_manager,
     async_address_present,
     async_ble_device_from_address,
+    async_clear_address_from_match_history,
     async_current_scanners,
     async_discovered_service_info,
     async_get_advertisement_callback,
@@ -112,9 +113,9 @@ __all__ = [
     "BluetoothServiceInfo",
     "BluetoothServiceInfoBleak",
     "HaBluetoothConnector",
-    "HomeAssistantRemoteScanner",
     "async_address_present",
     "async_ble_device_from_address",
+    "async_clear_address_from_match_history",
     "async_current_scanners",
     "async_discovered_service_info",
     "async_get_advertisement_callback",

homeassistant/components/bluetooth/api.py

@@ -193,6 +193,20 @@ def async_rediscover_address(hass: HomeAssistant, address: str) -> None:
     _get_manager(hass).async_rediscover_address(address)
 
 
+@hass_callback
+def async_clear_address_from_match_history(hass: HomeAssistant, address: str) -> None:
+    """Clear an address from the integration matcher history.
+
+    This allows future advertisements from this address to trigger discovery
+    even if the advertisement content has changed but the service data UUIDs
+    remain the same.
+
+    Unlike async_rediscover_address, this does not immediately re-trigger
+    discovery with the current advertisement in history.
+    """
+    _get_manager(hass).async_clear_address_from_match_history(address)
+
+
 @hass_callback
 def async_register_scanner(
     hass: HomeAssistant,

homeassistant/components/bluetooth/manager.py

@@ -120,6 +120,19 @@ class HomeAssistantBluetoothManager(BluetoothManager):
         if service_info := self._all_history.get(address):
             self._async_trigger_matching_discovery(service_info)
 
+    @hass_callback
+    def async_clear_address_from_match_history(self, address: str) -> None:
+        """Clear an address from the integration matcher history.
+
+        This allows future advertisements from this address to trigger discovery
+        even if the advertisement content has changed but the service data UUIDs
+        remain the same.
+
+        Unlike async_rediscover_address, this does not immediately re-trigger
+        discovery with the current advertisement in history.
+        """
+        self._integration_matcher.async_clear_address(address)
+
     def _discover_service_info(self, service_info: BluetoothServiceInfoBleak) -> None:
         matched_domains = self._integration_matcher.match_domains(service_info)
         if self._debug:

homeassistant/components/bluetooth/match.py

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

homeassistant/components/caldav/calendar.py

@@ -3,15 +3,20 @@
 from __future__ import annotations
 
 from datetime import datetime
+from functools import partial
 import logging
+from typing import Any
 
 import caldav
+from caldav.lib.error import DAVError
+import requests
 import voluptuous as vol
 
 from homeassistant.components.calendar import (
     ENTITY_ID_FORMAT,
     PLATFORM_SCHEMA as CALENDAR_PLATFORM_SCHEMA,
     CalendarEntity,
+    CalendarEntityFeature,
     CalendarEvent,
     is_offset_reached,
 )
@@ -23,6 +28,7 @@ from homeassistant.const import (
     CONF_VERIFY_SSL,
 )
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity import async_generate_entity_id
 from homeassistant.helpers.entity_platform import (
@@ -175,6 +181,8 @@ async def async_setup_entry(
 class WebDavCalendarEntity(CoordinatorEntity[CalDavUpdateCoordinator], CalendarEntity):
     """A device for getting the next Task from a WebDav Calendar."""
 
+    _attr_supported_features = CalendarEntityFeature.CREATE_EVENT
+
     def __init__(
         self,
         name: str | None,
@@ -203,6 +211,31 @@ class WebDavCalendarEntity(CoordinatorEntity[CalDavUpdateCoordinator], CalendarE
         """Get all events in a specific time frame."""
         return await self.coordinator.async_get_events(hass, start_date, end_date)
 
+    async def async_create_event(self, **kwargs: Any) -> None:
+        """Create a new event in the calendar."""
+        _LOGGER.debug("Event: %s", kwargs)
+
+        item_data: dict[str, Any] = {
+            "summary": kwargs["summary"],
+            "dtstart": kwargs["dtstart"],
+            "dtend": kwargs["dtend"],
+        }
+        if description := kwargs.get("description"):
+            item_data["description"] = description
+        if location := kwargs.get("location"):
+            item_data["location"] = location
+        if rrule := kwargs.get("rrule"):
+            item_data["rrule"] = rrule
+
+        _LOGGER.debug("ICS data %s", item_data)
+
+        try:
+            await self.hass.async_add_executor_job(
+                partial(self.coordinator.calendar.add_event, **item_data),
+            )
+        except (requests.ConnectionError, DAVError) as err:
+            raise HomeAssistantError(f"CalDAV save error: {err}") from err
+
     @callback
     def _handle_coordinator_update(self) -> None:
         """Update event data."""

homeassistant/components/camera/__init__.py

@@ -74,7 +74,10 @@ from .const import (
     StreamType,
 )
 from .helper import get_camera_from_entity_id
-from .img_util import scale_jpeg_camera_image
+from .img_util import (
+    TurboJPEGSingleton,  # noqa: F401
+    scale_jpeg_camera_image,
+)
 from .prefs import (
     CameraPreferences,
     DynamicStreamSettings,  # noqa: F401

homeassistant/components/canary/alarm_control_panel.py

@@ -31,7 +31,7 @@ async def async_setup_entry(
         for location_id, location in coordinator.data["locations"].items()
     ]
 
-    async_add_entities(alarms, True)
+    async_add_entities(alarms)
 
 
 class CanaryAlarm(

homeassistant/components/canary/camera.py

@@ -68,8 +68,7 @@ async def async_setup_entry(
             for location_id, location in coordinator.data["locations"].items()
             for device in location.devices
             if device.is_online
-        ),
-        True,
+        )
     )
 
 

homeassistant/components/canary/sensor.py

@@ -80,7 +80,7 @@ async def async_setup_entry(
                     if device_type.get("name") in sensor_type[4]
                 )
 
-    async_add_entities(sensors, True)
+    async_add_entities(sensors)
 
 
 class CanarySensor(CoordinatorEntity[CanaryDataUpdateCoordinator], SensorEntity):

homeassistant/components/cloud/client.py

@@ -19,7 +19,7 @@ from homeassistant.components.alexa import (
     errors as alexa_errors,
     smart_home as alexa_smart_home,
 )
-from homeassistant.components.camera.webrtc import async_register_ice_servers
+from homeassistant.components.camera import async_register_ice_servers
 from homeassistant.components.google_assistant import smart_home as ga
 from homeassistant.const import __version__ as HA_VERSION
 from homeassistant.core import Context, HassJob, HomeAssistant, callback

homeassistant/components/cloud/google_config.py

@@ -12,7 +12,9 @@ from hass_nabucasa.google_report_state import ErrorResponse
 
 from homeassistant.components.binary_sensor import BinarySensorDeviceClass
 from homeassistant.components.google_assistant import DOMAIN as GOOGLE_DOMAIN
-from homeassistant.components.google_assistant.helpers import AbstractConfig
+from homeassistant.components.google_assistant.helpers import (  # pylint: disable=hass-component-root-import
+    AbstractConfig,
+)
 from homeassistant.components.homeassistant.exposed_entities import (
     async_expose_entity,
     async_get_assistant_settings,

homeassistant/components/cloud/manifest.json

@@ -13,6 +13,6 @@
   "integration_type": "system",
   "iot_class": "cloud_push",
   "loggers": ["acme", "hass_nabucasa", "snitun"],
-  "requirements": ["hass-nabucasa==1.2.0"],
+  "requirements": ["hass-nabucasa==1.4.0"],
   "single_config_entry": true
 }

homeassistant/components/cloud/prefs.py

@@ -11,7 +11,7 @@ from hass_nabucasa.voice import MAP_VOICE, Gender
 from homeassistant.auth.const import GROUP_ID_ADMIN
 from homeassistant.auth.models import User
 from homeassistant.components import webhook
-from homeassistant.components.google_assistant.http import (
+from homeassistant.components.google_assistant.http import (  # pylint: disable=hass-component-root-import
     async_get_users as async_get_google_assistant_users,
 )
 from homeassistant.core import HomeAssistant, callback

homeassistant/components/co2signal/config_flow.py

@@ -38,6 +38,10 @@ TYPE_SPECIFY_COUNTRY = "specify_country_code"
 
 _LOGGER = logging.getLogger(__name__)
 
+DESCRIPTION_PLACEHOLDER = {
+    "register_link": "https://electricitymaps.com/free-tier",
+}
+
 
 class ElectricityMapsConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Co2signal."""
@@ -70,6 +74,7 @@ class ElectricityMapsConfigFlow(ConfigFlow, domain=DOMAIN):
             return self.async_show_form(
                 step_id="user",
                 data_schema=data_schema,
+                description_placeholders=DESCRIPTION_PLACEHOLDER,
             )
 
         data = {CONF_API_KEY: user_input[CONF_API_KEY]}
@@ -179,4 +184,5 @@ class ElectricityMapsConfigFlow(ConfigFlow, domain=DOMAIN):
             step_id=step_id,
             data_schema=data_schema,
             errors=errors,
+            description_placeholders=DESCRIPTION_PLACEHOLDER,
         )

homeassistant/components/co2signal/quality_scale.yaml

@@ -18,7 +18,6 @@ rules:
     status: todo
     comment: |
       The config flow misses data descriptions.
-      Remove URLs from data descriptions, they should be replaced with placeholders.
       Make use of Electricity Maps zone keys in country code as dropdown.
       Make use of location selector for coordinates.
   dependency-transparency: done

homeassistant/components/co2signal/strings.json

@@ -6,7 +6,7 @@
           "location": "[%key:common::config_flow::data::location%]",
           "api_key": "[%key:common::config_flow::data::access_token%]"
         },
-        "description": "Visit https://electricitymaps.com/free-tier to request a token."
+        "description": "Visit the [Electricity Maps page]({register_link}) to request a token."
       },
       "coordinates": {
         "data": {

homeassistant/components/coinbase/config_flow.py

@@ -166,6 +166,7 @@ class CoinbaseConfigFlow(ConfigFlow, domain=DOMAIN):
                 data_schema=STEP_USER_DATA_SCHEMA,
                 description_placeholders={
                     "account_name": self.reauth_entry.title,
+                    "developer_url": "https://www.coinbase.com/developer-platform",
                 },
                 errors=errors,
             )
@@ -195,6 +196,7 @@ class CoinbaseConfigFlow(ConfigFlow, domain=DOMAIN):
             data_schema=STEP_USER_DATA_SCHEMA,
             description_placeholders={
                 "account_name": self.reauth_entry.title,
+                "developer_url": "https://www.coinbase.com/developer-platform",
             },
             errors=errors,
         )

homeassistant/components/coinbase/strings.json

@@ -11,7 +11,7 @@
       },
       "reauth_confirm": {
         "title": "Update Coinbase API credentials",
-        "description": "Your current Coinbase API key appears to be for the deprecated v2 API. Please reconfigure with a new API key created for the v3 API. Visit https://www.coinbase.com/developer-platform  to create new credentials for {account_name}.",
+        "description": "Your current Coinbase API key appears to be for the deprecated v2 API. Please reconfigure with a new API key created for the v3 API. Visit the [Developer Platform]({developer_url}) to create new credentials for {account_name}.",
         "data": {
           "api_key": "[%key:common::config_flow::data::api_key%]",
           "api_token": "API secret"

homeassistant/components/comelit/manifest.json

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

homeassistant/components/comelit/utils.py

@@ -138,7 +138,7 @@ def new_device_listener(
     data_type: str,
 ) -> Callable[[], None]:
     """Subscribe to coordinator updates to check for new devices."""
-    known_devices: set[int] = set()
+    known_devices: dict[str, list[int]] = {}
 
     def _check_devices() -> None:
         """Check for new devices and call callback with any new monitors."""
@@ -147,8 +147,8 @@ def new_device_listener(
 
         new_devices: list[DeviceType] = []
         for _id in coordinator.data[data_type]:
-            if _id not in known_devices:
-                known_devices.add(_id)
+            if _id not in (id_list := known_devices.get(data_type, [])):
+                known_devices.update({data_type: [*id_list, _id]})
                 new_devices.append(coordinator.data[data_type][_id])
 
         if new_devices:

homeassistant/components/config/automation.py

@@ -6,7 +6,9 @@ from typing import Any
 import uuid
 
 from homeassistant.components.automation import DOMAIN as AUTOMATION_DOMAIN
-from homeassistant.components.automation.config import async_validate_config_item
+from homeassistant.components.automation.config import (  # pylint: disable=hass-component-root-import
+    async_validate_config_item,
+)
 from homeassistant.config import AUTOMATION_CONFIG_PATH
 from homeassistant.const import CONF_ID, SERVICE_RELOAD
 from homeassistant.core import HomeAssistant, callback

homeassistant/components/config/script.py

@@ -5,7 +5,9 @@ from __future__ import annotations
 from typing import Any
 
 from homeassistant.components.script import DOMAIN as SCRIPT_DOMAIN
-from homeassistant.components.script.config import async_validate_config_item
+from homeassistant.components.script.config import (  # pylint: disable=hass-component-root-import
+    async_validate_config_item,
+)
 from homeassistant.config import SCRIPT_CONFIG_PATH
 from homeassistant.const import SERVICE_RELOAD
 from homeassistant.core import HomeAssistant, callback

homeassistant/components/control4/manifest.json

@@ -6,7 +6,7 @@
   "documentation": "https://www.home-assistant.io/integrations/control4",
   "iot_class": "local_polling",
   "loggers": ["pyControl4"],
-  "requirements": ["pyControl4==1.2.0"],
+  "requirements": ["pyControl4==1.5.0"],
   "ssdp": [
     {
       "st": "c4:director"

homeassistant/components/control4/media_player.py

@@ -148,6 +148,15 @@ async def async_setup_entry(
                             source_type={dev_type}, idx=dev_id, name=name
                         )
 
+        # Skip rooms with no audio/video sources
+        if not sources:
+            _LOGGER.debug(
+                "Skipping room '%s' (ID: %s) - no audio/video sources found",
+                room.get("name"),
+                room_id,
+            )
+            continue
+
         try:
             hidden = room["roomHidden"]
             entity_list.append(

homeassistant/components/conversation/__init__.py

@@ -87,7 +87,6 @@ __all__ = [
     "async_get_chat_log",
     "async_get_result_from_chat_log",
     "async_set_agent",
-    "async_setup",
     "async_unset_agent",
 ]
 

homeassistant/components/conversation/chat_log.py

@@ -569,14 +569,17 @@ class ChatLog:
         if llm_api:
             prompt_parts.append(llm_api.api_prompt)
 
-        prompt_parts.append(
-            await self._async_expand_prompt_template(
-                llm_context,
-                llm.BASE_PROMPT,
-                llm_context.language,
-                user_name,
+        # Append current date and time to the prompt if the corresponding tool is not provided
+        llm_tools: list[llm.Tool] = llm_api.tools if llm_api else []
+        if not any(tool.name.endswith("GetDateTime") for tool in llm_tools):
+            prompt_parts.append(
+                await self._async_expand_prompt_template(
+                    llm_context,
+                    llm.DATE_TIME_PROMPT,
+                    llm_context.language,
+                    user_name,
+                )
             )
-        )
 
         if extra_system_prompt := (
             # Take new system prompt if one was given

homeassistant/components/cync/config_flow.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Mapping
 import logging
 from typing import Any
 
@@ -9,7 +10,7 @@ from pycync import Auth
 from pycync.exceptions import AuthFailedError, CyncError, TwoFactorRequiredError
 import voluptuous as vol
 
-from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_ACCESS_TOKEN, CONF_EMAIL, CONF_PASSWORD
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
@@ -39,7 +40,7 @@ class CyncConfigFlow(ConfigFlow, domain=DOMAIN):
 
     VERSION = 1
 
-    cync_auth: Auth
+    cync_auth: Auth = None
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -47,29 +48,14 @@ class CyncConfigFlow(ConfigFlow, domain=DOMAIN):
         """Attempt login with user credentials."""
         errors: dict[str, str] = {}
 
-        if user_input is None:
-            return self.async_show_form(
-                step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
-            )
+        if user_input:
+            try:
+                errors = await self._validate_credentials(user_input)
+            except TwoFactorRequiredError:
+                return await self.async_step_two_factor()
 
-        self.cync_auth = Auth(
-            async_get_clientsession(self.hass),
-            username=user_input[CONF_EMAIL],
-            password=user_input[CONF_PASSWORD],
-        )
-        try:
-            await self.cync_auth.login()
-        except AuthFailedError:
-            errors["base"] = "invalid_auth"
-        except TwoFactorRequiredError:
-            return await self.async_step_two_factor()
-        except CyncError:
-            errors["base"] = "cannot_connect"
-        except Exception:
-            _LOGGER.exception("Unexpected exception")
-            errors["base"] = "unknown"
-        else:
-            return await self._create_config_entry(self.cync_auth.username)
+            if not errors:
+                return await self._create_config_entry(self.cync_auth.username)
 
         return self.async_show_form(
             step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
@@ -81,12 +67,65 @@ class CyncConfigFlow(ConfigFlow, domain=DOMAIN):
         """Attempt login with the two factor auth code sent to the user."""
         errors: dict[str, str] = {}
 
-        if user_input is None:
+        if user_input:
+            errors = await self._validate_credentials(user_input)
+
+            if not errors:
+                return await self._create_config_entry(self.cync_auth.username)
+
             return self.async_show_form(
-                step_id="two_factor", data_schema=STEP_TWO_FACTOR_SCHEMA, errors=errors
+                step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
             )
+
+        return self.async_show_form(
+            step_id="two_factor", data_schema=STEP_TWO_FACTOR_SCHEMA, errors=errors
+        )
+
+    async def async_step_reauth(
+        self, entry_data: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Perform reauth upon an API authentication error."""
+        return await self.async_step_reauth_confirm()
+
+    async def async_step_reauth_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Dialog that informs the user that reauth is required and prompts for their Cync credentials."""
+        errors: dict[str, str] = {}
+
+        reauth_entry = self._get_reauth_entry()
+
+        if user_input:
+            try:
+                errors = await self._validate_credentials(user_input)
+            except TwoFactorRequiredError:
+                return await self.async_step_two_factor()
+
+            if not errors:
+                return await self._create_config_entry(self.cync_auth.username)
+
+        return self.async_show_form(
+            step_id="reauth_confirm",
+            data_schema=STEP_USER_DATA_SCHEMA,
+            errors=errors,
+            description_placeholders={CONF_EMAIL: reauth_entry.title},
+        )
+
+    async def _validate_credentials(self, user_input: dict[str, Any]) -> dict[str, str]:
+        """Attempt to log in with user email and password, and return the error dict."""
+        errors: dict[str, str] = {}
+
+        if not self.cync_auth:
+            self.cync_auth = Auth(
+                async_get_clientsession(self.hass),
+                username=user_input[CONF_EMAIL],
+                password=user_input[CONF_PASSWORD],
+            )
+
         try:
-            await self.cync_auth.login(user_input[CONF_TWO_FACTOR_CODE])
+            await self.cync_auth.login(user_input.get(CONF_TWO_FACTOR_CODE))
+        except TwoFactorRequiredError:
+            raise
         except AuthFailedError:
             errors["base"] = "invalid_auth"
         except CyncError:
@@ -94,25 +133,29 @@ class CyncConfigFlow(ConfigFlow, domain=DOMAIN):
         except Exception:
             _LOGGER.exception("Unexpected exception")
             errors["base"] = "unknown"
-        else:
-            return await self._create_config_entry(self.cync_auth.username)
 
-        return self.async_show_form(
-            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
-        )
+        return errors
 
     async def _create_config_entry(self, user_email: str) -> ConfigFlowResult:
         """Create the Cync config entry using input user data."""
 
         cync_user = self.cync_auth.user
         await self.async_set_unique_id(str(cync_user.user_id))
-        self._abort_if_unique_id_configured()
 
-        config = {
+        config_data = {
             CONF_USER_ID: cync_user.user_id,
             CONF_AUTHORIZE_STRING: cync_user.authorize,
             CONF_EXPIRES_AT: cync_user.expires_at,
             CONF_ACCESS_TOKEN: cync_user.access_token,
             CONF_REFRESH_TOKEN: cync_user.refresh_token,
         }
-        return self.async_create_entry(title=user_email, data=config)
+
+        if self.source == SOURCE_REAUTH:
+            self._abort_if_unique_id_mismatch()
+            return self.async_update_reload_and_abort(
+                entry=self._get_reauth_entry(), title=user_email, data=config_data
+            )
+
+        self._abort_if_unique_id_configured()
+
+        return self.async_create_entry(title=user_email, data=config_data)

homeassistant/components/cync/quality_scale.yaml

@@ -37,7 +37,7 @@ rules:
   integration-owner: done
   log-when-unavailable: todo
   parallel-updates: todo
-  reauthentication-flow: todo
+  reauthentication-flow: done
   test-coverage: todo
 
   # Gold

homeassistant/components/cync/strings.json

@@ -18,6 +18,18 @@
         "data_description": {
           "two_factor_code": "The two-factor code sent to your Cync account's email"
         }
+      },
+      "reauth_confirm": {
+        "title": "[%key:common::config_flow::title::reauth%]",
+        "description": "The Cync integration needs to re-authenticate for {email}",
+        "data": {
+          "email": "[%key:common::config_flow::data::email%]",
+          "password": "[%key:common::config_flow::data::password%]"
+        },
+        "data_description": {
+          "email": "[%key:component::cync::config::step::user::data_description::email%]",
+          "password": "[%key:component::cync::config::step::user::data_description::password%]"
+        }
       }
     },
     "error": {
@@ -26,7 +38,9 @@
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },
     "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]"
+      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
+      "unique_id_mismatch": "An incorrect user was provided by Cync for your email address, please consult your Cync app"
     }
   }
 }

homeassistant/components/demo/alarm_control_panel.py

@@ -5,7 +5,9 @@ from __future__ import annotations
 import datetime
 
 from homeassistant.components.alarm_control_panel import AlarmControlPanelState
-from homeassistant.components.manual.alarm_control_panel import ManualAlarm
+from homeassistant.components.manual.alarm_control_panel import (  # pylint: disable=hass-component-root-import
+    ManualAlarm,
+)
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_ARMING_TIME, CONF_DELAY_TIME, CONF_TRIGGER_TIME
 from homeassistant.core import HomeAssistant

homeassistant/components/demo/cover.py

@@ -139,6 +139,7 @@ class DemoCover(CoverEntity):
             self.async_write_ha_state()
             return
 
+        self._is_opening = False
         self._is_closing = True
         self._listen_cover()
         self._requested_closing = True
@@ -162,6 +163,7 @@ class DemoCover(CoverEntity):
             return
 
         self._is_opening = True
+        self._is_closing = False
         self._listen_cover()
         self._requested_closing = False
         self.async_write_ha_state()
@@ -181,10 +183,14 @@ class DemoCover(CoverEntity):
         if self._position == position:
             return
 
+        self._is_closing = position < (self._position or 0)
+        self._is_opening = not self._is_closing
+
         self._listen_cover()
         self._requested_closing = (
             self._position is not None and position < self._position
         )
+        self.async_write_ha_state()
 
     async def async_set_cover_tilt_position(self, **kwargs: Any) -> None:
         """Move the cover til to a specific position."""

homeassistant/components/derivative/sensor.py

@@ -196,7 +196,7 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
 
         self._attr_name = name if name is not None else f"{source_entity} derivative"
         self._attr_extra_state_attributes = {ATTR_SOURCE_ID: source_entity}
-
+        self._unit_template: str | None = None
         if unit_of_measurement is None:
             final_unit_prefix = "" if unit_prefix is None else unit_prefix
             self._unit_template = f"{final_unit_prefix}{{}}/{unit_time}"
@@ -217,6 +217,23 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
             lambda *args: None
         )
 
+    def _derive_and_set_attributes_from_state(self, source_state: State | None) -> None:
+        if self._unit_template and source_state:
+            original_unit = self._attr_native_unit_of_measurement
+            source_unit = source_state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
+            self._attr_native_unit_of_measurement = self._unit_template.format(
+                "" if source_unit is None else source_unit
+            )
+            if original_unit != self._attr_native_unit_of_measurement:
+                _LOGGER.debug(
+                    "%s: Derivative sensor switched UoM from %s to %s, resetting state to 0",
+                    self.entity_id,
+                    original_unit,
+                    self._attr_native_unit_of_measurement,
+                )
+                self._state_list = []
+                self._attr_native_value = round(Decimal(0), self._round_digits)
+
     def _calc_derivative_from_state_list(self, current_time: datetime) -> Decimal:
         def calculate_weight(start: datetime, end: datetime, now: datetime) -> float:
             window_start = now - timedelta(seconds=self._time_window)
@@ -285,6 +302,9 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
             except (InvalidOperation, TypeError):
                 self._attr_native_value = None
 
+        source_state = self.hass.states.get(self._sensor_source_id)
+        self._derive_and_set_attributes_from_state(source_state)
+
         def schedule_max_sub_interval_exceeded(source_state: State | None) -> None:
             """Schedule calculation using the source state and max_sub_interval.
 
@@ -358,10 +378,18 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
             _LOGGER.debug("%s: New state changed event: %s", self.entity_id, event.data)
             self._cancel_max_sub_interval_exceeded_callback()
             new_state = event.data["new_state"]
+
             if not self._handle_invalid_source_state(new_state):
                 return
 
             assert new_state
+
+            original_unit = self._attr_native_unit_of_measurement
+            self._derive_and_set_attributes_from_state(new_state)
+            if original_unit != self._attr_native_unit_of_measurement:
+                self.async_write_ha_state()
+                return
+
             schedule_max_sub_interval_exceeded(new_state)
             old_state = event.data["old_state"]
             if old_state is not None:
@@ -391,12 +419,6 @@ class DerivativeSensor(RestoreSensor, SensorEntity):
                     self.async_write_ha_state()
                     return
 
-            if self.native_unit_of_measurement is None:
-                unit = new_state.attributes.get(ATTR_UNIT_OF_MEASUREMENT)
-                self._attr_native_unit_of_measurement = self._unit_template.format(
-                    "" if unit is None else unit
-                )
-
             self._prune_state_list(new_timestamp)
 
             try:

homeassistant/components/doods/manifest.json

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

homeassistant/components/ecobee/config_flow.py

@@ -61,5 +61,8 @@ class EcobeeFlowHandler(ConfigFlow, domain=DOMAIN):
         return self.async_show_form(
             step_id="authorize",
             errors=errors,
-            description_placeholders={"pin": self._ecobee.pin},
+            description_placeholders={
+                "pin": self._ecobee.pin,
+                "auth_url": "https://www.ecobee.com/consumerportal/index.html",
+            },
         )

homeassistant/components/ecobee/strings.json

@@ -8,7 +8,7 @@
         }
       },
       "authorize": {
-        "description": "Please authorize this app at https://www.ecobee.com/consumerportal/index.html with PIN code:\n\n{pin}\n\nThen, select **Submit**."
+        "description": "Please authorize this app at {auth_url} with PIN code:\n\n{pin}\n\nThen, select **Submit**."
       }
     },
     "error": {

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/eheimdigital/sensor.py

@@ -8,8 +8,11 @@ from eheimdigital.classic_vario import EheimDigitalClassicVario
 from eheimdigital.device import EheimDigitalDevice
 from eheimdigital.types import FilterErrorCode
 
-from homeassistant.components.sensor import SensorEntity, SensorEntityDescription
-from homeassistant.components.sensor.const import SensorDeviceClass
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+)
 from homeassistant.const import PERCENTAGE, EntityCategory, UnitOfTime
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback

homeassistant/components/elevenlabs/__init__.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+import logging
 
 from elevenlabs import AsyncElevenLabs, Model
 from elevenlabs.core import ApiError
@@ -18,9 +19,14 @@ from homeassistant.exceptions import (
 )
 from homeassistant.helpers.httpx_client import get_async_client
 
-from .const import CONF_MODEL
+from .const import CONF_MODEL, CONF_STT_MODEL
 
-PLATFORMS: list[Platform] = [Platform.TTS]
+_LOGGER = logging.getLogger(__name__)
+
+PLATFORMS: list[Platform] = [
+    Platform.STT,
+    Platform.TTS,
+]
 
 
 async def get_model_by_id(client: AsyncElevenLabs, model_id: str) -> Model | None:
@@ -39,6 +45,7 @@ class ElevenLabsData:
 
     client: AsyncElevenLabs
     model: Model
+    stt_model: str
 
 
 type ElevenLabsConfigEntry = ConfigEntry[ElevenLabsData]
@@ -62,7 +69,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: ElevenLabsConfigEntry) -
     if model is None or (not model.languages):
         raise ConfigEntryError("Model could not be resolved")
 
-    entry.runtime_data = ElevenLabsData(client=client, model=model)
+    entry.runtime_data = ElevenLabsData(
+        client=client, model=model, stt_model=entry.options[CONF_STT_MODEL]
+    )
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
@@ -78,3 +87,44 @@ async def update_listener(
 ) -> None:
     """Handle options update."""
     await hass.config_entries.async_reload(config_entry.entry_id)
+
+
+async def async_migrate_entry(
+    hass: HomeAssistant, config_entry: ElevenLabsConfigEntry
+) -> bool:
+    """Migrate old config entry to new format."""
+
+    _LOGGER.debug(
+        "Migrating configuration from version %s.%s",
+        config_entry.version,
+        config_entry.minor_version,
+    )
+
+    if config_entry.version > 1:
+        # This means the user has downgraded from a future version
+        return False
+
+    if config_entry.version == 1:
+        new_options = {**config_entry.options}
+
+        if config_entry.minor_version < 2:
+            # Add defaults only if they’re not already present
+            if "stt_auto_language" not in new_options:
+                new_options["stt_auto_language"] = False
+            if "stt_model" not in new_options:
+                new_options["stt_model"] = "scribe_v1"
+
+        hass.config_entries.async_update_entry(
+            config_entry,
+            options=new_options,
+            minor_version=2,
+            version=1,
+        )
+
+    _LOGGER.debug(
+        "Migration to configuration version %s.%s successful",
+        config_entry.version,
+        config_entry.minor_version,
+    )
+
+    return True  # already up to date

homeassistant/components/elevenlabs/config_flow.py

@@ -25,15 +25,20 @@ from .const import (
     CONF_MODEL,
     CONF_SIMILARITY,
     CONF_STABILITY,
+    CONF_STT_AUTO_LANGUAGE,
+    CONF_STT_MODEL,
     CONF_STYLE,
     CONF_USE_SPEAKER_BOOST,
     CONF_VOICE,
-    DEFAULT_MODEL,
     DEFAULT_SIMILARITY,
     DEFAULT_STABILITY,
+    DEFAULT_STT_AUTO_LANGUAGE,
+    DEFAULT_STT_MODEL,
     DEFAULT_STYLE,
+    DEFAULT_TTS_MODEL,
     DEFAULT_USE_SPEAKER_BOOST,
     DOMAIN,
+    STT_MODELS,
 )
 
 USER_STEP_SCHEMA = vol.Schema({vol.Required(CONF_API_KEY): str})
@@ -68,6 +73,7 @@ class ElevenLabsConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for ElevenLabs text-to-speech."""
 
     VERSION = 1
+    MINOR_VERSION = 2
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -88,7 +94,12 @@ class ElevenLabsConfigFlow(ConfigFlow, domain=DOMAIN):
                 return self.async_create_entry(
                     title="ElevenLabs",
                     data=user_input,
-                    options={CONF_MODEL: DEFAULT_MODEL, CONF_VOICE: list(voices)[0]},
+                    options={
+                        CONF_MODEL: DEFAULT_TTS_MODEL,
+                        CONF_VOICE: list(voices)[0],
+                        CONF_STT_MODEL: DEFAULT_STT_MODEL,
+                        CONF_STT_AUTO_LANGUAGE: False,
+                    },
                 )
         return self.async_show_form(
             step_id="user", data_schema=USER_STEP_SCHEMA, errors=errors
@@ -113,6 +124,9 @@ class ElevenLabsOptionsFlow(OptionsFlow):
         self.models: dict[str, str] = {}
         self.model: str | None = None
         self.voice: str | None = None
+        self.stt_models: dict[str, str] = STT_MODELS
+        self.stt_model: str | None = None
+        self.auto_language: bool | None = None
 
     async def async_step_init(
         self, user_input: dict[str, Any] | None = None
@@ -126,6 +140,8 @@ class ElevenLabsOptionsFlow(OptionsFlow):
         if user_input is not None:
             self.model = user_input[CONF_MODEL]
             self.voice = user_input[CONF_VOICE]
+            self.stt_model = user_input[CONF_STT_MODEL]
+            self.auto_language = user_input[CONF_STT_AUTO_LANGUAGE]
             configure_voice = user_input.pop(CONF_CONFIGURE_VOICE)
             if configure_voice:
                 return await self.async_step_voice_settings()
@@ -165,6 +181,22 @@ class ElevenLabsOptionsFlow(OptionsFlow):
                             ]
                         )
                     ),
+                    vol.Required(
+                        CONF_STT_MODEL,
+                    ): SelectSelector(
+                        SelectSelectorConfig(
+                            options=[
+                                SelectOptionDict(label=model_name, value=model_id)
+                                for model_id, model_name in self.stt_models.items()
+                            ]
+                        )
+                    ),
+                    vol.Required(
+                        CONF_STT_AUTO_LANGUAGE,
+                        default=self.config_entry.options.get(
+                            CONF_STT_AUTO_LANGUAGE, DEFAULT_STT_AUTO_LANGUAGE
+                        ),
+                    ): bool,
                     vol.Required(CONF_CONFIGURE_VOICE, default=False): bool,
                 }
             ),
@@ -179,6 +211,8 @@ class ElevenLabsOptionsFlow(OptionsFlow):
         if user_input is not None:
             user_input[CONF_MODEL] = self.model
             user_input[CONF_VOICE] = self.voice
+            user_input[CONF_STT_MODEL] = self.stt_model
+            user_input[CONF_STT_AUTO_LANGUAGE] = self.auto_language
             return self.async_create_entry(
                 title="ElevenLabs",
                 data=user_input,

homeassistant/components/elevenlabs/const.py

@@ -7,12 +7,123 @@ CONF_MODEL = "model"
 CONF_CONFIGURE_VOICE = "configure_voice"
 CONF_STABILITY = "stability"
 CONF_SIMILARITY = "similarity"
+CONF_STT_AUTO_LANGUAGE = "stt_auto_language"
+CONF_STT_MODEL = "stt_model"
 CONF_STYLE = "style"
 CONF_USE_SPEAKER_BOOST = "use_speaker_boost"
 DOMAIN = "elevenlabs"
 
-DEFAULT_MODEL = "eleven_multilingual_v2"
+DEFAULT_TTS_MODEL = "eleven_multilingual_v2"
 DEFAULT_STABILITY = 0.5
 DEFAULT_SIMILARITY = 0.75
+DEFAULT_STT_AUTO_LANGUAGE = False
+DEFAULT_STT_MODEL = "scribe_v1"
 DEFAULT_STYLE = 0
 DEFAULT_USE_SPEAKER_BOOST = True
+
+STT_LANGUAGES = [
+    "af-ZA",  # Afrikaans
+    "am-ET",  # Amharic
+    "ar-SA",  # Arabic
+    "hy-AM",  # Armenian
+    "as-IN",  # Assamese
+    "ast-ES",  # Asturian
+    "az-AZ",  # Azerbaijani
+    "be-BY",  # Belarusian
+    "bn-IN",  # Bengali
+    "bs-BA",  # Bosnian
+    "bg-BG",  # Bulgarian
+    "my-MM",  # Burmese
+    "yue-HK",  # Cantonese
+    "ca-ES",  # Catalan
+    "ceb-PH",  # Cebuano
+    "ny-MW",  # Chichewa
+    "hr-HR",  # Croatian
+    "cs-CZ",  # Czech
+    "da-DK",  # Danish
+    "nl-NL",  # Dutch
+    "en-US",  # English
+    "et-EE",  # Estonian
+    "fil-PH",  # Filipino
+    "fi-FI",  # Finnish
+    "fr-FR",  # French
+    "ff-SN",  # Fulah
+    "gl-ES",  # Galician
+    "lg-UG",  # Ganda
+    "ka-GE",  # Georgian
+    "de-DE",  # German
+    "el-GR",  # Greek
+    "gu-IN",  # Gujarati
+    "ha-NG",  # Hausa
+    "he-IL",  # Hebrew
+    "hi-IN",  # Hindi
+    "hu-HU",  # Hungarian
+    "is-IS",  # Icelandic
+    "ig-NG",  # Igbo
+    "id-ID",  # Indonesian
+    "ga-IE",  # Irish
+    "it-IT",  # Italian
+    "ja-JP",  # Japanese
+    "jv-ID",  # Javanese
+    "kea-CV",  # Kabuverdianu
+    "kn-IN",  # Kannada
+    "kk-KZ",  # Kazakh
+    "km-KH",  # Khmer
+    "ko-KR",  # Korean
+    "ku-TR",  # Kurdish
+    "ky-KG",  # Kyrgyz
+    "lo-LA",  # Lao
+    "lv-LV",  # Latvian
+    "ln-CD",  # Lingala
+    "lt-LT",  # Lithuanian
+    "luo-KE",  # Luo
+    "lb-LU",  # Luxembourgish
+    "mk-MK",  # Macedonian
+    "ms-MY",  # Malay
+    "ml-IN",  # Malayalam
+    "mt-MT",  # Maltese
+    "zh-CN",  # Mandarin Chinese
+    "mi-NZ",  # Māori
+    "mr-IN",  # Marathi
+    "mn-MN",  # Mongolian
+    "ne-NP",  # Nepali
+    "nso-ZA",  # Northern Sotho
+    "no-NO",  # Norwegian
+    "oc-FR",  # Occitan
+    "or-IN",  # Odia
+    "ps-AF",  # Pashto
+    "fa-IR",  # Persian
+    "pl-PL",  # Polish
+    "pt-PT",  # Portuguese
+    "pa-IN",  # Punjabi
+    "ro-RO",  # Romanian
+    "ru-RU",  # Russian
+    "sr-RS",  # Serbian
+    "sn-ZW",  # Shona
+    "sd-PK",  # Sindhi
+    "sk-SK",  # Slovak
+    "sl-SI",  # Slovenian
+    "so-SO",  # Somali
+    "es-ES",  # Spanish
+    "sw-KE",  # Swahili
+    "sv-SE",  # Swedish
+    "ta-IN",  # Tamil
+    "tg-TJ",  # Tajik
+    "te-IN",  # Telugu
+    "th-TH",  # Thai
+    "tr-TR",  # Turkish
+    "uk-UA",  # Ukrainian
+    "umb-AO",  # Umbundu
+    "ur-PK",  # Urdu
+    "uz-UZ",  # Uzbek
+    "vi-VN",  # Vietnamese
+    "cy-GB",  # Welsh
+    "wo-SN",  # Wolof
+    "xh-ZA",  # Xhosa
+    "zu-ZA",  # Zulu
+]
+
+STT_MODELS = {
+    "scribe_v1": "Scribe v1",
+    "scribe_v1_experimental": "Scribe v1 Experimental",
+}

homeassistant/components/elevenlabs/strings.json

@@ -21,11 +21,15 @@
         "data": {
           "voice": "Voice",
           "model": "Model",
+          "stt_model": "Speech-to-Text Model",
+          "stt_auto_language": "Auto-detect language",
           "configure_voice": "Configure advanced voice settings"
         },
         "data_description": {
-          "voice": "Voice to use for the TTS.",
+          "voice": "Voice to use for text-to-speech.",
           "model": "ElevenLabs model to use. Please note that not all models support all languages equally well.",
+          "stt_model": "Speech-to-Text model to use.",
+          "stt_auto_language": "Automatically detect the spoken language for speech-to-text.",
           "configure_voice": "Configure advanced voice settings. Find more information in the ElevenLabs documentation."
         }
       },
@@ -44,5 +48,17 @@
         }
       }
     }
+  },
+  "entity": {
+    "tts": {
+      "elevenlabs_tts": {
+        "name": "Text-to-Speech"
+      }
+    },
+    "stt": {
+      "elevenlabs_stt": {
+        "name": "Speech-to-Text"
+      }
+    }
   }
 }

homeassistant/components/elevenlabs/stt.py

@@ -0,0 +1,207 @@
+"""Support for the ElevenLabs speech-to-text service."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterable
+from io import BytesIO
+import logging
+
+from elevenlabs import AsyncElevenLabs
+from elevenlabs.core import ApiError
+from elevenlabs.types import Model
+
+from homeassistant.components import stt
+from homeassistant.components.stt import (
+    AudioBitRates,
+    AudioChannels,
+    AudioCodecs,
+    AudioFormats,
+    AudioSampleRates,
+    SpeechMetadata,
+    SpeechResultState,
+    SpeechToTextEntity,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import ElevenLabsConfigEntry
+from .const import (
+    CONF_STT_AUTO_LANGUAGE,
+    DEFAULT_STT_AUTO_LANGUAGE,
+    DOMAIN,
+    STT_LANGUAGES,
+)
+
+_LOGGER = logging.getLogger(__name__)
+PARALLEL_UPDATES = 10
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: ElevenLabsConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up ElevenLabs stt platform via config entry."""
+    client = config_entry.runtime_data.client
+    auto_detect = config_entry.options.get(
+        CONF_STT_AUTO_LANGUAGE, DEFAULT_STT_AUTO_LANGUAGE
+    )
+
+    async_add_entities(
+        [
+            ElevenLabsSTTEntity(
+                client,
+                config_entry.runtime_data.model,
+                config_entry.runtime_data.stt_model,
+                config_entry.entry_id,
+                auto_detect_language=auto_detect,
+            )
+        ]
+    )
+
+
+class ElevenLabsSTTEntity(SpeechToTextEntity):
+    """The ElevenLabs STT API entity."""
+
+    _attr_has_entity_name = True
+    _attr_translation_key = "elevenlabs_stt"
+
+    def __init__(
+        self,
+        client: AsyncElevenLabs,
+        model: Model,
+        stt_model: str,
+        entry_id: str,
+        auto_detect_language: bool = False,
+    ) -> None:
+        """Init ElevenLabs TTS service."""
+        self._client = client
+        self._auto_detect_language = auto_detect_language
+        self._stt_model = stt_model
+
+        # Entity attributes
+        self._attr_unique_id = entry_id
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, entry_id)},
+            manufacturer="ElevenLabs",
+            model=model.name,
+            name="ElevenLabs",
+            entry_type=DeviceEntryType.SERVICE,
+        )
+
+    @property
+    def supported_languages(self) -> list[str]:
+        """Return a list of supported languages."""
+        return STT_LANGUAGES
+
+    @property
+    def supported_formats(self) -> list[AudioFormats]:
+        """Return a list of supported formats."""
+        return [AudioFormats.WAV, AudioFormats.OGG]
+
+    @property
+    def supported_codecs(self) -> list[AudioCodecs]:
+        """Return a list of supported codecs."""
+        return [AudioCodecs.PCM, AudioCodecs.OPUS]
+
+    @property
+    def supported_bit_rates(self) -> list[AudioBitRates]:
+        """Return a list of supported bit rates."""
+        return [AudioBitRates.BITRATE_16]
+
+    @property
+    def supported_sample_rates(self) -> list[AudioSampleRates]:
+        """Return a list of supported sample rates."""
+        return [AudioSampleRates.SAMPLERATE_16000]
+
+    @property
+    def supported_channels(self) -> list[AudioChannels]:
+        """Return a list of supported channels."""
+        return [
+            AudioChannels.CHANNEL_MONO,
+            AudioChannels.CHANNEL_STEREO,
+        ]
+
+    async def async_process_audio_stream(
+        self, metadata: SpeechMetadata, stream: AsyncIterable[bytes]
+    ) -> stt.SpeechResult:
+        """Process an audio stream to STT service."""
+        _LOGGER.debug(
+            "Processing audio stream for STT: model=%s, language=%s, format=%s, codec=%s, sample_rate=%s, channels=%s, bit_rate=%s",
+            self._stt_model,
+            metadata.language,
+            metadata.format,
+            metadata.codec,
+            metadata.sample_rate,
+            metadata.channel,
+            metadata.bit_rate,
+        )
+
+        if self._auto_detect_language:
+            lang_code = None
+        else:
+            language = metadata.language
+            if language.lower() not in [lang.lower() for lang in STT_LANGUAGES]:
+                _LOGGER.warning("Unsupported language: %s", language)
+                return stt.SpeechResult(None, SpeechResultState.ERROR)
+            lang_code = language.split("-")[0]
+
+        raw_pcm_compatible = (
+            metadata.codec == AudioCodecs.PCM
+            and metadata.sample_rate == AudioSampleRates.SAMPLERATE_16000
+            and metadata.channel == AudioChannels.CHANNEL_MONO
+            and metadata.bit_rate == AudioBitRates.BITRATE_16
+        )
+        if raw_pcm_compatible:
+            file_format = "pcm_s16le_16"
+        elif metadata.codec == AudioCodecs.PCM:
+            _LOGGER.warning("PCM input does not meet expected raw format requirements")
+            return stt.SpeechResult(None, SpeechResultState.ERROR)
+        else:
+            file_format = "other"
+
+        audio = b""
+        async for chunk in stream:
+            audio += chunk
+
+        _LOGGER.debug("Finished reading audio stream, total size: %d bytes", len(audio))
+        if not audio:
+            _LOGGER.warning("No audio received in stream")
+            return stt.SpeechResult(None, SpeechResultState.ERROR)
+
+        lang_display = lang_code if lang_code else "auto-detected"
+
+        _LOGGER.debug(
+            "Transcribing audio (%s), format: %s, size: %d bytes",
+            lang_display,
+            file_format,
+            len(audio),
+        )
+
+        try:
+            response = await self._client.speech_to_text.convert(
+                file=BytesIO(audio),
+                file_format=file_format,
+                model_id=self._stt_model,
+                language_code=lang_code,
+                tag_audio_events=False,
+                num_speakers=1,
+                diarize=False,
+            )
+        except ApiError as exc:
+            _LOGGER.error("Error during processing of STT request: %s", exc)
+            return stt.SpeechResult(None, SpeechResultState.ERROR)
+
+        text = response.text or ""
+        detected_lang_code = response.language_code or "?"
+        detected_lang_prob = response.language_probability or "?"
+
+        _LOGGER.debug(
+            "Transcribed text is in language %s (probability %s): %s",
+            detected_lang_code,
+            detected_lang_prob,
+            text,
+        )
+
+        return stt.SpeechResult(text, SpeechResultState.SUCCESS)

homeassistant/components/elevenlabs/tts.py

@@ -71,7 +71,6 @@ async def async_setup_entry(
                 voices,
                 default_voice_id,
                 config_entry.entry_id,
-                config_entry.title,
                 voice_settings,
             )
         ]
@@ -83,6 +82,8 @@ class ElevenLabsTTSEntity(TextToSpeechEntity):
 
     _attr_supported_options = [ATTR_VOICE, ATTR_MODEL]
     _attr_entity_category = EntityCategory.CONFIG
+    _attr_has_entity_name = True
+    _attr_translation_key = "elevenlabs_tts"
 
     def __init__(
         self,
@@ -91,7 +92,6 @@ class ElevenLabsTTSEntity(TextToSpeechEntity):
         voices: list[ElevenLabsVoice],
         default_voice_id: str,
         entry_id: str,
-        title: str,
         voice_settings: VoiceSettings,
     ) -> None:
         """Init ElevenLabs TTS service."""
@@ -112,11 +112,11 @@ class ElevenLabsTTSEntity(TextToSpeechEntity):
 
         # Entity attributes
         self._attr_unique_id = entry_id
-        self._attr_name = title
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, entry_id)},
             manufacturer="ElevenLabs",
             model=model.name,
+            name="ElevenLabs",
             entry_type=DeviceEntryType.SERVICE,
         )
         self._attr_supported_languages = [

homeassistant/components/energy/sensor.py

@@ -16,7 +16,9 @@ from homeassistant.components.sensor import (
     SensorEntity,
     SensorStateClass,
 )
-from homeassistant.components.sensor.recorder import reset_detected
+from homeassistant.components.sensor.recorder import (  # pylint: disable=hass-component-root-import
+    reset_detected,
+)
 from homeassistant.const import ATTR_UNIT_OF_MEASUREMENT, UnitOfEnergy, UnitOfVolume
 from homeassistant.core import (
     HomeAssistant,

homeassistant/components/enphase_envoy/icons.json

@@ -38,6 +38,25 @@
       },
       "available_energy": {
         "default": "mdi:battery-50"
+      },
+      "grid_status": {
+        "default": "mdi:transmission-tower",
+        "state": {
+          "off_grid": "mdi:transmission-tower-off",
+          "synchronizing": "mdi:sync-alert"
+        }
+      },
+      "mid_state": {
+        "default": "mdi:electric-switch-closed",
+        "state": {
+          "open": "mdi:electric-switch"
+        }
+      },
+      "admin_state": {
+        "default": "mdi:transmission-tower",
+        "state": {
+          "off_grid": "mdi:transmission-tower-off"
+        }
       }
     },
     "switch": {

homeassistant/components/enphase_envoy/sensor.py

@@ -824,6 +824,12 @@ class EnvoyCollarSensorEntityDescription(SensorEntityDescription):
     value_fn: Callable[[EnvoyCollar], datetime.datetime | int | float | str]
 
 
+# translations don't accept uppercase
+ADMIN_STATE_MAP = {
+    "ENCMN_MDE_ON_GRID": "on_grid",
+    "ENCMN_MDE_OFF_GRID": "off_grid",
+}
+
 COLLAR_SENSORS = (
     EnvoyCollarSensorEntityDescription(
         key="temperature",
@@ -838,11 +844,21 @@ COLLAR_SENSORS = (
         device_class=SensorDeviceClass.TIMESTAMP,
         value_fn=lambda collar: dt_util.utc_from_timestamp(collar.last_report_date),
     ),
+    # grid_state does not seem to change when off-grid, but rather admin_state_str
     EnvoyCollarSensorEntityDescription(
         key="grid_state",
         translation_key="grid_status",
         value_fn=lambda collar: collar.grid_state,
     ),
+    # grid_status off-grid shows in admin_state rather than in grid_state
+    # map values as translations don't accept uppercase which these are
+    EnvoyCollarSensorEntityDescription(
+        key="admin_state_str",
+        translation_key="admin_state",
+        value_fn=lambda collar: ADMIN_STATE_MAP.get(
+            collar.admin_state_str, collar.admin_state_str
+        ),
+    ),
     EnvoyCollarSensorEntityDescription(
         key="mid_state",
         translation_key="mid_state",

homeassistant/components/enphase_envoy/strings.json

@@ -409,10 +409,26 @@
         "name": "Last report duration"
       },
       "grid_status": {
-        "name": "[%key:component::enphase_envoy::entity::binary_sensor::grid_status::name%]"
+        "name": "[%key:component::enphase_envoy::entity::binary_sensor::grid_status::name%]",
+        "state": {
+          "on_grid": "On grid",
+          "off_grid": "Off grid",
+          "synchronizing": "Synchronizing to grid"
+        }
       },
       "mid_state": {
-        "name": "MID state"
+        "name": "MID state",
+        "state": {
+          "open": "[%key:common::state::open%]",
+          "close": "[%key:common::state::closed%]"
+        }
+      },
+      "admin_state": {
+        "name": "Admin state",
+        "state": {
+          "on_grid": "[%key:component::enphase_envoy::entity::sensor::grid_status::state::on_grid%]",
+          "off_grid": "[%key:component::enphase_envoy::entity::sensor::grid_status::state::off_grid%]"
+        }
       }
     },
     "switch": {

homeassistant/components/environment_canada/__init__.py

@@ -47,11 +47,8 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ECConfigEntry) ->
     radar_coordinator = ECDataUpdateCoordinator(
         hass, config_entry, radar_data, "radar", DEFAULT_RADAR_UPDATE_INTERVAL
     )
-    try:
-        await radar_coordinator.async_config_entry_first_refresh()
-    except ConfigEntryNotReady:
-        errors = errors + 1
-        _LOGGER.warning("Unable to retrieve Environment Canada radar")
+    # Skip initial refresh for radar since the camera entity is disabled by default.
+    # The coordinator will fetch data when the entity is enabled.
 
     aqhi_data = ECAirQuality(coordinates=(lat, lon))
     aqhi_coordinator = ECDataUpdateCoordinator(
@@ -63,7 +60,9 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ECConfigEntry) ->
         errors = errors + 1
         _LOGGER.warning("Unable to retrieve Environment Canada AQHI")
 
-    if errors == 3:
+    # Require at least one coordinator to succeed (weather or AQHI)
+    # Radar is optional since the camera entity is disabled by default
+    if errors >= 2:
         raise ConfigEntryNotReady
 
     config_entry.runtime_data = ECRuntimeData(

homeassistant/components/environment_canada/camera.py

@@ -59,6 +59,14 @@ class ECCameraEntity(CoordinatorEntity[ECDataUpdateCoordinator[ECRadar]], Camera
 
         self.content_type = "image/gif"
 
+    async def async_added_to_hass(self) -> None:
+        """When entity is added to hass."""
+        await super().async_added_to_hass()
+        # Trigger coordinator refresh when entity is enabled
+        # since radar coordinator skips initial refresh during setup
+        if not self.coordinator.last_update_success:
+            await self.coordinator.async_request_refresh()
+
     def camera_image(
         self, width: int | None = None, height: int | None = None
     ) -> bytes | None:

homeassistant/components/environment_canada/config_flow.py

@@ -6,11 +6,18 @@ import xml.etree.ElementTree as ET
 
 import aiohttp
 from env_canada import ECWeather, ec_exc
+from env_canada.ec_weather import get_ec_sites_list
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_LANGUAGE, CONF_LATITUDE, CONF_LONGITUDE
 from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.selector import (
+    SelectOptionDict,
+    SelectSelector,
+    SelectSelectorConfig,
+    SelectSelectorMode,
+)
 
 from .const import CONF_STATION, CONF_TITLE, DOMAIN
 
@@ -25,14 +32,16 @@ async def validate_input(data):
     lang = data.get(CONF_LANGUAGE).lower()
 
     if station:
+        # When station is provided, use it and get the coordinates from ECWeather
         weather_data = ECWeather(station_id=station, language=lang)
-    else:
-        weather_data = ECWeather(coordinates=(lat, lon), language=lang)
-    await weather_data.update()
-
-    if lat is None or lon is None:
+        await weather_data.update()
+        # Always use the station's coordinates, not the user-provided ones
         lat = weather_data.lat
         lon = weather_data.lon
+    else:
+        # When no station is provided, use coordinates to find nearest station
+        weather_data = ECWeather(coordinates=(lat, lon), language=lang)
+        await weather_data.update()
 
     return {
         CONF_TITLE: weather_data.metadata.location,
@@ -46,6 +55,13 @@ class EnvironmentCanadaConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Environment Canada weather."""
 
     VERSION = 1
+    _station_codes: list[dict[str, str]] | None = None
+
+    async def _get_station_codes(self) -> list[dict[str, str]]:
+        """Get station codes, cached after first call."""
+        if self._station_codes is None:
+            self._station_codes = await get_ec_sites_list()
+        return self._station_codes
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -80,9 +96,21 @@ class EnvironmentCanadaConfigFlow(ConfigFlow, domain=DOMAIN):
                 self._abort_if_unique_id_configured()
                 return self.async_create_entry(title=info[CONF_TITLE], data=user_input)
 
+        station_codes = await self._get_station_codes()
+
         data_schema = vol.Schema(
             {
-                vol.Optional(CONF_STATION): str,
+                vol.Optional(CONF_STATION): SelectSelector(
+                    SelectSelectorConfig(
+                        options=[
+                            SelectOptionDict(
+                                value=station["value"], label=station["label"]
+                            )
+                            for station in station_codes
+                        ],
+                        mode=SelectSelectorMode.DROPDOWN,
+                    )
+                ),
                 vol.Optional(
                     CONF_LATITUDE, default=self.hass.config.latitude
                 ): cv.latitude,

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.3"]
+  "requirements": ["env-canada==0.12.1"]
 }

homeassistant/components/environment_canada/strings.json

@@ -3,11 +3,11 @@
     "step": {
       "user": {
         "title": "Environment Canada: weather location and language",
-        "description": "Either a station ID or latitude/longitude must be specified. The default latitude/longitude used are the values configured in your Home Assistant installation. The closest weather station to the coordinates will be used if specifying coordinates. If a station code is used it must follow the format: PP/code, where PP is the two-letter province and code is the station ID. The list of station IDs can be found here: https://dd.weather.gc.ca/citypage_weather/docs/site_list_towns_en.csv. Weather information can be retrieved in either English or French.",
+        "description": "Select a weather station from the dropdown, or specify coordinates to use the closest station. The default coordinates are from your Home Assistant installation. Weather information can be retrieved in English or French.",
         "data": {
           "latitude": "[%key:common::config_flow::data::latitude%]",
           "longitude": "[%key:common::config_flow::data::longitude%]",
-          "station": "Weather station ID",
+          "station": "Weather station",
           "language": "Weather information language"
         }
       }
@@ -16,7 +16,7 @@
       "already_configured": "[%key:common::config_flow::abort::already_configured_service%]"
     },
     "error": {
-      "bad_station_id": "Station ID is invalid, missing, or not found in the station ID database",
+      "bad_station_id": "Station code is invalid, missing, or not found in the station code database",
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "error_response": "Response from Environment Canada in error",
       "too_many_attempts": "Connections to Environment Canada are rate limited; Try again in 60 seconds",

homeassistant/components/epson/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/epson",
   "iot_class": "local_polling",
   "loggers": ["epson_projector"],
-  "requirements": ["epson-projector==0.5.1"]
+  "requirements": ["epson-projector==0.6.0"]
 }