Remove not needed guards for integration migrations from future versions (#173301)

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>

.github/workflows/check-requirements.lock.yml

@@ -36,7 +36,7 @@
 #   - actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
 #   - actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
 #   - actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
-#   - github/gh-aw-actions/setup@b11be78086764c43fa463398aed7ffdcf40549c1 # v0.77.0
+#   - github/gh-aw-actions/setup@97f280b14527ca95859c0facba201aeccb2c097f # v0.77.3
 #
 # Container images used:
 #   - ghcr.io/github/gh-aw-firewall/agent:0.25.46
@@ -90,7 +90,7 @@ jobs:
     steps:
       - name: Setup Scripts
         id: setup
-        uses: github/gh-aw-actions/setup@b11be78086764c43fa463398aed7ffdcf40549c1 # v0.77.0
+        uses: github/gh-aw-actions/setup@97f280b14527ca95859c0facba201aeccb2c097f # v0.77.3
         with:
           destination: ${{ runner.temp }}/gh-aw/actions
           job-name: ${{ github.job }}
@@ -352,7 +352,7 @@ jobs:
     steps:
       - name: Setup Scripts
         id: setup
-        uses: github/gh-aw-actions/setup@b11be78086764c43fa463398aed7ffdcf40549c1 # v0.77.0
+        uses: github/gh-aw-actions/setup@97f280b14527ca95859c0facba201aeccb2c097f # v0.77.3
         with:
           destination: ${{ runner.temp }}/gh-aw/actions
           job-name: ${{ github.job }}
@@ -961,7 +961,7 @@ jobs:
     steps:
       - name: Setup Scripts
         id: setup
-        uses: github/gh-aw-actions/setup@b11be78086764c43fa463398aed7ffdcf40549c1 # v0.77.0
+        uses: github/gh-aw-actions/setup@97f280b14527ca95859c0facba201aeccb2c097f # v0.77.3
         with:
           destination: ${{ runner.temp }}/gh-aw/actions
           job-name: ${{ github.job }}
@@ -1100,7 +1100,7 @@ jobs:
     steps:
       - name: Setup Scripts
         id: setup
-        uses: github/gh-aw-actions/setup@b11be78086764c43fa463398aed7ffdcf40549c1 # v0.77.0
+        uses: github/gh-aw-actions/setup@97f280b14527ca95859c0facba201aeccb2c097f # v0.77.3
         with:
           destination: ${{ runner.temp }}/gh-aw/actions
           job-name: ${{ github.job }}
@@ -1325,7 +1325,7 @@ jobs:
     steps:
       - name: Setup Scripts
         id: setup
-        uses: github/gh-aw-actions/setup@b11be78086764c43fa463398aed7ffdcf40549c1 # v0.77.0
+        uses: github/gh-aw-actions/setup@97f280b14527ca95859c0facba201aeccb2c097f # v0.77.3
         with:
           destination: ${{ runner.temp }}/gh-aw/actions
           job-name: ${{ github.job }}
@@ -1383,7 +1383,7 @@ jobs:
     steps:
       - name: Setup Scripts
         id: setup
-        uses: github/gh-aw-actions/setup@b11be78086764c43fa463398aed7ffdcf40549c1 # v0.77.0
+        uses: github/gh-aw-actions/setup@97f280b14527ca95859c0facba201aeccb2c097f # v0.77.3
         with:
           destination: ${{ runner.temp }}/gh-aw/actions
           job-name: ${{ github.job }}

.github/workflows/wheels.yml

@@ -137,7 +137,7 @@ jobs:
           sed -i "/uv/d" requirements_diff.txt
 
       - name: Build wheels
-        uses: home-assistant/wheels@e5742a69d69f0e274e2689c998900c7d19652c21 # 2025.12.0
+        uses: home-assistant/wheels@34957438948e0b3dcde73c77750643dadae594f5 # 2026.06.0
         with:
           abi: ${{ matrix.abi }}
           tag: musllinux_1_2
@@ -195,7 +195,7 @@ jobs:
           sed -i "/uv/d" requirements_diff.txt
 
       - name: Build wheels
-        uses: home-assistant/wheels@e5742a69d69f0e274e2689c998900c7d19652c21 # 2025.12.0
+        uses: home-assistant/wheels@34957438948e0b3dcde73c77750643dadae594f5 # 2026.06.0
         with:
           abi: ${{ matrix.abi }}
           tag: musllinux_1_2

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.15.14
+    rev: v0.15.15
     hooks:
       - id: ruff-check
         args:
@@ -64,17 +64,6 @@ repos:
         files: ^(homeassistant|tests|script)/.+\.py$
   - repo: local
     hooks:
-      # Drift guard for the checked-in sandbox protobuf gencode. Manual
-      # stage only (grpcio-tools is not a project dep, so it bootstraps a
-      # throwaway venv and degrades gracefully when uv is absent): run with
-      # `prek run --hook-stage manual sandbox-proto-drift` or in a CI lane.
-      - id: sandbox-proto-drift
-        name: sandbox protobuf gencode drift guard
-        entry: sandbox/proto/check_drift.sh
-        language: script
-        pass_filenames: false
-        stages: [manual]
-        files: ^sandbox/proto/sandbox\.proto$
       # Run mypy through our wrapper script in order to get the possible
       # pyenv and/or virtualenv activated; it may not have been e.g. if
       # committing from a GUI tool that was not launched from an activated
@@ -86,9 +75,6 @@ repos:
         require_serial: true
         types_or: [python, pyi]
         files: ^(homeassistant|pylint)/.+\.(py|pyi)$
-        # Checked-in protobuf gencode (sandbox): the .py + .pyi pair trips
-        # mypy's duplicate-module check, and it is machine-generated anyway.
-        exclude: _pb2\.(py|pyi)$
       - id: pylint
         name: pylint
         entry: script/run-in-env.sh pylint --ignore-missing-annotations=y

.strict-typing

@@ -96,6 +96,7 @@ homeassistant.components.aprs.*
 homeassistant.components.apsystems.*
 homeassistant.components.aqualogic.*
 homeassistant.components.aquostv.*
+homeassistant.components.aqvify.*
 homeassistant.components.aranet.*
 homeassistant.components.arcam_fmj.*
 homeassistant.components.arris_tg2492lg.*

CODEOWNERS

@@ -162,6 +162,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/apsystems/ @mawoka-myblock @SonnenladenGmbH
 /homeassistant/components/aquacell/ @Jordi1990
 /tests/components/aquacell/ @Jordi1990
+/homeassistant/components/aqvify/ @astrandb
+/tests/components/aqvify/ @astrandb
 /homeassistant/components/aranet/ @aschmitz @thecode @anrijs
 /tests/components/aranet/ @aschmitz @thecode @anrijs
 /homeassistant/components/arcam_fmj/ @elupus
@@ -574,8 +576,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/flo/ @dmulcahey
 /homeassistant/components/flume/ @ChrisMandich @bdraco @jeeftor
 /tests/components/flume/ @ChrisMandich @bdraco @jeeftor
-/homeassistant/components/fluss/ @fluss
-/tests/components/fluss/ @fluss
+/homeassistant/components/fluss/ @fluss @Marcello17
+/tests/components/fluss/ @fluss @Marcello17
 /homeassistant/components/flux_led/ @icemanch
 /tests/components/flux_led/ @icemanch
 /homeassistant/components/forecast_solar/ @klaasnicolaas @frenck

homeassistant/components/airos/__init__.py

@@ -116,10 +116,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> boo
 async def async_migrate_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> bool:
     """Migrate old config entry."""
 
-    # 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

homeassistant/components/airvisual_pro/entity.py

@@ -1,6 +1,10 @@
 """The AirVisual Pro integration."""
 
-from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.device_registry import (
+    CONNECTION_NETWORK_MAC,
+    DeviceInfo,
+    format_mac,
+)
 from homeassistant.helpers.entity import EntityDescription
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
@@ -25,6 +29,12 @@ class AirVisualProEntity(CoordinatorEntity[AirVisualProCoordinator]):
         """Return device registry information for this entity."""
         return DeviceInfo(
             identifiers={(DOMAIN, self.coordinator.data["serial_number"])},
+            connections={
+                (
+                    CONNECTION_NETWORK_MAC,
+                    format_mac(self.coordinator.data["status"]["mac_address"]),
+                )
+            },
             manufacturer="AirVisual",
             model=self.coordinator.data["status"]["model"],
             name=self.coordinator.data["settings"]["node_name"],

homeassistant/components/alexa_devices/__init__.py

@@ -65,10 +65,6 @@ async def async_setup_entry(hass: HomeAssistant, entry: AmazonConfigEntry) -> bo
 async def async_migrate_entry(hass: HomeAssistant, entry: AmazonConfigEntry) -> bool:
     """Migrate old entry."""
 
-    if entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
     if entry.version == 1 and entry.minor_version < 3:
         if CONF_SITE in entry.data:
             # Site in data (wrong place), just move to login data

homeassistant/components/anova/__init__.py

@@ -75,10 +75,6 @@ async def async_migrate_entry(hass: HomeAssistant, entry: AnovaConfigEntry) -> b
     """Migrate entry."""
     _LOGGER.debug("Migrating from version %s:%s", entry.version, entry.minor_version)
 
-    if entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
     if entry.version == 1 and entry.minor_version == 1:
         new_data = {**entry.data}
         if CONF_DEVICES in new_data:

homeassistant/components/anthropic/__init__.py

@@ -178,10 +178,6 @@ async def async_migrate_entry(hass: HomeAssistant, entry: AnthropicConfigEntry)
     """Migrate entry."""
     LOGGER.debug("Migrating from version %s:%s", entry.version, entry.minor_version)
 
-    if entry.version > 2:
-        # This means the user has downgraded from a future version
-        return False
-
     if entry.version == 2 and entry.minor_version == 1:
         # Correct broken device migration in Home Assistant Core 2025.7.0b0-2025.7.0b1
         device_registry = dr.async_get(hass)

homeassistant/components/api/__init__.py

@@ -59,7 +59,6 @@ ATTR_EXTERNAL_URL = "external_url"
 ATTR_INTERNAL_URL = "internal_url"
 ATTR_LOCATION_NAME = "location_name"
 ATTR_INSTALLATION_TYPE = "installation_type"
-ATTR_REQUIRES_API_PASSWORD = "requires_api_password"
 ATTR_UUID = "uuid"
 ATTR_VERSION = "version"
 

homeassistant/components/aqvify/__init__.py

@@ -0,0 +1,28 @@
+"""The Aqvify integration."""
+
+import logging
+
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+
+from .coordinator import AqvifyConfigEntry, AqvifyCoordinator
+
+_LOGGER = logging.getLogger(__name__)
+PLATFORMS: list[Platform] = [Platform.SENSOR]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: AqvifyConfigEntry) -> bool:
+    """Set up Aqvify from a config entry."""
+
+    coordinator = AqvifyCoordinator(hass, entry)
+    await coordinator.async_config_entry_first_refresh()
+    entry.runtime_data = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: AqvifyConfigEntry) -> bool:
+    """Unload Aqvify config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/aqvify/config_flow.py

@@ -0,0 +1,61 @@
+"""Config flow for the Aqvify integration."""
+
+import logging
+from typing import Any
+
+from aiohttp import ClientResponseError
+from pyaqvify import AqvifyAPI, AqvifyAuthException
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_API_KEY
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+STEP_USER_DATA_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_API_KEY): str,
+    }
+)
+
+
+class AqvifyConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Aqvify."""
+
+    VERSION = 1
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        errors: dict[str, str] = {}
+        if user_input is not None:
+            hub = AqvifyAPI(
+                user_input[CONF_API_KEY],
+                websession=async_get_clientsession(self.hass),
+            )
+            try:
+                account_data = await hub.async_get_account_id()
+            except AqvifyAuthException:
+                errors["base"] = "invalid_auth"
+            except ClientResponseError:
+                errors["base"] = "cannot_connect"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                await self.async_set_unique_id(account_data.account_id)
+                self._abort_if_unique_id_configured()
+                return self.async_create_entry(title="Aqvify", data=user_input)
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=STEP_USER_DATA_SCHEMA,
+            errors=errors,
+            description_placeholders={
+                "aqvify_url": "https://app.aqvify.com/User",
+            },
+        )

homeassistant/components/aqvify/const.py

@@ -0,0 +1,3 @@
+"""Constants for the Aqvify integration."""
+
+DOMAIN = "aqvify"

homeassistant/components/aqvify/coordinator.py

@@ -0,0 +1,92 @@
+"""Coordinator for Aqvify integration."""
+
+from dataclasses import dataclass
+from datetime import timedelta
+import logging
+
+from aiohttp import ClientResponseError
+from pyaqvify import AqvifyAPI, AqvifyAuthException, AqvifyDeviceData, AqvifyDevices
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_API_KEY
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+UPDATE_INTERVAL = timedelta(seconds=60)
+
+type AqvifyConfigEntry = ConfigEntry[AqvifyCoordinator]
+
+
+@dataclass
+class AqvifyCoordinatorData:
+    """Data class for storing coordinator data."""
+
+    devices: AqvifyDevices
+    device_data: dict[str, AqvifyDeviceData]
+
+
+class AqvifyCoordinator(DataUpdateCoordinator[AqvifyCoordinatorData]):
+    """Data update coordinator for Aqvify devices."""
+
+    config_entry: AqvifyConfigEntry
+
+    def __init__(self, hass: HomeAssistant, entry: AqvifyConfigEntry) -> None:
+        """Initialize the Aqvify data update coordinator."""
+        super().__init__(
+            hass,
+            logger=_LOGGER,
+            name=DOMAIN,
+            update_interval=UPDATE_INTERVAL,
+            config_entry=entry,
+        )
+
+        self.api_client = AqvifyAPI(
+            entry.data[CONF_API_KEY], websession=async_get_clientsession(hass)
+        )
+
+    async def _async_setup(self) -> None:
+        """Set up the coordinator."""
+        try:
+            await self.api_client.async_get_account_id()
+        except AqvifyAuthException as err:
+            raise ConfigEntryAuthFailed(f"Invalid Aqvify API key: {err}") from err
+        except (ClientResponseError, TimeoutError) as err:
+            raise ConfigEntryNotReady(
+                f"Failed to connect to Aqvify API: {err}"
+            ) from err
+
+    async def _async_update_data(self) -> AqvifyCoordinatorData:
+        """Fetch device state."""
+        try:
+            devices = await self.api_client.async_get_devices()
+        except ClientResponseError as err:
+            raise UpdateFailed(f"Error communicating with Aqvify API: {err}") from err
+        except TimeoutError as err:
+            raise UpdateFailed(f"Timeout communicating with Aqvify API: {err}") from err
+
+        device_data = {}
+        for device in devices.devices.values():
+            try:
+                device_key = str(device.device_key)
+                device_data[
+                    device_key
+                ] = await self.api_client.async_get_device_latest_data(device_key)
+            except ClientResponseError as err:
+                raise UpdateFailed(
+                    f"Error communicating with Aqvify API: {err}"
+                ) from err
+            except TimeoutError as err:
+                raise UpdateFailed(
+                    f"Timeout communicating with Aqvify API: {err}"
+                ) from err
+
+        return AqvifyCoordinatorData(
+            devices=devices,
+            device_data=device_data,
+        )

homeassistant/components/aqvify/entity.py

@@ -0,0 +1,35 @@
+"""Defines a base Aqvify entity."""
+
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity import EntityDescription
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import AqvifyCoordinator
+
+
+class AqvifyBaseEntity(CoordinatorEntity[AqvifyCoordinator]):
+    """Defines a base Aqvify entity."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: AqvifyCoordinator,
+        description: EntityDescription,
+        device_key: str,
+    ) -> None:
+        """Initialize the Aqvify entity."""
+        super().__init__(coordinator)
+
+        account_id = self.coordinator.config_entry.unique_id
+        self.device_key = device_key
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, f"{account_id}_{device_key}")},
+            name=coordinator.data.devices.devices[device_key].name,
+            manufacturer="Aqvify",
+            configuration_url="https://app.aqvify.com",
+            serial_number=device_key,
+        )
+        self._attr_unique_id = f"{account_id}_{device_key}_{description.key}"
+        self.entity_description = description

homeassistant/components/aqvify/icons.json

@@ -0,0 +1,12 @@
+{
+  "entity": {
+    "sensor": {
+      "meter_value": {
+        "default": "mdi:waves-arrow-up"
+      },
+      "water_level": {
+        "default": "mdi:waves"
+      }
+    }
+  }
+}

homeassistant/components/aqvify/manifest.json

@@ -0,0 +1,12 @@
+{
+  "domain": "aqvify",
+  "name": "Aqvify",
+  "codeowners": ["@astrandb"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/aqvify",
+  "integration_type": "hub",
+  "iot_class": "cloud_polling",
+  "loggers": ["pyaqvify"],
+  "quality_scale": "bronze",
+  "requirements": ["pyaqvify==0.0.8"]
+}

homeassistant/components/aqvify/quality_scale.yaml

@@ -0,0 +1,69 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: |
+      No actions in this integration.
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: |
+      The integration does not provide any actions.
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: |
+      Entities of this integration do not explicitly subscribe to 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: todo
+  docs-installation-parameters: todo
+  entity-unavailable: todo
+  integration-owner: todo
+  log-when-unavailable: todo
+  parallel-updates: done
+  reauthentication-flow: todo
+  test-coverage: todo
+
+  # Gold
+  devices: todo
+  diagnostics: todo
+  discovery-update-info: todo
+  discovery: todo
+  docs-data-update: todo
+  docs-examples: todo
+  docs-known-limitations: todo
+  docs-supported-devices: todo
+  docs-supported-functions: todo
+  docs-troubleshooting: todo
+  docs-use-cases: todo
+  dynamic-devices: todo
+  entity-category: todo
+  entity-device-class: todo
+  entity-disabled-by-default: todo
+  entity-translations: todo
+  exception-translations: todo
+  icon-translations: done
+  reconfiguration-flow: todo
+  repair-issues: todo
+  stale-devices: todo
+
+  # Platinum
+  async-dependency: todo
+  inject-websession: todo
+  strict-typing: todo

homeassistant/components/aqvify/sensor.py

@@ -0,0 +1,79 @@
+"""Sensor platform for Aqvify integration."""
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import datetime
+
+from pyaqvify import AqvifyDeviceData
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+    SensorStateClass,
+    StateType,
+)
+from homeassistant.const import UnitOfLength
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import AqvifyConfigEntry
+from .entity import AqvifyBaseEntity
+
+# Coordinator is used to centralize the data updates.
+PARALLEL_UPDATES = 0
+
+
+@dataclass(frozen=True, kw_only=True)
+class AqvifySensorEntityDescription(SensorEntityDescription):
+    """Description of an Aqvify sensor entity."""
+
+    value_fn: Callable[[AqvifyDeviceData], float | int | None]
+
+
+ENTITIES: tuple[AqvifySensorEntityDescription, ...] = (
+    AqvifySensorEntityDescription(
+        key="meter_value",
+        translation_key="meter_value",
+        native_unit_of_measurement=UnitOfLength.METERS,
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.DISTANCE,
+        suggested_display_precision=2,
+        value_fn=lambda value: value.meter_value,
+    ),
+    AqvifySensorEntityDescription(
+        key="water_level",
+        translation_key="water_level",
+        native_unit_of_measurement=UnitOfLength.METERS,
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.DISTANCE,
+        suggested_display_precision=2,
+        value_fn=lambda value: value.water_level,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: AqvifyConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Aqvify sensor entities from a config entry."""
+    async_add_entities(
+        AqvifySensor(entry.runtime_data, description, device_key)
+        for description in ENTITIES
+        for device_key in entry.runtime_data.data.devices.devices
+    )
+
+
+class AqvifySensor(AqvifyBaseEntity, SensorEntity):
+    """Representation of an Aqvify sensor entity."""
+
+    entity_description: AqvifySensorEntityDescription
+
+    @property
+    def native_value(self) -> StateType | datetime | None:
+        """Return the state of the sensor."""
+        return self.entity_description.value_fn(
+            self.coordinator.data.device_data[self.device_key]
+        )

homeassistant/components/aqvify/strings.json

@@ -0,0 +1,33 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "step": {
+      "user": {
+        "data": {
+          "api_key": "API key"
+        },
+        "data_description": {
+          "api_key": "Your Aqvify API key"
+        },
+        "description": "Navigate to your [Aqvify account]({aqvify_url}), copy your API key, and paste it below."
+      }
+    }
+  },
+  "entity": {
+    "sensor": {
+      "meter_value": {
+        "name": "Meter value"
+      },
+      "water_level": {
+        "name": "Water level"
+      }
+    }
+  }
+}

homeassistant/components/assist_pipeline/pipeline.py

@@ -1816,6 +1816,11 @@ class PipelineInput:
                             await self.run.text_to_speech(tts_input)
 
         except PipelineError as err:
+            if self.run.tts_stream:
+                # Clean up TTS stream
+                self.run.tts_stream.delete()
+                self.run.tts_stream = None
+
             self.run.process_event(
                 PipelineEvent(
                     PipelineEventType.ERROR,
@@ -1885,15 +1890,17 @@ class PipelineInput:
         ):
             prepare_tasks.append(self.run.prepare_recognize_intent(self.session))
 
+        if prepare_tasks:
+            await asyncio.gather(*prepare_tasks)
+
+        # Do TTS prepare separately so we don't create a ResultStream if the
+        # pipeline is invalid.
         if (
             start_stage_index
             <= PIPELINE_STAGE_ORDER.index(PipelineStage.TTS)
             <= end_stage_index
         ):
-            prepare_tasks.append(self.run.prepare_text_to_speech())
-
-        if prepare_tasks:
-            await asyncio.gather(*prepare_tasks)
+            await self.run.prepare_text_to_speech()
 
 
 class PipelinePreferred(CollectionError):

homeassistant/components/assist_satellite/__init__.py

@@ -3,8 +3,11 @@
 from dataclasses import asdict
 import logging
 from pathlib import Path
+import re
 from typing import Any
 
+from hassil.parse_expression import parse_sentence
+from hassil.parser import ParseError
 from hassil.util import (
     PUNCTUATION_END,
     PUNCTUATION_END_WORD,
@@ -164,6 +167,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
                             [cv.string],
                             has_one_non_empty_item,
                             has_no_punctuation,
+                            is_valid_sentence,
                         ),
                     }
                 ],
@@ -201,6 +205,8 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 def has_no_punctuation(value: list[str]) -> list[str]:
     """Validate result does not contain punctuation."""
     for sentence in value:
+        # Exclude {list_references} which may contain punctuation characters.
+        sentence = _remove_list_references(sentence)
         if (
             PUNCTUATION_START.search(sentence)
             or PUNCTUATION_END.search(sentence)
@@ -212,6 +218,21 @@ def has_no_punctuation(value: list[str]) -> list[str]:
     return value
 
 
+def _remove_list_references(sentence: str) -> str:
+    """Remove {list_references} from a sentence for linting."""
+    return re.sub(r"(?<!\\)\{[^{}]*\}", "", sentence)
+
+
+def is_valid_sentence(value: list[str]) -> list[str]:
+    """Validate result can be parsed by hassil."""
+    for sentence in value:
+        try:
+            parse_sentence(sentence)
+        except ParseError as err:
+            raise vol.Invalid(f"invalid sentence: {err}") from err
+    return value
+
+
 def has_one_non_empty_item(value: list[str]) -> list[str]:
     """Validate result has at least one item."""
     if len(value) < 1:

homeassistant/components/blebox/icons.json

@@ -18,6 +18,9 @@
       }
     },
     "sensor": {
+      "open_status": {
+        "default": "mdi:window-open"
+      },
       "power_consumption": {
         "default": "mdi:lightning-bolt"
       }

homeassistant/components/blebox/sensor.py

@@ -50,21 +50,25 @@ SENSOR_TYPES: tuple[BleBoxSensorEntityDescription, ...] = (
         key="pm1",
         device_class=SensorDeviceClass.PM1,
         native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
+        state_class=SensorStateClass.MEASUREMENT,
     ),
     BleBoxSensorEntityDescription(
         key="pm2_5",
         device_class=SensorDeviceClass.PM25,
         native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
+        state_class=SensorStateClass.MEASUREMENT,
     ),
     BleBoxSensorEntityDescription(
         key="pm10",
         device_class=SensorDeviceClass.PM10,
         native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
+        state_class=SensorStateClass.MEASUREMENT,
     ),
     BleBoxSensorEntityDescription(
         key="temperature",
         device_class=SensorDeviceClass.TEMPERATURE,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        state_class=SensorStateClass.MEASUREMENT,
     ),
     BleBoxSensorEntityDescription(
         key="powerConsumption",
@@ -76,62 +80,72 @@ SENSOR_TYPES: tuple[BleBoxSensorEntityDescription, ...] = (
         key="humidity",
         device_class=SensorDeviceClass.HUMIDITY,
         native_unit_of_measurement=PERCENTAGE,
+        state_class=SensorStateClass.MEASUREMENT,
     ),
     BleBoxSensorEntityDescription(
         key="wind",
         device_class=SensorDeviceClass.WIND_SPEED,
         native_unit_of_measurement=UnitOfSpeed.METERS_PER_SECOND,
+        state_class=SensorStateClass.MEASUREMENT,
     ),
     BleBoxSensorEntityDescription(
         key="illuminance",
         device_class=SensorDeviceClass.ILLUMINANCE,
         native_unit_of_measurement=LIGHT_LUX,
+        state_class=SensorStateClass.MEASUREMENT,
     ),
     BleBoxSensorEntityDescription(
         key="forwardActiveEnergy",
         device_class=SensorDeviceClass.ENERGY,
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
+        state_class=SensorStateClass.TOTAL_INCREASING,
     ),
     BleBoxSensorEntityDescription(
         key="reverseActiveEnergy",
         device_class=SensorDeviceClass.ENERGY,
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
+        state_class=SensorStateClass.TOTAL_INCREASING,
     ),
     BleBoxSensorEntityDescription(
         key="reactivePower",
         device_class=SensorDeviceClass.POWER,
         native_unit_of_measurement=UnitOfReactivePower.VOLT_AMPERE_REACTIVE,
+        state_class=SensorStateClass.MEASUREMENT,
     ),
     BleBoxSensorEntityDescription(
         key="activePower",
         device_class=SensorDeviceClass.POWER,
         native_unit_of_measurement=UnitOfPower.WATT,
+        state_class=SensorStateClass.MEASUREMENT,
     ),
     BleBoxSensorEntityDescription(
         key="apparentPower",
         device_class=SensorDeviceClass.APPARENT_POWER,
         native_unit_of_measurement=UnitOfApparentPower.VOLT_AMPERE,
+        state_class=SensorStateClass.MEASUREMENT,
     ),
     BleBoxSensorEntityDescription(
         key="voltage",
         device_class=SensorDeviceClass.VOLTAGE,
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        state_class=SensorStateClass.MEASUREMENT,
     ),
     BleBoxSensorEntityDescription(
         key="current",
         device_class=SensorDeviceClass.CURRENT,
         native_unit_of_measurement=UnitOfElectricCurrent.MILLIAMPERE,
+        state_class=SensorStateClass.MEASUREMENT,
     ),
     BleBoxSensorEntityDescription(
         key="frequency",
         device_class=SensorDeviceClass.FREQUENCY,
         native_unit_of_measurement=UnitOfFrequency.HERTZ,
+        state_class=SensorStateClass.MEASUREMENT,
     ),
     BleBoxSensorEntityDescription(
         key="openStatus",
         translation_key="open_status",
         device_class=SensorDeviceClass.ENUM,
-        icon="mdi:window-open",
         options=list(OPEN_STATUS.values()),
         value_fn=lambda v: OPEN_STATUS.get(int(v)) if v is not None else None,
     ),

homeassistant/components/bluetooth/api.py

@@ -6,6 +6,7 @@ These APIs are the only documented way to interact with the bluetooth integratio
 import asyncio
 from asyncio import Future
 from collections.abc import Callable, Iterable
+from contextlib import ExitStack
 from typing import TYPE_CHECKING, cast
 
 from bleak import BleakScanner
@@ -178,15 +179,20 @@ async def async_process_advertisements(
         if not done.done() and callback(service_info):
             done.set_result(service_info)
 
-    unload = _get_manager(hass).async_register_callback(
-        _async_discovered_device, match_dict, mode, scan_duration=timeout
-    )
+    manager = _get_manager(hass)
+
+    with ExitStack() as stack:
+        unload = manager.async_register_callback(
+            _async_discovered_device, match_dict, mode
+        )
+        stack.callback(unload)
+
+        if mode == BluetoothScanningMode.ACTIVE:
+            task = hass.async_create_task(manager.async_request_active_scan(timeout))
+            stack.callback(task.cancel)
 
-    try:
         async with asyncio.timeout(timeout):
             return await done
-    finally:
-        unload()
 
 
 @hass_callback

homeassistant/components/bluetooth/manifest.json

@@ -21,6 +21,6 @@
     "bluetooth-auto-recovery==1.6.4",
     "bluetooth-data-tools==1.29.18",
     "dbus-fast==5.0.16",
-    "habluetooth==6.8.1"
+    "habluetooth==6.8.3"
   ]
 }

homeassistant/components/brands/__init__.py

@@ -1,18 +1,19 @@
 """The Brands integration."""
 
 from collections import deque
+from collections.abc import Container, Mapping
 from http import HTTPStatus
 import logging
 from pathlib import Path
 from random import SystemRandom
 import time
-from typing import Any, Final
+from typing import Any, Final, override
 
-from aiohttp import ClientError, hdrs, web
+from aiohttp import ClientError, web
 import voluptuous as vol
 
 from homeassistant.components import websocket_api
-from homeassistant.components.http import KEY_AUTHENTICATED, HomeAssistantView
+from homeassistant.components.http import HomeAssistantView
 from homeassistant.core import HomeAssistant, callback, valid_domain
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
@@ -108,23 +109,18 @@ def _read_brand_file(brand_dir: Path, image: str) -> bytes | None:
 class _BrandsBaseView(HomeAssistantView):
     """Base view for serving brand images."""
 
-    requires_auth = False
+    use_query_token_for_auth = True
 
     def __init__(self, hass: HomeAssistant) -> None:
         """Initialize the view."""
         self._hass = hass
         self._cache_dir = Path(hass.config.cache_path(DOMAIN))
 
-    def _authenticate(self, request: web.Request) -> None:
-        """Authenticate the request using Bearer token or query token."""
-        access_tokens: deque[str] = self._hass.data[DOMAIN]
-        authenticated = (
-            request[KEY_AUTHENTICATED] or request.query.get("token") in access_tokens
-        )
-        if not authenticated:
-            if hdrs.AUTHORIZATION in request.headers:
-                raise web.HTTPUnauthorized
-            raise web.HTTPForbidden
+    @callback
+    @override
+    def get_valid_auth_tokens(self, match_info: Mapping[str, str]) -> Container[str]:
+        """Return valid auth tokens, which can be used for query token authentication."""
+        return self._hass.data[DOMAIN]
 
     async def _serve_from_custom_integration(
         self,
@@ -240,8 +236,6 @@ class BrandsIntegrationView(_BrandsBaseView):
         image: str,
     ) -> web.Response:
         """Handle GET request for an integration brand image."""
-        self._authenticate(request)
-
         if not valid_domain(domain) or image not in ALLOWED_IMAGES:
             return web.Response(status=HTTPStatus.NOT_FOUND)
 
@@ -274,8 +268,6 @@ class BrandsHardwareView(_BrandsBaseView):
         image: str,
     ) -> web.Response:
         """Handle GET request for a hardware brand image."""
-        self._authenticate(request)
-
         if not CATEGORY_RE.match(category):
             return web.Response(status=HTTPStatus.NOT_FOUND)
         # Hardware images have dynamic names like "manufacturer_model.png"

homeassistant/components/bsblan/__init__.py

@@ -230,10 +230,6 @@ async def async_migrate_entry(hass: HomeAssistant, entry: BSBLanConfigEntry) ->
         entry.minor_version,
     )
 
-    if entry.version > 1:
-        # Downgraded from a future version; cannot migrate.
-        return False
-
     # 1.1 -> 1.2: Add CONF_HEATING_CIRCUITS. Attempt to discover available
     # heating circuits from the device; fall back to [1] (pre-multi-circuit
     # default) if the device is unreachable or the endpoint is unsupported.

homeassistant/components/cambridge_audio/manifest.json

@@ -8,6 +8,6 @@
   "iot_class": "local_push",
   "loggers": ["aiostreammagic"],
   "quality_scale": "platinum",
-  "requirements": ["aiostreammagic==2.13.1"],
+  "requirements": ["aiostreammagic==2.13.2"],
   "zeroconf": ["_stream-magic._tcp.local.", "_smoip._tcp.local."]
 }

homeassistant/components/camera/__init__.py

@@ -2,7 +2,7 @@
 
 import asyncio
 import collections
-from collections.abc import Awaitable, Callable, Coroutine
+from collections.abc import Awaitable, Callable, Container, Coroutine, Mapping
 from contextlib import suppress
 from dataclasses import asdict, dataclass
 from datetime import datetime, timedelta
@@ -12,16 +12,16 @@ import logging
 import os
 from random import SystemRandom
 import time
-from typing import Any, Final, final
+from typing import Any, Final, final, override
 
-from aiohttp import hdrs, web
+from aiohttp import web
 import attr
 from propcache.api import cached_property, under_cached_property
 import voluptuous as vol
 from webrtc_models import RTCIceCandidateInit
 
 from homeassistant.components import websocket_api
-from homeassistant.components.http import KEY_AUTHENTICATED, HomeAssistantView
+from homeassistant.components.http import HomeAssistantView
 from homeassistant.components.media_player import (
     ATTR_MEDIA_CONTENT_ID,
     ATTR_MEDIA_CONTENT_TYPE,
@@ -776,30 +776,26 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
 class CameraView(HomeAssistantView):
     """Base CameraView."""
 
-    requires_auth = False
+    use_query_token_for_auth = True
 
     def __init__(self, component: EntityComponent[Camera]) -> None:
         """Initialize a basic camera view."""
         self.component = component
 
+    @callback
+    @override
+    def get_valid_auth_tokens(self, match_info: Mapping[str, str]) -> Container[str]:
+        """Return valid auth tokens, which can be used for query token authentication."""
+        if (camera := self.component.get_entity(match_info["entity_id"])) is None:
+            return ()
+
+        return camera.access_tokens
+
     async def get(self, request: web.Request, entity_id: str) -> web.StreamResponse:
         """Start a GET request."""
         if (camera := self.component.get_entity(entity_id)) is None:
             raise web.HTTPNotFound
 
-        authenticated = (
-            request[KEY_AUTHENTICATED]
-            or request.query.get("token") in camera.access_tokens
-        )
-
-        if not authenticated:
-            # Attempt with invalid bearer token, raise unauthorized
-            # so ban middleware can handle it.
-            if hdrs.AUTHORIZATION in request.headers:
-                raise web.HTTPUnauthorized
-            # Invalid sigAuth or camera access token
-            raise web.HTTPForbidden
-
         if not camera.is_on:
             _LOGGER.debug("Camera is off")
             raise web.HTTPServiceUnavailable

homeassistant/components/chacon_dio/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/chacon_dio",
   "iot_class": "cloud_push",
   "loggers": ["dio_chacon_api"],
-  "requirements": ["dio-chacon-wifi-api==1.2.2"]
+  "requirements": ["dio-chacon-wifi-api==1.3.0"]
 }

homeassistant/components/comelit/__init__.py

@@ -87,10 +87,6 @@ async def async_migrate_entry(
 ) -> bool:
     """Migrate old entry."""
 
-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
     if config_entry.version == 1 and config_entry.minor_version == 1:
         device_registry = dr.async_get(hass)
 

homeassistant/components/conversation/trigger.py

@@ -1,8 +1,11 @@
 """Offer sentence based automation rules."""
 
 from collections.abc import Awaitable, Callable
+import re
 from typing import Any
 
+from hassil.parse_expression import parse_sentence
+from hassil.parser import ParseError
 from hassil.recognize import RecognizeResult
 from hassil.util import (
     PUNCTUATION_END,
@@ -31,6 +34,8 @@ TRIGGER_CALLBACK_TYPE = Callable[
 def has_no_punctuation(value: list[str]) -> list[str]:
     """Validate result does not contain punctuation."""
     for sentence in value:
+        # Exclude {list_references} which may contain punctuation characters.
+        sentence = _remove_list_references(sentence)
         if (
             PUNCTUATION_START.search(sentence)
             or PUNCTUATION_END.search(sentence)
@@ -42,6 +47,21 @@ def has_no_punctuation(value: list[str]) -> list[str]:
     return value
 
 
+def _remove_list_references(sentence: str) -> str:
+    """Remove {list_references} from a sentence for linting."""
+    return re.sub(r"(?<!\\)\{[^{}]*\}", "", sentence)
+
+
+def is_valid_sentence(value: list[str]) -> list[str]:
+    """Validate result can be parsed by hassil."""
+    for sentence in value:
+        try:
+            parse_sentence(sentence)
+        except ParseError as err:
+            raise vol.Invalid(f"invalid sentence: {err}") from err
+    return value
+
+
 def has_one_non_empty_item(value: list[str]) -> list[str]:
     """Validate result has at least one item."""
     if len(value) < 1:
@@ -58,7 +78,11 @@ TRIGGER_SCHEMA = cv.TRIGGER_BASE_SCHEMA.extend(
     {
         vol.Required(CONF_PLATFORM): DOMAIN,
         vol.Required(CONF_COMMAND): vol.All(
-            cv.ensure_list, [cv.string], has_one_non_empty_item, has_no_punctuation
+            cv.ensure_list,
+            [cv.string],
+            has_one_non_empty_item,
+            has_no_punctuation,
+            is_valid_sentence,
         ),
     }
 )

homeassistant/components/daikin/manifest.json

@@ -7,6 +7,6 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["pydaikin"],
-  "requirements": ["pydaikin==2.17.2"],
+  "requirements": ["pydaikin==2.18.1"],
   "zeroconf": ["_dkapi._tcp.local."]
 }

homeassistant/components/data_grand_lyon/config_flow.py

@@ -5,7 +5,7 @@ import logging
 from typing import Any
 
 from aiohttp import ClientError, ClientResponseError
-from data_grand_lyon_ha import DataGrandLyonClient
+from data_grand_lyon_ha import DataGrandLyonClient, TclStop, find_tcl_stop_by_id
 import voluptuous as vol
 
 from homeassistant.config_entries import (
@@ -18,6 +18,12 @@ from homeassistant.config_entries import (
 from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import callback
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.selector import (
+    SelectOptionDict,
+    SelectSelector,
+    SelectSelectorConfig,
+    SelectSelectorMode,
+)
 
 from .const import (
     CONF_LINE,
@@ -43,13 +49,6 @@ STEP_RECONFIGURE_SCHEMA = vol.Schema(
     }
 )
 
-STEP_STOP_DATA_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_LINE): str,
-        vol.Required(CONF_STOP_ID): vol.Coerce(int),
-    }
-)
-
 STEP_VELOV_STATION_DATA_SCHEMA = vol.Schema(
     {
         vol.Required(CONF_STATION_ID): vol.Coerce(int),
@@ -179,33 +178,126 @@ class DataGrandLyonConfigFlow(ConfigFlow, domain=DOMAIN):
 class StopSubentryFlowHandler(ConfigSubentryFlow):
     """Handle a subentry flow for adding a Data Grand Lyon stop."""
 
+    def __init__(self) -> None:
+        """Initialize the flow."""
+        self._stops: list[TclStop] = []
+        self._selected_stop: TclStop | None = None
+        self._selected_stop_id: int | None = None
+
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> SubentryFlowResult:
-        """Handle the user step to add a new stop."""
-        entry = self._get_entry()
+        """Pick a stop from the list fetched from the API, or enter one manually."""
+        if not self._stops:
+            if error := await self._async_load_stops():
+                return self.async_abort(reason=error)
 
+        errors: dict[str, str] = {}
         if user_input is not None:
-            line = user_input[CONF_LINE]
-            stop_id = user_input[CONF_STOP_ID]
-            unique_id = f"{line}_{stop_id}"
+            try:
+                stop_id = int(user_input[CONF_STOP_ID])
+            except ValueError:
+                errors[CONF_STOP_ID] = "invalid_stop_id"
+            else:
+                self._selected_stop_id = stop_id
+                self._selected_stop = find_tcl_stop_by_id(self._stops, stop_id)
+                return await self.async_step_pick_line()
 
-            for subentry in entry.subentries.values():
-                if subentry.unique_id == unique_id:
-                    return self.async_abort(reason="already_configured")
-
-            name = f"{line} - Stop {stop_id}"
-            return self.async_create_entry(
-                title=name,
-                data={CONF_LINE: line, CONF_STOP_ID: stop_id},
-                unique_id=unique_id,
+        options = [
+            SelectOptionDict(value=str(stop.id), label=_stop_label(stop))
+            for stop in sorted(
+                self._stops, key=lambda s: (s.nom, s.commune or "", s.id or 0)
             )
-
+        ]
+        schema = vol.Schema(
+            {
+                vol.Required(CONF_STOP_ID): SelectSelector(
+                    SelectSelectorConfig(
+                        options=options,
+                        mode=SelectSelectorMode.DROPDOWN,
+                        sort=False,
+                        custom_value=True,
+                    )
+                )
+            }
+        )
         return self.async_show_form(
             step_id="user",
-            data_schema=STEP_STOP_DATA_SCHEMA,
+            data_schema=schema,
+            errors=errors,
         )
 
+    async def async_step_pick_line(
+        self, user_input: dict[str, Any] | None = None
+    ) -> SubentryFlowResult:
+        """Pick a line from the selected stop's desserte, or enter one manually."""
+        assert self._selected_stop_id is not None
+        if user_input is not None:
+            return self._create_stop(
+                line=user_input[CONF_LINE], stop_id=self._selected_stop_id
+            )
+
+        options = self._selected_stop.desserte if self._selected_stop else []
+        schema = vol.Schema(
+            {
+                vol.Required(CONF_LINE): SelectSelector(
+                    SelectSelectorConfig(
+                        options=options,
+                        mode=SelectSelectorMode.DROPDOWN,
+                        custom_value=True,
+                    )
+                )
+            }
+        )
+        return self.async_show_form(step_id="pick_line", data_schema=schema)
+
+    async def _async_load_stops(self) -> str | None:
+        """Fetch TCL stops from the API, returning an error key on failure."""
+        entry = self._get_entry()
+        session = async_get_clientsession(self.hass)
+        client = DataGrandLyonClient(
+            session=session,
+            username=entry.data[CONF_USERNAME],
+            password=entry.data[CONF_PASSWORD],
+        )
+        try:
+            self._stops = await client.get_tcl_stops()
+        except ClientResponseError as err:
+            if err.status in (401, 403):
+                return "invalid_auth"
+            return "cannot_connect"
+        except ClientError, TimeoutError:
+            return "cannot_connect"
+        except Exception:
+            _LOGGER.exception("Unexpected error fetching Data Grand Lyon TCL stops")
+            return "unknown"
+        return None
+
+    def _create_stop(self, line: str, stop_id: int) -> SubentryFlowResult:
+        """Create the stop subentry, aborting on duplicate."""
+        entry = self._get_entry()
+        unique_id = f"{line}_{stop_id}"
+        for subentry in entry.subentries.values():
+            if subentry.unique_id == unique_id:
+                return self.async_abort(reason="already_configured")
+
+        return self.async_create_entry(
+            title=f"{line} - Stop {stop_id}",
+            data={CONF_LINE: line, CONF_STOP_ID: stop_id},
+            unique_id=unique_id,
+        )
+
+
+def _stop_label(stop: TclStop) -> str:
+    label = stop.nom
+    # variable extracted to please codespell.
+    address = stop.adresse  # codespell:ignore adresse
+    if address or stop.commune:
+        label += " (" + ", ".join(filter(None, [address, stop.commune])) + ")"
+    label += f" - {stop.id}"
+
+    return label
+
 
 class VelovStationSubentryFlowHandler(ConfigSubentryFlow):
     """Handle a subentry flow for adding a Vélo'v station."""

homeassistant/components/data_grand_lyon/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_polling",
   "quality_scale": "platinum",
-  "requirements": ["data-grand-lyon-ha==0.7.0"]
+  "requirements": ["data-grand-lyon-ha==0.8.0"]
 }

homeassistant/components/data_grand_lyon/strings.json

@@ -46,17 +46,30 @@
   "config_subentries": {
     "stop": {
       "abort": {
-        "already_configured": "[%key:common::config_flow::abort::already_configured_service%]"
+        "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
+        "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+        "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+        "unknown": "[%key:common::config_flow::error::unknown%]"
       },
       "entry_type": "Transit stop",
+      "error": {
+        "invalid_stop_id": "Stop ID must be a number."
+      },
       "initiate_flow": {
         "user": "Add transit stop"
       },
       "step": {
+        "pick_line": {
+          "data": {
+            "line": "Line"
+          }
+        },
         "user": {
           "data": {
-            "line": "Line",
-            "stop_id": "Stop ID"
+            "stop_id": "Stop"
+          },
+          "data_description": {
+            "stop_id": "Search by stop name, address or city, or enter a stop ID directly."
           }
         }
       }

homeassistant/components/demo/binary_sensor.py

@@ -5,6 +5,7 @@ from homeassistant.components.binary_sensor import (
     BinarySensorEntity,
 )
 from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -27,7 +28,19 @@ async def async_setup_entry(
                 BinarySensorDeviceClass.MOISTURE,
             ),
             DemoBinarySensor(
-                "binary_2", "Movement Backyard", True, BinarySensorDeviceClass.MOTION
+                "binary_2",
+                "Movement Backyard",
+                True,
+                BinarySensorDeviceClass.MOTION,
+            ),
+            DemoBinarySensor(
+                "binary_3",
+                "Outside Temperature",
+                False,
+                BinarySensorDeviceClass.BATTERY_CHARGING,
+                device_id="sensor_1",
+                entity_category=EntityCategory.DIAGNOSTIC,
+                entity_name="Battery Charging",
             ),
         ]
     )
@@ -46,6 +59,9 @@ class DemoBinarySensor(BinarySensorEntity):
         device_name: str,
         state: bool,
         device_class: BinarySensorDeviceClass,
+        device_id: str | None = None,
+        entity_category: EntityCategory | None = None,
+        entity_name: str | None = None,
     ) -> None:
         """Initialize the demo sensor."""
         self._unique_id = unique_id
@@ -54,10 +70,12 @@ class DemoBinarySensor(BinarySensorEntity):
         self._attr_device_info = DeviceInfo(
             identifiers={
                 # Serial numbers are unique identifiers within a specific domain
-                (DOMAIN, self.unique_id)
+                (DOMAIN, device_id or unique_id)
             },
             name=device_name,
         )
+        self._attr_entity_category = entity_category
+        self._attr_name = entity_name
 
     @property
     def unique_id(self) -> str:

homeassistant/components/derivative/__init__.py

@@ -54,10 +54,6 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
         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:
         if config_entry.minor_version < 2:
             new_options = {**config_entry.options}

homeassistant/components/device_tracker/__init__.py

@@ -22,6 +22,7 @@ from .const import (  # noqa: F401
     ATTR_LOCATION_NAME,
     ATTR_MAC,
     ATTR_SOURCE_TYPE,
+    ATTR_TRACKING_TYPE,
     CONF_ASSOCIATED_ZONE,
     CONF_CONSIDER_HOME,
     CONF_NEW_DEVICE_DEFAULTS,
@@ -36,6 +37,7 @@ from .const import (  # noqa: F401
     PLATFORM_TYPE_LEGACY,
     SCAN_INTERVAL,
     SourceType,
+    TrackingType,
 )
 from .entity import (  # noqa: F401
     BaseScannerEntity,

homeassistant/components/device_tracker/const.py

@@ -25,6 +25,18 @@ class SourceType(StrEnum):
     BLUETOOTH_LE = "bluetooth_le"
 
 
+class TrackingType(StrEnum):
+    """Tracking type for device trackers.
+
+    Describes how the tracker determines presence: by the device's geographic
+    position (e.g. GPS) or by its connection to a known endpoint (e.g. a router
+    or beacon associated with a zone).
+    """
+
+    CONNECTION = "connection"
+    POSITION = "position"
+
+
 CONF_SCAN_INTERVAL: Final = "interval_seconds"
 SCAN_INTERVAL: Final = timedelta(seconds=12)
 
@@ -47,6 +59,7 @@ ATTR_IN_ZONES: Final = "in_zones"
 ATTR_LOCATION_NAME: Final = "location_name"
 ATTR_MAC: Final = "mac"
 ATTR_SOURCE_TYPE: Final = "source_type"
+ATTR_TRACKING_TYPE: Final = "tracking_type"
 ATTR_CONSIDER_HOME: Final = "consider_home"
 ATTR_IP: Final = "ip"
 

homeassistant/components/device_tracker/entity.py

@@ -48,11 +48,13 @@ from .const import (
     ATTR_IP,
     ATTR_MAC,
     ATTR_SOURCE_TYPE,
+    ATTR_TRACKING_TYPE,
     CONF_ASSOCIATED_ZONE,
     CONNECTED_DEVICE_REGISTERED,
     DOMAIN,
     LOGGER,
     SourceType,
+    TrackingType,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -238,6 +240,9 @@ class TrackerEntity(
     """Base class for a tracked device."""
 
     entity_description: TrackerEntityDescription
+    _attr_capability_attributes: dict[str, Any] = {
+        ATTR_TRACKING_TYPE: TrackingType.POSITION
+    }
     _attr_in_zones: list[str] | None = None
     _attr_latitude: float | None = None
     _attr_location_accuracy: float = 0
@@ -411,6 +416,9 @@ class BaseScannerEntity(BaseTrackerEntity):
     addresses being used to identify the device.
     """
 
+    _attr_capability_attributes: dict[str, Any] = {
+        ATTR_TRACKING_TYPE: TrackingType.CONNECTION
+    }
     _scanner_option_associated_zone: str = zone.ENTITY_ID_HOME
     _scanner_option_associated_zone_unsub: CALLBACK_TYPE | None = None
 

homeassistant/components/device_tracker/strings.json

@@ -40,6 +40,13 @@
             "gps": "GPS",
             "router": "Router"
           }
+        },
+        "tracking_type": {
+          "name": "Tracking type",
+          "state": {
+            "connection": "Connection",
+            "position": "Position"
+          }
         }
       }
     }

homeassistant/components/dnsip/__init__.py

@@ -51,7 +51,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: DnsIPConfigEntry) -> boo
             tcp_port=entry.options[CONF_PORT],
             udp_port=entry.options[CONF_PORT],
         )
-        queries.append(resolver_ipv4.query(hostname, "A"))
+        queries.append(resolver_ipv4.query_dns(hostname, "A"))
 
     if entry.data[CONF_IPV6]:
         resolver_ipv6 = aiodns.DNSResolver(
@@ -59,7 +59,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: DnsIPConfigEntry) -> boo
             tcp_port=entry.options[CONF_PORT_IPV6],
             udp_port=entry.options[CONF_PORT_IPV6],
         )
-        queries.append(resolver_ipv6.query(hostname, "AAAA"))
+        queries.append(resolver_ipv6.query_dns(hostname, "AAAA"))
 
     async def _close_resolvers() -> None:
         if resolver_ipv4 is not None:
@@ -111,10 +111,6 @@ async def async_migrate_entry(
 ) -> bool:
     """Migrate old entry to a newer version."""
 
-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
     if config_entry.version < 2 and config_entry.minor_version < 2:
         _LOGGER.debug(
             "Migrating configuration from version %s.%s",

homeassistant/components/dnsip/config_flow.py

@@ -72,7 +72,7 @@ async def async_validate_hostname(
             _resolver = aiodns.DNSResolver(
                 nameservers=[resolver], udp_port=port, tcp_port=port
             )
-            result = bool(await _resolver.query(hostname, qtype))
+            result = bool(await _resolver.query_dns(hostname, qtype))
 
         return result
 

homeassistant/components/dnsip/sensor.py

@@ -8,6 +8,7 @@ from typing import TYPE_CHECKING, Literal
 
 import aiodns
 from aiodns.error import DNSError
+import pycares
 
 from homeassistant.components.sensor import SensorEntity
 from homeassistant.const import CONF_NAME, CONF_PORT
@@ -148,7 +149,7 @@ class WanIpSensor(SensorEntity):
         response = None
         try:
             async with asyncio.timeout(10):
-                response = await self._resolver.query(self.hostname, self.querytype)
+                response = await self._resolver.query_dns(self.hostname, self.querytype)
         except TimeoutError as err:
             _LOGGER.debug("Timeout while resolving host: %s", err)
             await self._resolver.close()
@@ -157,9 +158,19 @@ class WanIpSensor(SensorEntity):
             await self._resolver.close()
 
         if response:
-            sorted_ips = sort_ips(
-                [res.host for res in response], querytype=self.querytype
-            )
+            if TYPE_CHECKING:
+                assert all(
+                    isinstance(res.data, (pycares.ARecordData, pycares.AAAARecordData))
+                    for res in response.answer
+                )
+            _ips = []
+            for res in response.answer:
+                if TYPE_CHECKING:
+                    assert isinstance(
+                        res.data, (pycares.ARecordData, pycares.AAAARecordData)
+                    )
+                _ips.append(res.data.addr)
+            sorted_ips = sort_ips(_ips, querytype=self.querytype)
             self._attr_native_value = sorted_ips[0]
             self._attr_extra_state_attributes["ip_addresses"] = sorted_ips
             self._attr_available = True

homeassistant/components/dsmr/config_flow.py

@@ -13,7 +13,6 @@ from dsmr_parser.clients.rfxtrx_protocol import (
 from dsmr_parser.objects import DSMRObject
 import voluptuous as vol
 
-from homeassistant.components import usb
 from homeassistant.config_entries import (
     ConfigEntry,
     ConfigFlow,
@@ -23,6 +22,7 @@ from homeassistant.config_entries import (
 from homeassistant.const import CONF_HOST, CONF_PORT, CONF_PROTOCOL, CONF_TYPE
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.selector import SerialPortSelector
 
 from .const import (
     CONF_DSMR_VERSION,
@@ -37,8 +37,6 @@ from .const import (
     RFXTRX_DSMR_PROTOCOL,
 )
 
-CONF_MANUAL_PATH = "Enter Manually"
-
 
 class DSMRConnection:
     """Test the connection to DSMR and receive telegram to read serial ids."""
@@ -165,8 +163,6 @@ class DSMRFlowHandler(ConfigFlow, domain=DOMAIN):
 
     VERSION = 1
 
-    _dsmr_version: str | None = None
-
     @staticmethod
     @callback
     def async_get_options_flow(
@@ -222,34 +218,13 @@ class DSMRFlowHandler(ConfigFlow, domain=DOMAIN):
         """Step when setting up serial configuration."""
         errors: dict[str, str] = {}
         if user_input is not None:
-            user_selection = user_input[CONF_PORT]
-            if user_selection == CONF_MANUAL_PATH:
-                self._dsmr_version = user_input[CONF_DSMR_VERSION]
-                return await self.async_step_setup_serial_manual_path()
-
-            dev_path = user_selection
-
-            validate_data = {
-                CONF_PORT: dev_path,
-                CONF_DSMR_VERSION: user_input[CONF_DSMR_VERSION],
-            }
-
-            data = await self.async_validate_dsmr(validate_data, errors)
+            data = await self.async_validate_dsmr(user_input, errors)
             if not errors:
                 return self.async_create_entry(title=data[CONF_PORT], data=data)
 
-        ports = await usb.async_scan_serial_ports(self.hass)
-        list_of_ports = {
-            port.device: f"{port.device} - {port.description or 'n/a'}"
-            f", s/n: {port.serial_number or 'n/a'}"
-            + (f" - {port.manufacturer}" if port.manufacturer else "")
-            for port in ports
-        }
-        list_of_ports[CONF_MANUAL_PATH] = CONF_MANUAL_PATH
-
         schema = vol.Schema(
             {
-                vol.Required(CONF_PORT): vol.In(list_of_ports),
+                vol.Required(CONF_PORT): SerialPortSelector(),
                 vol.Required(CONF_DSMR_VERSION): vol.In(DSMR_VERSIONS),
             }
         )
@@ -259,27 +234,6 @@ class DSMRFlowHandler(ConfigFlow, domain=DOMAIN):
             errors=errors,
         )
 
-    async def async_step_setup_serial_manual_path(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Select path manually."""
-        if user_input is not None:
-            validate_data = {
-                CONF_PORT: user_input[CONF_PORT],
-                CONF_DSMR_VERSION: self._dsmr_version,
-            }
-
-            errors: dict[str, str] = {}
-            data = await self.async_validate_dsmr(validate_data, errors)
-            if not errors:
-                return self.async_create_entry(title=data[CONF_PORT], data=data)
-
-        schema = vol.Schema({vol.Required(CONF_PORT): str})
-        return self.async_show_form(
-            step_id="setup_serial_manual_path",
-            data_schema=schema,
-        )
-
     async def async_validate_dsmr(
         self, input_data: dict[str, Any], errors: dict[str, str]
     ) -> dict[str, Any]:

homeassistant/components/dsmr/strings.json

@@ -26,12 +26,6 @@
         },
         "title": "[%key:common::config_flow::data::device%]"
       },
-      "setup_serial_manual_path": {
-        "data": {
-          "port": "[%key:common::config_flow::data::usb_path%]"
-        },
-        "title": "[%key:common::config_flow::data::path%]"
-      },
       "user": {
         "data": {
           "type": "Connection type"

homeassistant/components/duco/const.py

@@ -7,3 +7,4 @@ from homeassistant.const import Platform
 DOMAIN = "duco"
 PLATFORMS = [Platform.FAN, Platform.SENSOR]
 SCAN_INTERVAL = timedelta(seconds=10)
+BOX_NODE_ID = 1

homeassistant/components/duco/diagnostics.py

@@ -3,7 +3,7 @@
 from dataclasses import asdict
 from typing import Any
 
-from duco_connectivity.exceptions import DucoConnectionError
+from duco_connectivity.exceptions import DucoConnectionError, DucoError
 
 from homeassistant.components.diagnostics import async_redact_data
 from homeassistant.const import CONF_HOST
@@ -52,6 +52,12 @@ async def async_get_config_entry_diagnostics(
             translation_domain=DOMAIN,
             translation_key="connection_error",
         ) from err
+    except DucoError as err:
+        raise HomeAssistantError(
+            translation_domain=DOMAIN,
+            translation_key="api_error",
+            translation_placeholders={"error": repr(err)},
+        ) from err
 
     api_info: dict[str, Any] = {"public_api_version": api_info_obj.public_api_version}
     if api_info_obj.reported_api_version is not None:

homeassistant/components/duco/entity.py

@@ -1,6 +1,6 @@
 """Base entity for the Duco integration."""
 
-from duco_connectivity.models import Node
+from duco_connectivity.models import Node, NodeType
 
 from homeassistant.const import ATTR_VIA_DEVICE
 from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, DeviceInfo
@@ -25,7 +25,7 @@ class DucoEntity(CoordinatorEntity[DucoCoordinator]):
             identifiers={(DOMAIN, f"{mac}_{node.node_id}")},
             manufacturer="Duco",
             model=coordinator.board_info.box_name
-            if node.general.node_type == "BOX"
+            if node.general.node_type == NodeType.BOX
             else node.general.node_type,
             name=node.general.name or f"Node {node.node_id}",
         )
@@ -34,7 +34,7 @@ class DucoEntity(CoordinatorEntity[DucoCoordinator]):
                 "connections": {(CONNECTION_NETWORK_MAC, mac)},
                 "serial_number": coordinator.board_info.serial_board_box,
             }
-            if node.general.node_type == "BOX"
+            if node.general.node_type == NodeType.BOX
             else {ATTR_VIA_DEVICE: (DOMAIN, f"{mac}_1")}
         )
         self._attr_device_info = device_info

homeassistant/components/duco/sensor.py

@@ -24,7 +24,7 @@ from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import dt as dt_util
 
-from .const import DOMAIN
+from .const import BOX_NODE_ID, DOMAIN
 from .coordinator import DucoConfigEntry, DucoCoordinator
 from .entity import DucoEntity
 
@@ -158,7 +158,13 @@ async def async_setup_entry(
         # The firmware removes deregistered RF/wired nodes automatically.
         # BSRH box sensors that are physically unplugged from the PCB are
         # not deregistered by the firmware and will never appear here as stale.
-        stale_node_ids = known_nodes - coordinator.data.nodes.keys()
+        # The BOX node can transiently disappear from the API response, so keep
+        # node 1 to avoid removing the main controller device.
+        stale_node_ids = {
+            node_id
+            for node_id in known_nodes - coordinator.data.nodes.keys()
+            if node_id != BOX_NODE_ID
+        }
         if stale_node_ids:
             device_reg = dr.async_get(hass)
             mac = entry.unique_id

homeassistant/components/duco/strings.json

@@ -59,7 +59,7 @@
         "name": "Target flow level"
       },
       "time_state_end": {
-        "name": "Mode end time"
+        "name": "State end time"
       },
       "ventilation_state": {
         "name": "Ventilation state",

homeassistant/components/dwd_weather_warnings/sensor.py

@@ -9,7 +9,6 @@ Warnungen vor markantem Wetter (Stufe 2)  # codespell:ignore vor
 Wetterwarnungen (Stufe 1)
 """
 
-from datetime import UTC, datetime
 from typing import Any
 
 from homeassistant.components.sensor import SensorEntity, SensorEntityDescription
@@ -17,6 +16,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
+from homeassistant.util import dt as dt_util
 
 from .const import (
     ADVANCE_WARNING_SENSOR,
@@ -100,7 +100,7 @@ class DwdWeatherWarningsSensor(
         if warnings is None:
             return []
 
-        now = datetime.now(UTC)  # pylint: disable=home-assistant-enforce-utcnow
+        now = dt_util.utcnow()
         return [warning for warning in warnings if warning[API_ATTR_WARNING_END] > now]
 
     @property

homeassistant/components/elevenlabs/__init__.py

@@ -98,10 +98,6 @@ async def async_migrate_entry(
         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}
 

homeassistant/components/energyid/__init__.py

@@ -26,6 +26,7 @@ from homeassistant.helpers.event import (
     async_track_state_change_event,
     async_track_time_interval,
 )
+from homeassistant.util import dt as dt_util
 
 from .const import (
     CONF_DEVICE_NAME,
@@ -221,8 +222,7 @@ def update_listeners(hass: HomeAssistant, entry: EnergyIDConfigEntry) -> None:
             ):
                 try:
                     value = float(current_state.state)
-                    # pylint: disable-next=home-assistant-enforce-utcnow
-                    timestamp = current_state.last_updated or dt.datetime.now(dt.UTC)
+                    timestamp = current_state.last_updated or dt_util.utcnow()
                     client.get_or_create_sensor(energyid_key).update(value, timestamp)
                 except ValueError, TypeError:
                     _LOGGER.debug(

homeassistant/components/environment_canada/__init__.py

@@ -8,9 +8,12 @@ from env_canada import ECAirQuality, ECMap, ECWeather
 from homeassistant.const import CONF_LANGUAGE, CONF_LATITUDE, CONF_LONGITUDE, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.typing import ConfigType
 
-from .const import CONF_STATION
+from .const import CONF_STATION, DOMAIN
 from .coordinator import ECConfigEntry, ECDataUpdateCoordinator, ECRuntimeData
+from .services import async_setup_services
 
 DEFAULT_RADAR_UPDATE_INTERVAL = timedelta(minutes=5)
 DEFAULT_WEATHER_UPDATE_INTERVAL = timedelta(minutes=5)
@@ -19,6 +22,14 @@ PLATFORMS = [Platform.CAMERA, Platform.SENSOR, Platform.WEATHER]
 
 _LOGGER = logging.getLogger(__name__)
 
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the Environment Canada services."""
+    async_setup_services(hass)
+    return True
+
 
 async def async_setup_entry(hass: HomeAssistant, config_entry: ECConfigEntry) -> bool:
     """Set up EC as config entry."""

homeassistant/components/environment_canada/icons.json

@@ -19,6 +19,9 @@
     }
   },
   "services": {
+    "get_alerts": {
+      "service": "mdi:bell-alert"
+    },
     "get_forecasts": {
       "service": "mdi:weather-cloudy-clock"
     },

homeassistant/components/environment_canada/services.py

@@ -0,0 +1,56 @@
+"""Define services for the Environment Canada integration."""
+
+from typing import Any
+
+from env_canada import ECWeather
+import voluptuous as vol
+
+from homeassistant.const import ATTR_CONFIG_ENTRY_ID
+from homeassistant.core import HomeAssistant, ServiceCall, SupportsResponse, callback
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import config_validation as cv, service
+
+from .const import DOMAIN
+
+SERVICE_GET_ALERTS = "get_alerts"
+SERVICE_GET_ALERTS_SCHEMA = vol.Schema({vol.Required(ATTR_CONFIG_ENTRY_ID): cv.string})
+
+SNAKE_MAPPING = {
+    "alertColourLevel": "alert_colour_level",
+    "expiryTime": "expiry_time",
+}
+
+
+async def _async_get_alerts(call: ServiceCall) -> dict[str, Any]:
+    """Return the active alerts."""
+    entry = service.async_get_config_entry(
+        call.hass, DOMAIN, call.data[ATTR_CONFIG_ENTRY_ID]
+    )
+
+    ec: ECWeather | None = entry.runtime_data.weather_coordinator.ec_data
+    if ec is None:
+        raise HomeAssistantError(
+            translation_domain=DOMAIN,
+            translation_key="not_connected",
+        )
+
+    data: dict[str, Any] = ec.alerts
+    return {
+        k: [
+            {SNAKE_MAPPING.get(ik, ik): iv for ik, iv in item.items()}
+            for item in v["value"]
+        ]
+        for k, v in data.items()
+    }
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Set up the services for the Environment Canada integration."""
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_GET_ALERTS,
+        _async_get_alerts,
+        schema=SERVICE_GET_ALERTS_SCHEMA,
+        supports_response=SupportsResponse.ONLY,
+    )

homeassistant/components/environment_canada/services.yaml

@@ -1,3 +1,11 @@
+get_alerts:
+  fields:
+    config_entry_id:
+      required: true
+      selector:
+        config_entry:
+          integration: environment_canada
+
 get_forecasts:
   target:
     entity:

homeassistant/components/environment_canada/strings.json

@@ -112,7 +112,22 @@
       }
     }
   },
+  "exceptions": {
+    "not_connected": {
+      "message": "Environment Canada is not connected"
+    }
+  },
   "services": {
+    "get_alerts": {
+      "description": "Retrieves the alerts from the selected weather service.",
+      "fields": {
+        "config_entry_id": {
+          "description": "The Environment Canada service to retrieve alerts from.",
+          "name": "Environment Canada service"
+        }
+      },
+      "name": "Get alerts"
+    },
     "get_forecasts": {
       "description": "Retrieves the forecast from selected weather services.",
       "name": "Get forecasts"

homeassistant/components/epson/__init__.py

@@ -88,10 +88,6 @@ async def async_migrate_entry(
         config_entry.minor_version,
     )
 
-    if config_entry.version > 1 or config_entry.minor_version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
     if config_entry.version == 1 and config_entry.minor_version == 1:
         new_data = {**config_entry.data}
         new_data[CONF_CONNECTION_TYPE] = HTTP

homeassistant/components/esphome/entry_data.py

@@ -166,6 +166,8 @@ class RuntimeEntryData:
     )
     loaded_platforms: set[Platform] = field(default_factory=set)
     platform_load_lock: asyncio.Lock = field(default_factory=asyncio.Lock)
+    # Set once the first connection has finished scanner setup or teardown.
+    first_connect_done: asyncio.Event = field(default_factory=asyncio.Event)
     _storage_contents: StoreData | None = None
     _pending_storage: Callable[[], StoreData] | None = None
     assist_pipeline_update_callbacks: list[CALLBACK_TYPE] = field(default_factory=list)

homeassistant/components/esphome/manager.py

@@ -1,11 +1,12 @@
 """Manager for esphome devices."""
 
+import asyncio
 import base64
 from functools import partial
 import logging
 import secrets
 import struct
-from typing import TYPE_CHECKING, Any, NamedTuple
+from typing import TYPE_CHECKING, Any, Final, NamedTuple
 
 from aioesphomeapi import (
     APIClient,
@@ -106,6 +107,9 @@ if TYPE_CHECKING:
 
 _LOGGER = logging.getLogger(__name__)
 
+# Max time to wait at startup for a BLE proxy to register its scanner.
+STARTUP_SCANNER_WAIT: Final = 3.0
+
 LOG_LEVEL_TO_LOGGER = {
     LogLevel.LOG_LEVEL_NONE: logging.DEBUG,
     LogLevel.LOG_LEVEL_ERROR: logging.ERROR,
@@ -677,6 +681,8 @@ class ESPHomeManager:
                 hass, device_info.bluetooth_mac_address or device_info.mac_address
             )
 
+        entry_data.first_connect_done.set()
+
         if device_info.voice_assistant_feature_flags_compat(api_version) and (
             Platform.ASSIST_SATELLITE not in entry_data.loaded_platforms
         ):
@@ -988,6 +994,21 @@ class ESPHomeManager:
 
         await reconnect_logic.start()
 
+        # Wait for a cached BLE proxy to register its scanner before finishing setup.
+        if (
+            device_info := entry_data.device_info
+        ) is not None and device_info.bluetooth_proxy_feature_flags_compat(
+            entry_data.api_version
+        ):
+            try:
+                async with asyncio.timeout(STARTUP_SCANNER_WAIT):
+                    await entry_data.first_connect_done.wait()
+            except TimeoutError:
+                _LOGGER.debug(
+                    "%s: Timed out waiting for Bluetooth scanner to register",
+                    self.host,
+                )
+
 
 @callback
 def _async_setup_device_registry(

homeassistant/components/file/__init__.py

@@ -53,9 +53,6 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
 async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
     """Migrate config entry."""
-    if config_entry.version > 2:
-        # Downgraded from future
-        return False
 
     if config_entry.version < 2:
         # Move optional fields from data to options in config entry

homeassistant/components/fluss/manifest.json

@@ -1,7 +1,7 @@
 {
   "domain": "fluss",
   "name": "Fluss+",
-  "codeowners": ["@fluss"],
+  "codeowners": ["@fluss", "@Marcello17"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/fluss",
   "iot_class": "cloud_polling",

homeassistant/components/forecast_solar/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/forecast_solar",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["forecast-solar==5.0.0"]
+  "requirements": ["forecast-solar==5.0.1"]
 }

homeassistant/components/frontend/manifest.json

@@ -21,5 +21,5 @@
   "integration_type": "system",
   "preview_features": { "winter_mode": {} },
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20260527.4"]
+  "requirements": ["home-assistant-frontend==20260527.5"]
 }

homeassistant/components/fujitsu_fglair/__init__.py

@@ -48,8 +48,6 @@ async def async_unload_entry(hass: HomeAssistant, entry: FGLairConfigEntry) -> b
 
 async def async_migrate_entry(hass: HomeAssistant, entry: FGLairConfigEntry) -> bool:
     """Migrate old entry."""
-    if entry.version > 1:
-        return False
 
     if entry.version == 1:
         new_data = {**entry.data}

homeassistant/components/fyta/__init__.py

@@ -65,10 +65,6 @@ async def async_migrate_entry(
     """Migrate old entry."""
     _LOGGER.debug("Migrating from version %s", config_entry.version)
 
-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
-
     if config_entry.version == 1:
         if config_entry.minor_version < 2:
             new = {**config_entry.data}

homeassistant/components/gardena_bluetooth/__init__.py

@@ -1,17 +1,20 @@
 """The Gardena Bluetooth integration."""
 
+from contextlib import suppress
 import logging
 
 from bleak.backends.device import BLEDevice
 from gardena_bluetooth.client import CachedConnection, Client
-from gardena_bluetooth.const import ProductType
-from gardena_bluetooth.scan import async_get_manufacturer_data
+from gardena_bluetooth.const import ScanService
+from gardena_bluetooth.parse import ManufacturerData, ProductType
+from habluetooth import BluetoothServiceInfoBleak
 
 from homeassistant.components import bluetooth
 from homeassistant.const import CONF_ADDRESS, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady
 
+from .const import CONF_PRODUCT_TYPE
 from .coordinator import (
     DeviceUnavailable,
     GardenaBluetoothConfigEntry,
@@ -30,6 +33,79 @@ PLATFORMS: list[Platform] = [
 ]
 LOGGER = logging.getLogger(__name__)
 DISCONNECT_DELAY = 5
+PRODUCTS_SCAN_TIMEOUT = 10
+PRODUCT_TYPE_TIMEOUT = 30
+
+
+async def async_get_product(hass: HomeAssistant, address: str) -> ManufacturerData:
+    """Get manufacturer data for the given address via active scan."""
+
+    data = ManufacturerData()
+
+    def _data_callback(info: BluetoothServiceInfoBleak) -> bool:
+        LOGGER.debug("Processing advertisement from %s: %s", info.address, info)
+        if info.device.address != address:
+            return False
+
+        data.update(info.manufacturer_data.get(ManufacturerData.company, b""))
+        return data.product_type is not ProductType.UNKNOWN
+
+    with suppress(TimeoutError):
+        await bluetooth.async_process_advertisements(
+            hass,
+            _data_callback,
+            bluetooth.BluetoothCallbackMatcher(
+                address=address, manufacturer_id=ManufacturerData.company
+            ),
+            mode=bluetooth.BluetoothScanningMode.ACTIVE,
+            timeout=PRODUCT_TYPE_TIMEOUT,
+        )
+    return data
+
+
+async def async_get_products(hass: HomeAssistant) -> dict[str, ManufacturerData]:
+    """Get all products that are currently advertising."""
+    products: dict[str, ManufacturerData] = {}
+
+    def _data_callback(info: BluetoothServiceInfoBleak) -> bool:
+        LOGGER.debug("Processing advertisement from %s: %s", info.address, info)
+        if ScanService not in info.service_uuids:
+            return False
+
+        raw = info.manufacturer_data.get(ManufacturerData.company, b"")
+        if (data := products.get(info.device.address)) is None:
+            data = ManufacturerData()
+            products[info.device.address] = data
+
+        data.update(raw)
+        return False
+
+    with suppress(TimeoutError):
+        await bluetooth.async_process_advertisements(
+            hass,
+            _data_callback,
+            bluetooth.BluetoothCallbackMatcher(
+                manufacturer_id=ManufacturerData.company
+            ),
+            mode=bluetooth.BluetoothScanningMode.ACTIVE,
+            timeout=PRODUCTS_SCAN_TIMEOUT,
+        )
+    return products
+
+
+async def async_migrate_product_type(
+    hass: HomeAssistant, entry: GardenaBluetoothConfigEntry
+) -> GardenaBluetoothConfigEntry:
+    """Discover product type for old entries and upgrade them to minor version 2."""
+    mfg = await async_get_product(hass, entry.data[CONF_ADDRESS])
+    if mfg.product_type is ProductType.UNKNOWN:
+        raise ConfigEntryNotReady("Unable to find product type")
+    hass.config_entries.async_update_entry(
+        entry,
+        data={**entry.data, CONF_PRODUCT_TYPE: mfg.product_type.name},
+        minor_version=2,
+    )
+    return entry
 
 
 def get_connection(hass: HomeAssistant, address: str) -> CachedConnection:
@@ -51,16 +127,11 @@ async def async_setup_entry(
 ) -> bool:
     """Set up Gardena Bluetooth from a config entry."""
 
+    if entry.minor_version < 2:
+        entry = await async_migrate_product_type(hass, entry)
+
     address = entry.data[CONF_ADDRESS]
-
-    try:
-        mfg_data = await async_get_manufacturer_data({address})
-    except TimeoutError as exc:
-        raise ConfigEntryNotReady("Unable to find product type") from exc
-
-    product_type = mfg_data[address].product_type
-    if product_type is ProductType.UNKNOWN:
-        raise ConfigEntryNotReady("Unable to find product type")
+    product_type = ProductType[entry.data[CONF_PRODUCT_TYPE]]
 
     client = Client(get_connection(hass, address), product_type)
 

homeassistant/components/gardena_bluetooth/config_flow.py

@@ -4,22 +4,18 @@ import logging
 from typing import Any
 
 from gardena_bluetooth.client import Client
-from gardena_bluetooth.const import PRODUCT_NAMES, DeviceInformation, ScanService
+from gardena_bluetooth.const import PRODUCT_NAMES, DeviceInformation
 from gardena_bluetooth.exceptions import CharacteristicNotFound, CommunicationFailure
 from gardena_bluetooth.parse import ManufacturerData, ProductType
-from gardena_bluetooth.scan import async_get_manufacturer_data
 import voluptuous as vol
 
-from homeassistant.components.bluetooth import (
-    BluetoothServiceInfo,
-    async_discovered_service_info,
-)
+from homeassistant.components.bluetooth import BluetoothServiceInfo
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 from homeassistant.const import CONF_ADDRESS
 from homeassistant.data_entry_flow import AbortFlow
 
-from . import get_connection
-from .const import DOMAIN
+from . import async_get_product, async_get_products, get_connection
+from .const import CONF_PRODUCT_TYPE, DOMAIN
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -33,26 +29,16 @@ _SUPPORTED_PRODUCT_TYPES = {
 }
 
 
-def _is_supported(discovery_info: BluetoothServiceInfo):
-    """Check if device is supported."""
-    if ScanService not in discovery_info.service_uuids:
-        return False
-
-    if discovery_info.manufacturer_data.get(ManufacturerData.company) is None:
-        _LOGGER.debug("Missing manufacturer data: %s", discovery_info)
-        return False
-    return True
-
-
 class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Gardena Bluetooth."""
 
     VERSION = 1
+    MINOR_VERSION = 2
 
     def __init__(self) -> None:
         """Initialize the config flow."""
-        self.devices: dict[str, str] = {}
         self.address: str | None
+        self.devices: dict[str, ManufacturerData] = {}
 
     async def async_read_data(self):
         """Try to connect to device and extract information."""
@@ -68,20 +54,23 @@ class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
         finally:
             await client.disconnect()
 
-        return {CONF_ADDRESS: self.address}
+        assert self.address in self.devices
+        return {
+            CONF_ADDRESS: self.address,
+            CONF_PRODUCT_TYPE: self.devices[self.address].product_type.name,
+        }
 
     async def async_step_bluetooth(
         self, discovery_info: BluetoothServiceInfo
     ) -> ConfigFlowResult:
         """Handle the bluetooth discovery step."""
         _LOGGER.debug("Discovered device: %s", discovery_info)
-        data = await async_get_manufacturer_data({discovery_info.address})
-        product_type = data[discovery_info.address].product_type
-        if product_type not in _SUPPORTED_PRODUCT_TYPES:
+        mfg = await async_get_product(self.hass, discovery_info.address)
+        self.devices[discovery_info.address] = mfg
+        if mfg.product_type not in _SUPPORTED_PRODUCT_TYPES:
             return self.async_abort(reason="no_devices_found")
 
         self.address = discovery_info.address
-        self.devices = {discovery_info.address: PRODUCT_NAMES[product_type]}
         await self.async_set_unique_id(self.address)
         self._abort_if_unique_id_configured()
         return await self.async_step_confirm()
@@ -91,7 +80,7 @@ class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
     ) -> ConfigFlowResult:
         """Confirm discovery."""
         assert self.address
-        title = self.devices[self.address]
+        title = PRODUCT_NAMES[self.devices[self.address].product_type]
 
         if user_input is not None:
             data = await self.async_read_data()
@@ -117,31 +106,25 @@ class GardenaBluetoothConfigFlow(ConfigFlow, domain=DOMAIN):
             self._abort_if_unique_id_configured()
             return await self.async_step_confirm()
 
-        current_addresses = self._async_current_ids(include_ignore=False)
-        candidates = set()
-        for discovery_info in async_discovered_service_info(self.hass):
-            address = discovery_info.address
-            if address in current_addresses or not _is_supported(discovery_info):
-                continue
-            candidates.add(address)
-
-        data = await async_get_manufacturer_data(candidates)
-        for address, mfg_data in data.items():
-            if mfg_data.product_type not in _SUPPORTED_PRODUCT_TYPES:
-                continue
-            self.devices[address] = PRODUCT_NAMES[mfg_data.product_type]
+        current = self._async_current_ids(include_ignore=False)
+        self.devices = await async_get_products(self.hass)
 
         # Keep selection sorted by address to ensure stable tests
-        self.devices = dict(sorted(self.devices.items(), key=lambda x: x[0]))
+        devices = {
+            address: PRODUCT_NAMES[data.product_type]
+            for address in sorted(self.devices)
+            if address not in current
+            and (data := self.devices[address]).product_type in _SUPPORTED_PRODUCT_TYPES
+        }
 
-        if not self.devices:
+        if not devices:
             return self.async_abort(reason="no_devices_found")
 
         return self.async_show_form(
             step_id="user",
             data_schema=vol.Schema(
                 {
-                    vol.Required(CONF_ADDRESS): vol.In(self.devices),
+                    vol.Required(CONF_ADDRESS): vol.In(devices),
                 },
             ),
         )

homeassistant/components/gardena_bluetooth/const.py

@@ -1,3 +1,4 @@
 """Constants for the Gardena Bluetooth integration."""
 
 DOMAIN = "gardena_bluetooth"
+CONF_PRODUCT_TYPE = "product_type"

homeassistant/components/generic/__init__.py

@@ -59,10 +59,6 @@ async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Migrate entry."""
     _LOGGER.debug("Migrating from version %s:%s", entry.version, entry.minor_version)
 
-    if entry.version > 2:
-        # This means the user has downgraded from a future version
-        return False
-
     if entry.version == 1:
         # Migrate to advanced section
         new_options = {**entry.options}

homeassistant/components/generic_hygrostat/__init__.py

@@ -148,9 +148,6 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
         "Migrating 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:
         options = {**config_entry.options}
         if config_entry.minor_version < 2:

homeassistant/components/generic_thermostat/__init__.py

@@ -76,9 +76,6 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
         "Migrating 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:
         options = {**config_entry.options}
         if config_entry.minor_version < 2:

homeassistant/components/goodwe/__init__.py

@@ -98,10 +98,6 @@ async def async_migrate_entry(
 ) -> bool:
     """Migrate old config entries."""
 
-    if config_entry.version > 2:
-        # This means the user has downgraded from a future version
-        return False
-
     if config_entry.version == 1:
         # Update from version 1 to version 2 adding the PROTOCOL to the config entry
         host = config_entry.data[CONF_HOST]

homeassistant/components/goodwe/config_flow.py

@@ -24,7 +24,7 @@ _LOGGER = logging.getLogger(__name__)
 class GoodweFlowHandler(ConfigFlow, domain=DOMAIN):
     """Handle a Goodwe config flow."""
 
-    MINOR_VERSION = 2
+    VERSION = 2
 
     async def async_handle_successful_connection(
         self,

homeassistant/components/google_generative_ai_conversation/__init__.py

@@ -226,10 +226,6 @@ async def async_migrate_entry(
     """Migrate entry."""
     LOGGER.debug("Migrating from version %s:%s", entry.version, entry.minor_version)
 
-    if entry.version > 2:
-        # This means the user has downgraded from a future version
-        return False
-
     if entry.version == 2 and entry.minor_version == 1:
         # Add TTS subentry which was missing in 2025.7.0b0
         if not any(

homeassistant/components/history_stats/__init__.py

@@ -100,9 +100,6 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
         "Migrating 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:
         options = {**config_entry.options}
         if config_entry.minor_version < 2:

homeassistant/components/homeassistant_connect_zbt2/__init__.py

@@ -108,10 +108,6 @@ async def async_migrate_entry(
         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:
         if config_entry.minor_version == 1:
             serial_number = config_entry.data[SERIAL_NUMBER]
@@ -135,7 +131,24 @@ async def async_migrate_entry(
             )
 
             if canonical.entry_id != config_entry.entry_id:
-                # The canonical entry's migration will remove this duplicate.
+                if canonical.minor_version < 2:
+                    # The canonical entry has not been migrated yet and its
+                    # migration will remove this duplicate.
+                    return False
+
+                # The canonical entry is already fully migrated and will not run
+                # a migration that removes this duplicate, so remove it here. The
+                # entry can't remove itself while its setup lock is held, so
+                # schedule the removal instead.
+                _LOGGER.debug(
+                    "Removing duplicate config entry %s for serial %s in favor of %s",
+                    config_entry.entry_id,
+                    serial_number,
+                    canonical.entry_id,
+                )
+                hass.async_create_task(
+                    hass.config_entries.async_remove(config_entry.entry_id)
+                )
                 return False
 
             for duplicate in duplicates:

homeassistant/components/homeassistant_sky_connect/__init__.py

@@ -140,10 +140,6 @@ async def async_migrate_entry(
         "Migrating 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:
         if config_entry.minor_version == 1:
             # Add-on startup with type service get started before
@@ -239,7 +235,24 @@ async def async_migrate_entry(
             )
 
             if canonical.entry_id != config_entry.entry_id:
-                # The canonical entry's migration will remove this duplicate.
+                if canonical.minor_version < 5:
+                    # The canonical entry has not been migrated yet and its
+                    # migration will remove this duplicate.
+                    return False
+
+                # The canonical entry is already fully migrated and will not run
+                # a migration that removes this duplicate, so remove it here. The
+                # entry can't remove itself while its setup lock is held, so
+                # schedule the removal instead.
+                _LOGGER.warning(
+                    "Removing duplicate config entry %s for serial %s in favor of %s",
+                    config_entry.entry_id,
+                    serial_number,
+                    canonical.entry_id,
+                )
+                hass.async_create_task(
+                    hass.config_entries.async_remove(config_entry.entry_id)
+                )
                 return False
 
             for duplicate in duplicates:

homeassistant/components/homematicip_cloud/__init__.py

@@ -126,8 +126,6 @@ async def async_migrate_entry(
     hass: HomeAssistant, config_entry: config_entries.ConfigEntry
 ) -> bool:
     """Migrate the config entry from version 1 to version 2."""
-    if config_entry.version > 2:
-        return False
 
     if config_entry.version == 1:
         _LOGGER.debug("Migrating HomematicIP Cloud config entry to version 2")

homeassistant/components/hypontech/coordinator.py

@@ -1,9 +1,16 @@
 """The coordinator for Hypontech Cloud integration."""
 
+import asyncio
 from dataclasses import dataclass
 from datetime import timedelta
 
-from hyponcloud import HyponCloud, OverviewData, PlantData, RequestError
+from hyponcloud import (
+    HyponCloud,
+    OverviewData,
+    PlantData,
+    PlantMonitorData,
+    RequestError,
+)
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
@@ -12,12 +19,20 @@ from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, Upda
 from .const import DOMAIN, LOGGER
 
 
+@dataclass
+class HypontechPlant:
+    """Store a plant together with its real-time monitor data."""
+
+    info: PlantData
+    monitor: PlantMonitorData
+
+
 @dataclass
 class HypontechCoordinatorData:
     """Store coordinator data."""
 
     overview: OverviewData
-    plants: dict[str, PlantData]
+    plants: dict[str, HypontechPlant]
 
 
 type HypontechConfigEntry = ConfigEntry[HypontechDataCoordinator]
@@ -50,11 +65,17 @@ class HypontechDataCoordinator(DataUpdateCoordinator[HypontechCoordinatorData]):
         try:
             overview = await self.api.get_overview()
             plants = await self.api.get_list()
+            monitors = await asyncio.gather(
+                *(self.api.get_monitor(plant.plant_id) for plant in plants)
+            )
         except RequestError as ex:
             raise UpdateFailed(
                 translation_domain=DOMAIN, translation_key="connection_error"
             ) from ex
         return HypontechCoordinatorData(
             overview=overview,
-            plants={plant.plant_id: plant for plant in plants},
+            plants={
+                plant.plant_id: HypontechPlant(info=plant, monitor=monitor)
+                for plant, monitor in zip(plants, monitors, strict=True)
+            },
         )

homeassistant/components/hypontech/entity.py

@@ -1,12 +1,10 @@
 """Base entity for the Hypontech Cloud integration."""
 
-from hyponcloud import PlantData
-
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import DOMAIN
-from .coordinator import HypontechDataCoordinator
+from .coordinator import HypontechDataCoordinator, HypontechPlant
 
 
 class HypontechEntity(CoordinatorEntity[HypontechDataCoordinator]):
@@ -36,12 +34,13 @@ class HypontechPlantEntity(CoordinatorEntity[HypontechDataCoordinator]):
         plant = coordinator.data.plants[plant_id]
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, plant_id)},
-            name=plant.plant_name,
+            name=plant.info.plant_name,
             manufacturer="Hypontech",
+            model=plant.info.plant_type,
         )
 
     @property
-    def plant(self) -> PlantData:
+    def plant(self) -> HypontechPlant:
         """Return the plant data."""
         return self.coordinator.data.plants[self.plant_id]
 

homeassistant/components/hypontech/sensor.py

@@ -11,11 +11,11 @@ from homeassistant.components.sensor import (
     SensorEntityDescription,
     SensorStateClass,
 )
-from homeassistant.const import UnitOfEnergy, UnitOfPower
+from homeassistant.const import PERCENTAGE, UnitOfEnergy, UnitOfPower
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .coordinator import HypontechConfigEntry, HypontechDataCoordinator
+from .coordinator import HypontechConfigEntry, HypontechDataCoordinator, HypontechPlant
 from .entity import HypontechEntity, HypontechPlantEntity
 
 
@@ -36,8 +36,8 @@ class HypontechSensorDescription(SensorEntityDescription):
 class HypontechPlantSensorDescription(SensorEntityDescription):
     """Describes Hypontech plant sensor entity."""
 
-    value_fn: Callable[[PlantData], float | None]
-    unit_fn: Callable[[PlantData], str] | None = None
+    value_fn: Callable[[HypontechPlant], float | None]
+    unit_fn: Callable[[HypontechPlant], str] | None = None
 
 
 OVERVIEW_SENSORS: tuple[HypontechSensorDescription, ...] = (
@@ -67,12 +67,24 @@ OVERVIEW_SENSORS: tuple[HypontechSensorDescription, ...] = (
 )
 
 PLANT_SENSORS: tuple[HypontechPlantSensorDescription, ...] = (
+    # Historically keyed "pv_power" when total power was the only reading (no
+    # battery support). Now it carries the PV-only power from the monitor
+    # endpoint; the plant endpoint's total power is exposed as "total_power".
     HypontechPlantSensorDescription(
         key="pv_power",
+        translation_key="pv_power",
+        native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
         state_class=SensorStateClass.MEASUREMENT,
-        value_fn=lambda c: c.power,
-        unit_fn=_power_unit,
+        value_fn=lambda c: c.monitor.power_pv,
+    ),
+    HypontechPlantSensorDescription(
+        key="total_power",
+        translation_key="total_power",
+        device_class=SensorDeviceClass.POWER,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda c: c.info.power,
+        unit_fn=lambda c: _power_unit(c.info),
     ),
     HypontechPlantSensorDescription(
         key="lifetime_energy",
@@ -80,7 +92,7 @@ PLANT_SENSORS: tuple[HypontechPlantSensorDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        value_fn=lambda c: c.e_total,
+        value_fn=lambda c: c.info.e_total,
     ),
     HypontechPlantSensorDescription(
         key="today_energy",
@@ -88,7 +100,44 @@ PLANT_SENSORS: tuple[HypontechPlantSensorDescription, ...] = (
         native_unit_of_measurement=UnitOfEnergy.KILO_WATT_HOUR,
         device_class=SensorDeviceClass.ENERGY,
         state_class=SensorStateClass.TOTAL_INCREASING,
-        value_fn=lambda c: c.e_today,
+        value_fn=lambda c: c.info.e_today,
+    ),
+    HypontechPlantSensorDescription(
+        key="load_power",
+        translation_key="load_power",
+        native_unit_of_measurement=UnitOfPower.WATT,
+        device_class=SensorDeviceClass.POWER,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda c: c.monitor.power_load,
+    ),
+    HypontechPlantSensorDescription(
+        key="grid_power",
+        translation_key="grid_power",
+        native_unit_of_measurement=UnitOfPower.WATT,
+        device_class=SensorDeviceClass.POWER,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda c: c.monitor.meter_power,
+    ),
+)
+
+# Sensors only added for plants that have a battery (storage) system.
+BATTERY_SENSORS: tuple[HypontechPlantSensorDescription, ...] = (
+    HypontechPlantSensorDescription(
+        key="battery_power",
+        translation_key="battery_power",
+        native_unit_of_measurement=UnitOfPower.WATT,
+        device_class=SensorDeviceClass.POWER,
+        state_class=SensorStateClass.MEASUREMENT,
+        # Positive while the battery is discharging, negative while charging.
+        value_fn=lambda c: c.monitor.w_cha,
+    ),
+    HypontechPlantSensorDescription(
+        key="battery_state_of_charge",
+        translation_key="battery_state_of_charge",
+        native_unit_of_measurement=PERCENTAGE,
+        device_class=SensorDeviceClass.BATTERY,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda c: c.monitor.soc,
     ),
 )
 
@@ -105,11 +154,15 @@ async def async_setup_entry(
         HypontechOverviewSensor(coordinator, desc) for desc in OVERVIEW_SENSORS
     ]
 
-    entities.extend(
-        HypontechPlantSensor(coordinator, plant_id, desc)
-        for plant_id in coordinator.data.plants
-        for desc in PLANT_SENSORS
-    )
+    for plant_id, plant in coordinator.data.plants.items():
+        entities.extend(
+            HypontechPlantSensor(coordinator, plant_id, desc) for desc in PLANT_SENSORS
+        )
+        if plant.info.plant_type.endswith("Storage"):
+            entities.extend(
+                HypontechPlantSensor(coordinator, plant_id, desc)
+                for desc in BATTERY_SENSORS
+            )
 
     async_add_entities(entities)
 

homeassistant/components/hypontech/strings.json

@@ -36,11 +36,29 @@
   },
   "entity": {
     "sensor": {
+      "battery_power": {
+        "name": "Battery power"
+      },
+      "battery_state_of_charge": {
+        "name": "Battery state of charge"
+      },
+      "grid_power": {
+        "name": "Grid power"
+      },
       "lifetime_energy": {
         "name": "Lifetime energy"
       },
+      "load_power": {
+        "name": "Load power"
+      },
+      "pv_power": {
+        "name": "PV power"
+      },
       "today_energy": {
         "name": "Today energy"
+      },
+      "total_power": {
+        "name": "Total power"
       }
     }
   },

homeassistant/components/image/__init__.py

@@ -2,20 +2,21 @@
 
 import asyncio
 import collections
+from collections.abc import Container, Mapping
 from contextlib import suppress
 from dataclasses import dataclass
 from datetime import datetime, timedelta
 import logging
 import os
 from random import SystemRandom
-from typing import Final, final
+from typing import Final, final, override
 
-from aiohttp import hdrs, web
+from aiohttp import web
 import httpx
 from propcache.api import cached_property
 import voluptuous as vol
 
-from homeassistant.components.http import KEY_AUTHENTICATED, KEY_HASS, HomeAssistantView
+from homeassistant.components.http import KEY_HASS, HomeAssistantView
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONTENT_TYPE_MULTIPART, EVENT_HOMEASSISTANT_STOP
 from homeassistant.core import (
@@ -314,33 +315,28 @@ class ImageView(HomeAssistantView):
     """View to serve an image."""
 
     name = "api:image:image"
-    requires_auth = False
+    use_query_token_for_auth = True
     url = "/api/image_proxy/{entity_id}"
 
     def __init__(self, component: EntityComponent[ImageEntity]) -> None:
         """Initialize an image view."""
         self.component = component
 
-    async def _authenticate_request(
-        self, request: web.Request, entity_id: str
-    ) -> ImageEntity:
-        """Authenticate request and return image entity."""
+    @callback
+    @override
+    def get_valid_auth_tokens(self, match_info: Mapping[str, str]) -> Container[str]:
+        """Return valid auth tokens, which can be used for query token authentication."""
+        if (image_entity := self.component.get_entity(match_info["entity_id"])) is None:
+            return ()
+
+        return image_entity.access_tokens
+
+    @callback
+    def _get_image_entity(self, entity_id: str) -> ImageEntity:
+        """Get image entity from request."""
         if (image_entity := self.component.get_entity(entity_id)) is None:
             raise web.HTTPNotFound
 
-        authenticated = (
-            request[KEY_AUTHENTICATED]
-            or request.query.get("token") in image_entity.access_tokens
-        )
-
-        if not authenticated:
-            # Attempt with invalid bearer token, raise unauthorized
-            # so ban middleware can handle it.
-            if hdrs.AUTHORIZATION in request.headers:
-                raise web.HTTPUnauthorized
-            # Invalid sigAuth or image entity access token
-            raise web.HTTPForbidden
-
         return image_entity
 
     async def head(self, request: web.Request, entity_id: str) -> web.Response:
@@ -349,7 +345,7 @@ class ImageView(HomeAssistantView):
         This is sent by some DLNA renderers, like Samsung ones, prior to sending
         the GET request.
         """
-        image_entity = await self._authenticate_request(request, entity_id)
+        image_entity = self._get_image_entity(entity_id)
 
         # Don't use `handle` as we don't care about the stream case, we only want
         # to verify that the image exists.
@@ -365,7 +361,7 @@ class ImageView(HomeAssistantView):
 
     async def get(self, request: web.Request, entity_id: str) -> web.StreamResponse:
         """Start a GET request."""
-        image_entity = await self._authenticate_request(request, entity_id)
+        image_entity = self._get_image_entity(entity_id)
         return await self.handle(request, image_entity)
 
     async def handle(

homeassistant/components/indevolt/manifest.json

@@ -8,6 +8,6 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "quality_scale": "platinum",
-  "requirements": ["indevolt-api==1.8.3"],
+  "requirements": ["indevolt-api==1.8.5"],
   "zeroconf": [{ "name": "igen_fw*", "type": "_http._tcp.local." }]
 }

homeassistant/components/indevolt/services.py

@@ -30,7 +30,7 @@ RT_ACTION_SERVICE_SCHEMA: Final = vol.Schema(
         ),
         vol.Required("power"): vol.All(
             vol.Coerce(int),
-            vol.Range(min=1, max=2400),
+            vol.Range(min=0, max=2400),
         ),
     }
 )

homeassistant/components/indevolt/services.yaml

@@ -18,7 +18,7 @@ charge:
       required: true
       selector:
         number:
-          min: 1
+          min: 0
           max: 2400
           step: 1
           unit_of_measurement: "W"
@@ -43,7 +43,7 @@ discharge:
       required: true
       selector:
         number:
-          min: 1
+          min: 0
           max: 2400
           step: 1
           unit_of_measurement: "W"

homeassistant/components/integration/__init__.py

@@ -49,9 +49,6 @@ async def async_migrate_entry(hass: HomeAssistant, config_entry: ConfigEntry) ->
         "Migrating 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:
         options = {**config_entry.options}
         if config_entry.minor_version < 2:

homeassistant/components/islamic_prayer_times/__init__.py

@@ -52,9 +52,6 @@ async def async_migrate_entry(
     """Migrate old entry."""
     _LOGGER.debug("Migrating from version %s", config_entry.version)
 
-    if config_entry.version > 1:
-        # This means the user has downgraded from a future version
-        return False
     if config_entry.version == 1:
         new = {**config_entry.data}
         if config_entry.minor_version < 2:

homeassistant/components/jellyfin/__init__.py

@@ -2,6 +2,7 @@
 
 from typing import Any
 
+from homeassistant.const import CONF_URL
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv, device_registry as dr
@@ -65,6 +66,15 @@ async def async_setup_entry(hass: HomeAssistant, entry: JellyfinConfigEntry) ->
     return True
 
 
+async def async_migrate_entry(hass: HomeAssistant, entry: JellyfinConfigEntry) -> bool:
+    """Migrate an old config entry."""
+    if entry.version == 1 and entry.minor_version < 2:
+        new_data = {**entry.data, CONF_URL: entry.data[CONF_URL].rstrip("/")}
+        hass.config_entries.async_update_entry(entry, data=new_data, minor_version=2)
+
+    return True
+
+
 async def async_unload_entry(hass: HomeAssistant, entry: JellyfinConfigEntry) -> bool:
     """Unload a config entry."""
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/jellyfin/config_flow.py

@@ -46,6 +46,7 @@ class JellyfinConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Jellyfin."""
 
     VERSION = 1
+    MINOR_VERSION = 2
 
     def __init__(self) -> None:
         """Initialize the Jellyfin config flow."""
@@ -58,6 +59,8 @@ class JellyfinConfigFlow(ConfigFlow, domain=DOMAIN):
         errors: dict[str, str] = {}
 
         if user_input is not None:
+            user_input[CONF_URL] = user_input[CONF_URL].rstrip("/")
+
             if self.client_device_id is None:
                 self.client_device_id = _generate_client_device_id()
 

homeassistant/components/jewish_calendar/__init__.py

@@ -131,10 +131,6 @@ async def async_migrate_entry(
             return {"new_unique_id": new_unique_id}
         return None
 
-    if config_entry.version > 2:
-        # This means the user has downgraded from a future version
-        return False
-
     if config_entry.version == 1:
         await er.async_migrate_entries(hass, config_entry.entry_id, update_unique_id)
         hass.config_entries.async_update_entry(config_entry, version=2)

homeassistant/components/kiosker/__init__.py

@@ -2,8 +2,14 @@
 
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.typing import ConfigType
 
+from .const import DOMAIN
 from .coordinator import KioskerConfigEntry, KioskerDataUpdateCoordinator
+from .services import async_setup_services
+
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
 _PLATFORMS: list[Platform] = [
     Platform.BINARY_SENSOR,
@@ -13,6 +19,12 @@ _PLATFORMS: list[Platform] = [
 ]
 
 
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the Kiosker integration."""
+    async_setup_services(hass)
+    return True
+
+
 async def async_setup_entry(hass: HomeAssistant, entry: KioskerConfigEntry) -> bool:
     """Set up Kiosker from a config entry."""
 

homeassistant/components/kiosker/button.py

@@ -72,6 +72,11 @@ BUTTONS: tuple[KioskerButtonEntityDescription, ...] = (
         translation_key="screensaver_interact",
         action_fn=lambda api: api.screensaver_interact(),
     ),
+    KioskerButtonEntityDescription(
+        key="blackoutClear",
+        translation_key="blackout_clear",
+        action_fn=lambda api: api.blackout_clear(),
+    ),
 )
 
 

homeassistant/components/kiosker/const.py

@@ -8,3 +8,16 @@ POLL_INTERVAL = 15
 DEFAULT_SSL = False
 DEFAULT_SSL_VERIFY = False
 REFRESH_DELAY = 0.5
+
+# Service attribute keys
+ATTR_URL = "url"
+ATTR_VISIBLE = "visible"
+ATTR_TEXT = "text"
+ATTR_BACKGROUND = "background"
+ATTR_FOREGROUND = "foreground"
+ATTR_EXPIRE = "expire"
+ATTR_DISMISSIBLE = "dismissible"
+ATTR_BUTTON_BACKGROUND = "button_background"
+ATTR_BUTTON_FOREGROUND = "button_foreground"
+ATTR_BUTTON_TEXT = "button_text"
+ATTR_SOUND = "sound"