[pull] dev from home-assistant:dev

homeassistant/components/collection_image/image.py

@@ -5,9 +5,10 @@
 import random
 from typing import override
 
-from homeassistant.components.image import ImageEntity
+from homeassistant.components.image import DEFAULT_CONTENT_TYPE, ImageEntity
 from homeassistant.components.media_player import (
     BrowseError,
+    BrowseMedia,
     MediaClass,
     async_process_play_media_url,
 )
@@ -51,8 +52,6 @@ async def async_setup_entry(
 class CollectionImageImageEntity(ImageEntity):
     """Implement the image entity for Collection Image."""
 
-    _unavailable_logged: bool = False
-
     path: Path | None
 
     def __init__(
@@ -69,80 +68,80 @@ def __init__(
         self._attr_name = name
         self.media_content_id = media_content_id
 
-    async def get_next_image(self) -> None:
-        """Update the image entity with the next image from the source media."""
-
+    def set_unavailable(self) -> None:
+        """Set the entity to unavailable state."""
+        self._attr_available = False
+        self.path = None
+        self._attr_image_url = UNDEFINED
         self._cached_image = None
+        self.async_write_ha_state()
 
-        def set_unavailable() -> None:
-            self._unavailable_logged = True
-            self._attr_available = False
-            self.path = None
-            self._attr_image_url = UNDEFINED
-            self.async_write_ha_state()
-
+    async def get_valid_images(self) -> list[BrowseMedia]:
+        """Given the configured media directory for the entity, get a list of all child images."""
         try:
             media = await async_browse_media(self.hass, self.media_content_id)
         except BrowseError as err:
-            if not self._unavailable_logged:
-                _LOGGER.info("%s: %s", self.entity_id, str(err))
-            set_unavailable()
-            return
+            _LOGGER.warning("%s: %s", self.entity_id, str(err))
+            return []
 
-        if media.children and (
-            filtered := [
-                item for item in media.children if item.media_class == MediaClass.IMAGE
-            ]
-        ):
-            child = random.choice(filtered)
-            try:
-                resolved = await async_resolve_media(
-                    self.hass, child.media_content_id, self.entity_id
-                )
-            except Unresolvable as err:
-                if not self._unavailable_logged:
-                    _LOGGER.info("%s: %s", self.entity_id, str(err))
-                set_unavailable()
-                return
-
-            if resolved.url:
-                self.path = None
-                self._attr_image_url = async_process_play_media_url(
-                    self.hass, resolved.url
-                )
-            else:
-                self.path = resolved.path
-                self._attr_image_url = UNDEFINED
-
-            self._attr_content_type = resolved.mime_type
-            self._attr_available = True
-            self._attr_image_last_updated = dt_util.utcnow()
-            if self._unavailable_logged:
-                _LOGGER.info(
-                    "%s: Has become available again",
-                    self.entity_id,
-                )
-            self._unavailable_logged = False
-            self.async_write_ha_state()
-            return
-
-        if not self._unavailable_logged:
-            _LOGGER.info(
+        images = [
+            item
+            for item in (media.children or [])
+            if item.media_class == MediaClass.IMAGE
+        ]
+        if not images:
+            _LOGGER.warning(
                 "%s: No valid images in %s",
                 self.entity_id,
                 self.media_content_id,
             )
-        set_unavailable()
-        return
+        return images
+
+    async def get_random_image(self) -> None:
+        """Update the image entity with a random image from the source media."""
+
+        filtered = await self.get_valid_images()
+        if not filtered:
+            self.set_unavailable()
+            return
+
+        child = random.choice(filtered)
+        self._attr_available = True
+        await self.update_image(child.media_content_id)
+
+    async def update_image(self, image_id: str):
+        """Update the entity from the image_id."""
+        self._cached_image = None
+        try:
+            resolved = await async_resolve_media(self.hass, image_id, self.entity_id)
+        except Unresolvable as err:
+            _LOGGER.warning("%s: %s", self.entity_id, str(err))
+            self._attr_image_last_updated = None
+            self.path = None
+            self._attr_image_url = UNDEFINED
+            self._attr_content_type = DEFAULT_CONTENT_TYPE
+            self.async_write_ha_state()
+            return
+
+        if resolved.url:
+            self.path = None
+            self._attr_image_url = async_process_play_media_url(self.hass, resolved.url)
+        else:
+            self.path = resolved.path
+            self._attr_image_url = UNDEFINED
+
+        self._attr_content_type = resolved.mime_type
+        self._attr_image_last_updated = dt_util.utcnow()
+        self.async_write_ha_state()
 
     @override
     async def async_added_to_hass(self) -> None:
         """Initialize the first image after entity has been created."""
 
-        async def get_next_image_on_start(_hass: HomeAssistant) -> None:
-            await self.get_next_image()
+        async def get_random_image_on_start(_hass: HomeAssistant) -> None:
+            await self.get_random_image()
 
-        self.async_on_remove(async_at_started(self.hass, get_next_image_on_start))
+        self.async_on_remove(async_at_started(self.hass, get_random_image_on_start))
 
     @override
     def image(self) -> bytes | None:

homeassistant/components/collection_image/services.py

@@ -19,5 +19,5 @@ def async_setup_services(hass: HomeAssistant) -> None:
         SERVICE_SHUFFLE,
         entity_domain=IMAGE_DOMAIN,
         schema={},
-        func="get_next_image",
+        func="get_random_image",
     )

homeassistant/components/duco/coordinator.py

@@ -10,7 +10,6 @@
     DucoConnectionError,
     DucoError,
     DucoResponseError,
-    DucoUnsupportedCapabilityError,
 )
 from duco_connectivity.models import (
     BoardInfo,
@@ -52,9 +51,6 @@ class DucoCoordinator(DataUpdateCoordinator[DucoData]):
 
     config_entry: DucoConfigEntry
     board_info: BoardInfo
-    _supports_time_filter_remain: bool
-    _supports_ventilation_temperatures: bool
-    _supports_bypass_supply_temperature_targets: bool
     _configured_node_names: dict[int, str]
 
     def __init__(
@@ -73,9 +69,6 @@ def __init__(
         )
         self.client = client
         self._configured_node_names = {}
-        self._supports_time_filter_remain = True
-        self._supports_ventilation_temperatures = True
-        self._supports_bypass_supply_temperature_targets = True
 
     async def _async_load_node_names(self) -> None:
         """Load configured Duco node names during setup."""
@@ -183,48 +176,37 @@ async def _async_update_data(self) -> DucoData:
 
         # Heat recovery info only backs the optional filter timer sensor, so
         # failures on this supplemental endpoint should not make the primary
-        # node entities unavailable.
+        # node entities unavailable. A None result leaves the sensor absent
+        # but keeps the helper pollable so data can appear on a later refresh.
         time_filter_remain = None
-        if self._supports_time_filter_remain:
-            with suppress(DucoError):
-                time_filter_remain = await self.client.async_get_time_filter_remaining()
-                self._supports_time_filter_remain = time_filter_remain is not None
+        with suppress(DucoError):
+            time_filter_remain = await self.client.async_get_time_filter_remaining()
 
         ventilation_temperatures = (
             self.data.ventilation_temperatures if self.data else None
         )
-        if self._supports_ventilation_temperatures:
-            try:
-                ventilation_temperatures = (
-                    await self.client.async_get_ventilation_temperature_info()
-                )
-            except DucoUnsupportedCapabilityError:
-                ventilation_temperatures = None
-                self._supports_ventilation_temperatures = False
-            except DucoError as err:
-                _LOGGER.debug(
-                    "Could not fetch Duco ventilation temperatures", exc_info=err
-                )
+        try:
+            ventilation_temperatures = (
+                await self.client.async_get_ventilation_temperature_info()
+            )
+        except DucoError as err:
+            _LOGGER.debug("Could not fetch Duco ventilation temperatures", exc_info=err)
 
         bypass_supply_temperature_targets: dict[int, BypassSupplyTemperatureTarget] = {}
-        if self._supports_bypass_supply_temperature_targets:
-            try:
-                bypass_supply_temperature_targets = (
-                    await self.client.async_get_bypass_supply_temperature_targets()
-                )
-            except DucoUnsupportedCapabilityError:
-                bypass_supply_temperature_targets = {}
-                self._supports_bypass_supply_temperature_targets = False
-            except DucoConnectionError as err:
-                raise UpdateFailed(
-                    translation_domain=DOMAIN,
-                    translation_key="cannot_connect",
-                ) from err
-            except DucoError as err:
-                raise UpdateFailed(
-                    translation_domain=DOMAIN,
-                    translation_key="api_error",
-                ) from err
+        try:
+            bypass_supply_temperature_targets = (
+                await self.client.async_get_bypass_supply_temperature_targets()
+            )
+        except DucoConnectionError as err:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="cannot_connect",
+            ) from err
+        except DucoError as err:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="api_error",
+            ) from err
 
         return DucoData(
             nodes={node.node_id: node for node in nodes},

homeassistant/components/duco/manifest.json

@@ -13,7 +13,7 @@
   "iot_class": "local_polling",
   "loggers": ["duco_connectivity"],
   "quality_scale": "platinum",
-  "requirements": ["python-duco-connectivity==0.13.1"],
+  "requirements": ["python-duco-connectivity==0.14.0"],
   "zeroconf": [
     {
       "name": "duco [[][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f][]].*",

homeassistant/components/duco/number.py

@@ -1,6 +1,5 @@
 """Number platform for the Duco integration."""
 
-from decimal import ROUND_DOWN, ROUND_HALF_UP, Decimal
 import logging
 from typing import override
 
@@ -56,14 +55,6 @@ def _async_add_new_entities() -> None:
                 if (description.key, zone_id) in known_entities:
                     continue
 
-                # Skip incomplete metadata because guessing valid limits would expose an invalid control.
-                if (
-                    target.minimum is None
-                    or target.maximum is None
-                    or target.increment is None
-                ):
-                    continue
-
                 known_entities.add((description.key, zone_id))
                 new_entities.append(
                     DucoBypassSupplyTemperatureTargetNumber(
@@ -130,32 +121,18 @@ def native_value(self) -> float | None:
         )
         return target.value if target else None
 
-    def _normalize_step_value(self, value: float) -> float:
-        """Normalize converted temperature values to the nearest supported native step."""
-        if self.unit_of_measurement == self.native_unit_of_measurement:
-            return value
-
-        # Home Assistant converts service values from the configured temperature
-        # unit first, which can land between valid Duco Celsius increments.
-        minimum = Decimal(str(self.native_min_value))
-        step = Decimal(str(self.native_step))
-        steps = ((Decimal(str(value)) - minimum) / step).to_integral_value(
-            rounding=ROUND_HALF_UP
-        )
-        # Rounding up may overshoot when the range is not a whole number of steps.
-        max_steps = (
-            (Decimal(str(self.native_max_value)) - minimum) / step
-        ).to_integral_value(rounding=ROUND_DOWN)
-        return float(minimum + (min(steps, max_steps) * step))
-
     @override
     async def async_set_native_value(self, value: float) -> None:
         """Set the bypass supply temperature target."""
-        value = self._normalize_step_value(value)
-        if (
-            (Decimal(str(value)) - Decimal(str(self.native_min_value)))
-            / Decimal(str(self.native_step))
-        ) % 1 != 0:
+        target = self.coordinator.data.bypass_supply_temperature_targets[self._zone_id]
+
+        try:
+            if self.unit_of_measurement != self.native_unit_of_measurement:
+                value = target.normalize_value(value)
+            await self.coordinator.client.async_set_bypass_supply_temperature_target(
+                self._zone_id, value, target=target
+            )
+        except ValueError as err:
             raise HomeAssistantError(
                 translation_domain=DOMAIN,
                 translation_key="invalid_bypass_supply_temperature_target_step",
@@ -164,12 +141,7 @@ async def async_set_native_value(self, value: float) -> None:
                     "minimum": str(self.native_min_value),
                     "increment": str(self.native_step),
                 },
-            )
-
-        try:
-            await self.coordinator.client.async_set_bypass_supply_temperature_target(
-                self._zone_id, value
-            )
+            ) from err
         except DucoRateLimitError as err:
             _LOGGER.warning(
                 "Duco write rate limit exceeded for bypass target zone %s",

homeassistant/components/hdfury/manifest.json

@@ -7,7 +7,7 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "quality_scale": "platinum",
-  "requirements": ["hdfury==1.6.0"],
+  "requirements": ["hdfury==1.6.1"],
   "zeroconf": [
     { "name": "diva-*", "type": "_http._tcp.local." },
     { "name": "vertex2-*", "type": "_http._tcp.local." },