[pull] dev from home-assistant:dev

homeassistant/components/alexa_devices/services.py

@@ -46,8 +46,9 @@ def async_get_entry_id_for_service_call(
 ) -> tuple[dr.DeviceEntry, AmazonConfigEntry]:
     """Get the entry ID related to a service call (by device ID)."""
     config_entry: AmazonConfigEntry
+    # Callers read the device's serial number, which only a main device has
     device, config_entry = service.async_get_device_and_config_entry(
-        call.hass, DOMAIN, call.data[ATTR_DEVICE_ID]
+        call.hass, DOMAIN, call.data[ATTR_DEVICE_ID], include_child_devices=False
     )
     return (device, config_entry)
 

homeassistant/components/bsblan/services.py

@@ -127,7 +127,7 @@ def _build_weekly_schedule_days(
 
 def _resolve_config_entry(
     service_call: ServiceCall,
-) -> tuple[BSBLanConfigEntry, dr.DeviceEntry]:
+) -> tuple[BSBLanConfigEntry, dr.AnyDeviceEntry]:
     """Resolve device_id from a service call into a loaded BSBLAN config entry."""
     config_entry: BSBLanConfigEntry
     device, config_entry = service.async_get_device_and_config_entry(
@@ -136,12 +136,12 @@ def _resolve_config_entry(
     return config_entry, device
 
 
-def _device_name(device_entry: dr.DeviceEntry) -> str:
+def _device_name(device_entry: dr.AnyDeviceEntry) -> str:
     """Return the best available display name for a device."""
     return device_entry.name_by_user or device_entry.name or device_entry.id
 
 
-def _ensure_water_heater_device(device_entry: dr.DeviceEntry) -> None:
+def _ensure_water_heater_device(device_entry: dr.AnyDeviceEntry) -> None:
     """Validate the service targets the water heater sub-device."""
     for domain, identifier in device_entry.identifiers:
         if domain == DOMAIN and identifier.endswith("-water-heater"):

homeassistant/components/device_automation/helpers.py

@@ -130,24 +130,17 @@ async def async_validate_device_automation_config(
         )
 
     # Find a config entry with the same domain as the device automation
-    device_config_entry = None
-    for entry_id in device.config_entries:
-        if (
-            not (entry := hass.config_entries.async_get_entry(entry_id))
-            or entry.domain != validated_config[CONF_DOMAIN]
-        ):
-            continue
-        device_config_entry = entry
-        break
-
-    if not device_config_entry:
+    _, config_entry = dr.async_get_device_and_config_entry_for_domain(
+        hass, device.id, domain=validated_config[CONF_DOMAIN]
+    )
+    if not config_entry:
         # There's no config entry with the same domain as the device automation
         raise InvalidDeviceAutomationConfig(
             f"Device '{validated_config[CONF_DEVICE_ID]}' has no config entry from "
             f"domain '{validated_config[CONF_DOMAIN]}'"
         )
 
-    if not await hass.config_entries.async_wait_component(device_config_entry):
+    if not await hass.config_entries.async_wait_component(config_entry):
         # The component could not be loaded, skip the dynamic validation
         return validated_config
 

homeassistant/components/energyzero/services.py

@@ -86,6 +86,8 @@ def __serialize_prices(
             {
                 "price": price,
                 "timestamp": str(time_range.start_including),
+                "start": str(time_range.start_including),
+                "end": str(time_range.end_excluding),
             }
             for price_data in prices
             for time_range, price in price_data.prices.items()
@@ -111,12 +113,20 @@ async def __get_prices(
     local_tz = ZoneInfo(call.hass.config.time_zone)
     start_date, start_datetime = __get_date(call.data.get(ATTR_START), local_tz)
     end_date, end_datetime = __get_date(call.data.get(ATTR_END), local_tz)
+
     filter_start = start_datetime or dt_util.as_utc(
         dt_util.start_of_local_day(start_date)
     )
-    filter_end = end_datetime or dt_util.as_utc(
-        dt_util.start_of_local_day(end_date + timedelta(days=1))
-    )
+    end_start = end_datetime or dt_util.as_utc(dt_util.start_of_local_day(end_date))
+
+    if filter_start == end_start:
+        day = filter_start.astimezone(local_tz).date()
+        filter_start = dt_util.as_utc(dt_util.start_of_local_day(day))
+        filter_end = dt_util.as_utc(dt_util.start_of_local_day(day + timedelta(days=1)))
+    else:
+        filter_end = end_datetime or dt_util.as_utc(
+            dt_util.start_of_local_day(end_date + timedelta(days=1))
+        )
 
     if filter_end <= filter_start:
         raise ServiceValidationError(

homeassistant/components/enphase_envoy/manifest.json

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

homeassistant/components/file_upload/__init__.py

@@ -118,6 +118,7 @@ async def _receive_file_field(
     queue: SimpleQueue[tuple[bytes, asyncio.Future[None] | None] | None] = SimpleQueue()
 
     def _sync_queue_consumer() -> None:
+        file_path.parent.mkdir()
         with file_path.open("wb") as file_handle:
             while True:
                 if (_chunk_future := queue.get()) is None:
@@ -128,6 +129,7 @@ def _sync_queue_consumer() -> None:
                 file_handle.write(_chunk)
 
     fut: asyncio.Future[None] | None = None
+    cancelled: asyncio.CancelledError | None = None
     try:
         fut = hass.async_add_executor_job(_sync_queue_consumer)
         chunks_sent = 0
@@ -143,23 +145,31 @@ def _sync_queue_consumer() -> None:
             if fut.done():
                 # The executor job failed
                 break
+    except asyncio.CancelledError as err:
+        # Remember a cancellation from the streaming loop so the join below re-raises
+        # it instead of a later writer error.
+        cancelled = err
+        raise
     finally:
         # Always terminate the queue consumer, also if the stream raised or the task
         # was cancelled, otherwise awaiting the consumer future deadlocks.
         queue.put_nowait(None)
         if fut is not None:
             # The executor thread can't be cancelled and is guaranteed to finish once
-            # it reads the sentinel queued above. Await it even if this task is
-            # cancelled: awaiting only through a shield keeps the executor future
-            # itself uncancelled, so the thread is fully done (file written and closed)
-            # before the caller cleans up. Re-raise any cancellation after.
-            cancelled: asyncio.CancelledError | None = None
+            # it reads the sentinel queued above. Wait for it even if this task is
+            # cancelled: asyncio.wait neither cancels the future nor raises its
+            # exception, so the thread is fully done (file written and closed) before
+            # the caller cleans up. The loop re-waits through repeated cancellations.
             while not fut.done():
                 try:
-                    await asyncio.shield(fut)
+                    await asyncio.wait({fut})
                 except asyncio.CancelledError as err:
                     cancelled = err
             if cancelled is not None:
+                # A cancellation takes precedence over a writer error; retrieve the
+                # writer result so its exception isn't flagged as never-retrieved.
+                if not fut.cancelled():
+                    fut.exception()
                 raise cancelled
             fut.result()
 
@@ -216,12 +226,12 @@ async def _upload_file(self, request: web.Request) -> web.Response:
         file_dir = file_upload_data.file_dir(file_id)
 
         try:
-            await hass.async_add_executor_job(file_dir.mkdir)
             await _receive_file_field(hass, file_field_reader, file_dir / filename)
         except Exception, asyncio.CancelledError:
-            # Upload failed: _receive_file_field has joined the writer and closed the
-            # file, so removing the directory now cannot race the writer. ignore_errors
-            # covers a failure that happened before the directory was created.
+            # Upload failed: _receive_file_field has joined the writer, which created
+            # the directory and closed the file, so removing the directory now cannot
+            # race the writer. ignore_errors covers a failure that happened before the
+            # directory was created.
             await hass.async_add_executor_job(
                 lambda: shutil.rmtree(file_dir, ignore_errors=True)
             )

homeassistant/components/flexit/__init__.py

@@ -12,7 +12,11 @@
 from .const import CONF_BAUDRATE, CONF_UNIT, DEFAULT_PORT, TYPE_SERIAL
 from .coordinator import FlexitConfigEntry, FlexitDataCoordinator
 
-_PLATFORMS: list[Platform] = [Platform.BINARY_SENSOR, Platform.CLIMATE]
+_PLATFORMS: list[Platform] = [
+    Platform.BINARY_SENSOR,
+    Platform.CLIMATE,
+    Platform.SENSOR,
+]
 
 
 def create_modbus_params(

homeassistant/components/flexit/sensor.py

@@ -0,0 +1,117 @@
+"""Sensor platform for the Flexit integration."""
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import override
+
+from flexit_modbus import Measurements
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+    SensorStateClass,
+)
+from homeassistant.const import (
+    PERCENTAGE,
+    EntityCategory,
+    UnitOfTemperature,
+    UnitOfTime,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.typing import StateType
+
+from .coordinator import FlexitConfigEntry, FlexitDataCoordinator
+from .entity import FlexitEntity
+
+
+@dataclass(kw_only=True, frozen=True)
+class FlexitSensorEntityDescription(SensorEntityDescription):
+    """Describe a Flexit sensor entity."""
+
+    value_fn: Callable[[Measurements], StateType]
+
+
+SENSORS: tuple[FlexitSensorEntityDescription, ...] = (
+    FlexitSensorEntityDescription(
+        key="air_filter_operating_time",
+        translation_key="air_filter_operating_time",
+        device_class=SensorDeviceClass.DURATION,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        native_unit_of_measurement=UnitOfTime.HOURS,
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        suggested_display_precision=0,
+        value_fn=lambda measurements: measurements.filter_running_hours,
+    ),
+    FlexitSensorEntityDescription(
+        key="heat_exchanger_regulation",
+        translation_key="heat_exchanger_regulation",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        native_unit_of_measurement=PERCENTAGE,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda measurements: measurements.heat_exchanger_regulation,
+    ),
+    FlexitSensorEntityDescription(
+        key="electric_heater_regulation",
+        translation_key="electric_heater_regulation",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        native_unit_of_measurement=PERCENTAGE,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda measurements: measurements.electric_heater_regulation,
+    ),
+    FlexitSensorEntityDescription(
+        key="cooling_regulation",
+        translation_key="cooling_regulation",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        native_unit_of_measurement=PERCENTAGE,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda measurements: measurements.cooling_regulation,
+    ),
+    FlexitSensorEntityDescription(
+        key="outdoor_air_temperature",
+        translation_key="outdoor_air_temperature",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda measurements: measurements.outdoor_air_temperature,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: FlexitConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Flexit sensor entities."""
+    coordinator = entry.runtime_data
+    async_add_entities(
+        FlexitSensor(coordinator, description) for description in SENSORS
+    )
+
+
+class FlexitSensor(FlexitEntity, SensorEntity):
+    """Representation of a Flexit sensor."""
+
+    entity_description: FlexitSensorEntityDescription
+
+    def __init__(
+        self,
+        coordinator: FlexitDataCoordinator,
+        entity_description: FlexitSensorEntityDescription,
+    ) -> None:
+        """Initialize the sensor."""
+        assert coordinator.config_entry is not None
+        super().__init__(coordinator)
+        self.entity_description = entity_description
+        self._attr_unique_id = (
+            f"{coordinator.config_entry.entry_id}-{entity_description.key}"
+        )
+
+    @property
+    @override
+    def native_value(self) -> StateType:
+        """Return the sensor value."""
+        return self.entity_description.value_fn(self.coordinator.device.measurements)

homeassistant/components/flexit/strings.json

@@ -64,6 +64,23 @@
       "filter_alarm": {
         "name": "Filter alarm"
       }
+    },
+    "sensor": {
+      "air_filter_operating_time": {
+        "name": "Air filter operating time"
+      },
+      "cooling_regulation": {
+        "name": "Cooling regulation"
+      },
+      "electric_heater_regulation": {
+        "name": "Electric heater regulation"
+      },
+      "heat_exchanger_regulation": {
+        "name": "Heat exchanger regulation"
+      },
+      "outdoor_air_temperature": {
+        "name": "Outdoor air temperature"
+      }
     }
   },
   "issues": {

homeassistant/components/frontend/manifest.json

@@ -22,5 +22,5 @@
   "integration_type": "system",
   "preview_features": { "winter_mode": {} },
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20260826.6"]
+  "requirements": ["home-assistant-frontend==20260826.7"]
 }

homeassistant/components/hassio/services.py

@@ -452,8 +452,9 @@ def async_register_network_storage_services(
 
     async def async_mount_reload(service: ServiceCall) -> None:
         """Handle service calls for Hass.io."""
+        # A mount is always a main device, and the check below reads its model
         device, _ = async_get_device_and_config_entry(
-            hass, DOMAIN, service.data[ATTR_DEVICE_ID]
+            hass, DOMAIN, service.data[ATTR_DEVICE_ID], include_child_devices=False
         )
 
         if device.name is None or device.model != SupervisorEntityModel.MOUNT:

homeassistant/components/hive/config_flow.py

@@ -50,12 +50,14 @@ async def async_step_user(
         # Login to Hive with user data.
         if user_input is not None:
             self.data.update(user_input)
+            username = self.data[CONF_USERNAME].lower()
             self.hive_auth = Auth(
-                username=self.data[CONF_USERNAME], password=self.data[CONF_PASSWORD]
+                username=username,
+                password=self.data[CONF_PASSWORD],
             )
 
             # Get user from existing entry and abort if already setup
-            await self.async_set_unique_id(self.data[CONF_USERNAME])
+            await self.async_set_unique_id(username)
             if self.context["source"] != SOURCE_REAUTH:
                 self._abort_if_unique_id_configured()