[pull] dev from home-assistant:dev

.strict-typing

@@ -419,6 +419,7 @@ homeassistant.components.plugwise.*
 homeassistant.components.pooldose.*
 homeassistant.components.portainer.*
 homeassistant.components.powerfox.*
+homeassistant.components.powerfox_local.*
 homeassistant.components.powerwall.*
 homeassistant.components.private_ble_device.*
 homeassistant.components.prometheus.*

homeassistant/brands/powerfox.json

@@ -0,0 +1,5 @@
+{
+  "domain": "powerfox",
+  "name": "Powerfox",
+  "integrations": ["powerfox", "powerfox_local"]
+}

homeassistant/components/cambridge_audio/manifest.json

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

homeassistant/components/ecovacs/__init__.py

@@ -38,12 +38,11 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 async def async_setup_entry(hass: HomeAssistant, entry: EcovacsConfigEntry) -> bool:
     """Set up this integration using UI."""
     controller = EcovacsController(hass, entry.data)
-    await controller.initialize()
 
-    async def on_unload() -> None:
-        await controller.teardown()
+    entry.async_on_unload(controller.teardown)
+
+    await controller.initialize()
 
-    entry.async_on_unload(on_unload)
     entry.runtime_data = controller
 
     async def _async_wait_connect(device: VacBot) -> None:

homeassistant/components/homematicip_cloud/light.py

@@ -22,6 +22,7 @@
     PluggableDimmer,
     SwitchMeasuring,
     WiredDimmer3,
+    WiredPushButton,
 )
 from packaging.version import Version
 
@@ -93,6 +94,20 @@ async def async_setup_entry(
             (Dimmer, PluggableDimmer, BrandDimmer, FullFlushDimmer),
         ):
             entities.append(HomematicipDimmer(hap, device))
+        elif isinstance(device, WiredPushButton):
+            optical_channels = sorted(
+                (
+                    ch
+                    for ch in device.functionalChannels
+                    if ch.functionalChannelType
+                    == FunctionalChannelType.OPTICAL_SIGNAL_CHANNEL
+                ),
+                key=lambda ch: ch.index,
+            )
+            for led_number, ch in enumerate(optical_channels, start=1):
+                entities.append(
+                    HomematicipOpticalSignalLight(hap, device, ch.index, led_number)
+                )
 
     async_add_entities(entities)
 
@@ -421,3 +436,129 @@ def _convert_color(color: tuple) -> RGBColorState:
     if 270 < hue <= 330:
         return RGBColorState.PURPLE
     return RGBColorState.RED
+
+
+class HomematicipOpticalSignalLight(HomematicipGenericEntity, LightEntity):
+    """Representation of HomematicIP WiredPushButton LED light."""
+
+    _attr_color_mode = ColorMode.HS
+    _attr_supported_color_modes = {ColorMode.HS}
+    _attr_supported_features = LightEntityFeature.EFFECT
+    _attr_translation_key = "optical_signal_light"
+
+    _effect_to_behaviour: dict[str, OpticalSignalBehaviour] = {
+        "on": OpticalSignalBehaviour.ON,
+        "blinking": OpticalSignalBehaviour.BLINKING_MIDDLE,
+        "flash": OpticalSignalBehaviour.FLASH_MIDDLE,
+        "billow": OpticalSignalBehaviour.BILLOW_MIDDLE,
+    }
+    _behaviour_to_effect: dict[OpticalSignalBehaviour, str] = {
+        v: k for k, v in _effect_to_behaviour.items()
+    }
+
+    _attr_effect_list = list(_effect_to_behaviour)
+
+    _color_switcher: dict[str, tuple[float, float]] = {
+        RGBColorState.WHITE: (0.0, 0.0),
+        RGBColorState.RED: (0.0, 100.0),
+        RGBColorState.YELLOW: (60.0, 100.0),
+        RGBColorState.GREEN: (120.0, 100.0),
+        RGBColorState.TURQUOISE: (180.0, 100.0),
+        RGBColorState.BLUE: (240.0, 100.0),
+        RGBColorState.PURPLE: (300.0, 100.0),
+    }
+
+    def __init__(
+        self,
+        hap: HomematicipHAP,
+        device: WiredPushButton,
+        channel_index: int,
+        led_number: int,
+    ) -> None:
+        """Initialize the optical signal light entity."""
+        super().__init__(
+            hap,
+            device,
+            post=f"LED {led_number}",
+            channel=channel_index,
+            is_multi_channel=True,
+            channel_real_index=channel_index,
+        )
+
+    @property
+    def is_on(self) -> bool:
+        """Return true if light is on."""
+        channel = self.get_channel_or_raise()
+        return channel.on is True
+
+    @property
+    def brightness(self) -> int:
+        """Return the brightness of this light between 0..255."""
+        channel = self.get_channel_or_raise()
+        return int((channel.dimLevel or 0.0) * 255)
+
+    @property
+    def hs_color(self) -> tuple[float, float]:
+        """Return the hue and saturation color value [float, float]."""
+        channel = self.get_channel_or_raise()
+        simple_rgb_color = channel.simpleRGBColorState
+        return self._color_switcher.get(simple_rgb_color, (0.0, 0.0))
+
+    @property
+    def effect(self) -> str | None:
+        """Return the current effect."""
+        channel = self.get_channel_or_raise()
+        return self._behaviour_to_effect.get(channel.opticalSignalBehaviour)
+
+    @property
+    def extra_state_attributes(self) -> dict[str, Any]:
+        """Return the state attributes of the optical signal light."""
+        state_attr = super().extra_state_attributes
+        channel = self.get_channel_or_raise()
+
+        if self.is_on:
+            state_attr[ATTR_COLOR_NAME] = channel.simpleRGBColorState
+
+        return state_attr
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Turn the light on."""
+        # Use hs_color from kwargs, if not applicable use current hs_color.
+        hs_color = kwargs.get(ATTR_HS_COLOR, self.hs_color)
+        simple_rgb_color = _convert_color(hs_color)
+
+        # If no kwargs, use default value.
+        brightness = 255
+        if ATTR_BRIGHTNESS in kwargs:
+            brightness = kwargs[ATTR_BRIGHTNESS]
+
+        # Minimum brightness is 10, otherwise the LED is disabled
+        brightness = max(10, brightness)
+        dim_level = round(brightness / 255.0, 2)
+
+        effect = self.effect
+        if ATTR_EFFECT in kwargs:
+            effect = kwargs[ATTR_EFFECT]
+        elif effect is None:
+            effect = "on"
+
+        behaviour = self._effect_to_behaviour.get(effect, OpticalSignalBehaviour.ON)
+
+        await self._device.set_optical_signal_async(
+            channelIndex=self._channel,
+            opticalSignalBehaviour=behaviour,
+            rgb=simple_rgb_color,
+            dimLevel=dim_level,
+        )
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn the light off."""
+        channel = self.get_channel_or_raise()
+        simple_rgb_color = channel.simpleRGBColorState
+
+        await self._device.set_optical_signal_async(
+            channelIndex=self._channel,
+            opticalSignalBehaviour=OpticalSignalBehaviour.OFF,
+            rgb=simple_rgb_color,
+            dimLevel=0.0,
+        )

homeassistant/components/homematicip_cloud/strings.json

@@ -28,6 +28,20 @@
     }
   },
   "entity": {
+    "light": {
+      "optical_signal_light": {
+        "state_attributes": {
+          "effect": {
+            "state": {
+              "billow": "Billow",
+              "blinking": "Blinking",
+              "flash": "Flash",
+              "on": "[%key:common::state::on%]"
+            }
+          }
+        }
+      }
+    },
     "sensor": {
       "smoke_detector_alarm_counter": {
         "name": "Alarm counter"

homeassistant/components/iometer/sensor.py

@@ -86,6 +86,22 @@ class IOmeterEntityDescription(SensorEntityDescription):
         options=["entered", "pending", "missing", "unknown"],
         value_fn=lambda data: data.status.device.core.pin_status or STATE_UNKNOWN,
     ),
+    IOmeterEntityDescription(
+        key="consumption_tariff_t1",
+        translation_key="consumption_tariff_t1",
+        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+        device_class=SensorDeviceClass.ENERGY,
+        state_class=SensorStateClass.TOTAL,
+        value_fn=lambda data: data.reading.get_consumption_tariff_T1(),
+    ),
+    IOmeterEntityDescription(
+        key="consumption_tariff_t2",
+        translation_key="consumption_tariff_t2",
+        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+        device_class=SensorDeviceClass.ENERGY,
+        state_class=SensorStateClass.TOTAL,
+        value_fn=lambda data: data.reading.get_consumption_tariff_T2(),
+    ),
     IOmeterEntityDescription(
         key="total_consumption",
         translation_key="total_consumption",

homeassistant/components/iometer/strings.json

@@ -39,6 +39,12 @@
       "battery_level": {
         "name": "Battery level"
       },
+      "consumption_tariff_t1": {
+        "name": "Consumption Tariff T1"
+      },
+      "consumption_tariff_t2": {
+        "name": "Consumption Tariff T2"
+      },
       "core_bridge_rssi": {
         "name": "Signal strength Core/Bridge"
       },

homeassistant/components/liebherr/const.py

@@ -1,6 +1,9 @@
 """Constants for the liebherr integration."""
 
+from datetime import timedelta
 from typing import Final
 
 DOMAIN: Final = "liebherr"
 MANUFACTURER: Final = "Liebherr"
+
+REFRESH_DELAY: Final = timedelta(seconds=5)

homeassistant/components/liebherr/entity.py

@@ -2,12 +2,22 @@
 
 from __future__ import annotations
 
-from pyliebherrhomeapi import TemperatureControl, ZonePosition
-
+import asyncio
+from collections.abc import Coroutine
+from typing import Any
+
+from pyliebherrhomeapi import (
+    LiebherrConnectionError,
+    LiebherrTimeoutError,
+    TemperatureControl,
+    ZonePosition,
+)
+
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import DOMAIN, MANUFACTURER
+from .const import DOMAIN, MANUFACTURER, REFRESH_DELAY
 from .coordinator import LiebherrCoordinator
 
 # Zone position to translation key mapping
@@ -44,6 +54,22 @@ def __init__(
             model_id=device.device_name,
         )
 
+    async def _async_send_command(
+        self,
+        command: Coroutine[Any, Any, None],
+    ) -> None:
+        """Send a command with error handling and delayed refresh."""
+        try:
+            await command
+        except (LiebherrConnectionError, LiebherrTimeoutError) as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="communication_error",
+            ) from err
+
+        await asyncio.sleep(REFRESH_DELAY.total_seconds())
+        await self.coordinator.async_request_refresh()
+
 
 class LiebherrZoneEntity(LiebherrEntity):
     """Base entity for zone-based Liebherr entities.