Sync with latest core - version for 2025.6 release

Author: markhannon

custom_components/zimi/__init__.py

@@ -51,7 +51,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ZimiConfigEntry) -> bool
         config_entry_id=entry.entry_id,
         identifiers={(DOMAIN, api.mac)},
         manufacturer=api.brand,
-        name=f"{api.network_name}",
+        name=api.network_name,
         model="Zimi Cloud Connect",
         sw_version=api.firmware_version,
         connections={(CONNECTION_NETWORK_MAC, api.mac)},

custom_components/zimi/cover.py

@@ -5,17 +5,12 @@
 import logging
 from typing import Any
 
-from zcc import ControlPoint
-from zcc.device import ControlPointDevice
-
 from homeassistant.components.cover import (
     CoverDeviceClass,
     CoverEntity,
     CoverEntityFeature,
 )
 from homeassistant.core import HomeAssistant
-
-# Import the device class from the component that you want to support
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import ZimiConfigEntry
@@ -31,9 +26,9 @@ async def async_setup_entry(
 ) -> None:
     """Set up the Zimi Cover platform."""
 
-    api: ControlPoint = config_entry.runtime_data
+    api = config_entry.runtime_data
 
-    doors: list[ZimiCover] = [ZimiCover(device, api) for device in api.doors]
+    doors = [ZimiCover(device, api) for device in api.doors]
 
     async_add_entities(doors)
 
@@ -49,15 +44,6 @@ class ZimiCover(ZimiEntity, CoverEntity):
         | CoverEntityFeature.STOP
     )
 
-    def __init__(self, device: ControlPointDevice, api: ControlPoint) -> None:
-        """Initialize an Zimicover."""
-
-        super().__init__(device, api)
-
-        _LOGGER.debug(
-            "Initialising ZimiCover %s in %s", self._device.name, self._device.room
-        )
-
     async def async_close_cover(self, **kwargs: Any) -> None:
         """Close the cover/door."""
         _LOGGER.debug("Sending close_cover() for %s", self.name)

custom_components/zimi/entity.py

@@ -21,23 +21,26 @@ class ZimiEntity(Entity):
     _attr_should_poll = False
     _attr_has_entity_name = True
 
-    def __init__(self, device: ControlPointDevice, api: ControlPoint) -> None:
+    def __init__(
+        self, device: ControlPointDevice, api: ControlPoint, use_device_name=True
+    ) -> None:
         """Initialize an HA Entity which is a ZimiDevice."""
 
         self._device = device
-        self._attr_unique_id = self._device.identifier
+        self._attr_unique_id = device.identifier
         self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, self._device.manufacture_info.identifier)},
-            manufacturer=self._device.manufacture_info.manufacturer,
-            model=self._device.manufacture_info.model,
-            name=self._device.manufacture_info.name,
+            identifiers={(DOMAIN, device.manufacture_info.identifier)},
+            manufacturer=device.manufacture_info.manufacturer,
+            model=device.manufacture_info.model,
+            name=device.manufacture_info.name,
             hw_version=device.manufacture_info.hwVersion,
             sw_version=device.manufacture_info.firmwareVersion,
             suggested_area=device.room,
             via_device=(DOMAIN, api.mac),
         )
-        self._attr_name = self._device.name.strip()
-        self._attr_suggested_area = self._device.room
+        if use_device_name:
+            self._attr_name = device.name.strip()
+        self._attr_suggested_area = device.room
 
     @property
     def available(self) -> bool:

custom_components/zimi/fan.py

@@ -6,13 +6,8 @@
 import math
 from typing import Any
 
-from zcc import ControlPoint
-from zcc.device import ControlPointDevice
-
 from homeassistant.components.fan import FanEntity, FanEntityFeature
 from homeassistant.core import HomeAssistant
-
-# Import the device class from the component that you want to support
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util.percentage import (
     percentage_to_ranged_value,
@@ -31,50 +26,39 @@ async def async_setup_entry(
     config_entry: ZimiConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up the Zimi Cover platform."""
+    """Set up the Zimi Fan platform."""
 
-    api: ControlPoint = config_entry.runtime_data
+    api = config_entry.runtime_data
 
-    fans: list[ZimiFan] = [ZimiFan(device, api) for device in api.fans]
-
-    async_add_entities(fans)
+    async_add_entities([ZimiFan(device, api) for device in api.fans])
 
 
 class ZimiFan(ZimiEntity, FanEntity):
     """Representation of a Zimi fan."""
 
+    _attr_speed_range = (0, 7)
+
     _attr_supported_features = (
         FanEntityFeature.SET_SPEED
         | FanEntityFeature.TURN_OFF
         | FanEntityFeature.TURN_ON
     )
 
-    def __init__(self, device: ControlPointDevice, api: ControlPoint) -> None:
-        """Initialize an ZimiFan."""
-
-        super().__init__(device, api)
-
-        _LOGGER.debug(
-            "Initialising ZimiFan %s in %s", self._device.name, self._device.room
-        )
-
-        self._speed = self._device.fanspeed
-
     async def async_set_percentage(self, percentage: int) -> None:
         """Set the desired speed for the fan."""
-        _LOGGER.debug("Sending async_set_percentage() with percentage %s", percentage)
 
         if percentage == 0:
             await self.async_turn_off()
             return
 
         target_speed = math.ceil(
-            percentage_to_ranged_value(self._speed_range, percentage)
+            percentage_to_ranged_value(self._attr_speed_range, percentage)
         )
+
         _LOGGER.debug(
-            "async_set_percentage() converted percentage %s to speed %s",
+            "Sending async_set_percentage() for %s with percentage %s",
+            self.name,
             percentage,
-            target_speed,
         )
 
         await self._device.set_fanspeed(target_speed)
@@ -94,21 +78,17 @@ async def async_turn_off(self, **kwargs: Any) -> None:
         """Instruct the fan to turn off."""
 
         _LOGGER.debug("Sending turn_off() for %s", self.name)
+
         await self._device.turn_off()
 
     @property
     def percentage(self) -> int:
         """Return the current speed percentage for the fan."""
         if not self._device.fanspeed:
             return 0
-        return ranged_value_to_percentage(self._speed_range, self._device.fanspeed)
-
-    @property
-    def _speed_range(self) -> tuple[int, int]:
-        """Return the range of speeds."""
-        return (0, 7)
+        return ranged_value_to_percentage(self._attr_speed_range, self._device.fanspeed)
 
     @property
     def speed_count(self) -> int:
         """Return the number of speeds the fan supports."""
-        return int_states_in_range(self._speed_range)
+        return int_states_in_range(self._attr_speed_range)

custom_components/zimi/light.py

@@ -32,7 +32,7 @@ async def async_setup_entry(
     ]
 
     lights.extend(
-        [ZimiDimmer(device, api) for device in api.lights if device.type == "dimmer"]
+        ZimiDimmer(device, api) for device in api.lights if device.type == "dimmer"
     )
 
     async_add_entities(lights)
@@ -81,8 +81,6 @@ def __init__(self, device: ControlPointDevice, api: ControlPoint) -> None:
         super().__init__(device, api)
         self._attr_color_mode = ColorMode.BRIGHTNESS
         self._attr_supported_color_modes = {ColorMode.BRIGHTNESS}
-        if self._device.type != "dimmer":
-            raise ValueError("ZimiDimmer needs a dimmable light")
 
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Instruct the light to turn on (with optional brightness)."""

custom_components/zimi/manifest.json

@@ -4,12 +4,12 @@
   "codeowners": [
     "@markhannon"
   ],
-  "version": "2.0.3",
+  "version": "2.0.4",
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/zimi",
   "iot_class": "local_push",
   "quality_scale": "bronze",
   "requirements": [
-    "zcc-helper==3.5"
+    "zcc-helper==3.5.2"
   ]
 }

custom_components/zimi/sensor.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
+from dataclasses import dataclass
 import logging
 
 from zcc import ControlPoint
@@ -15,40 +17,45 @@
 from homeassistant.const import PERCENTAGE, EntityCategory, UnitOfTemperature
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.typing import StateType
 
 from . import ZimiConfigEntry
 from .entity import ZimiEntity
 
-SENSOR_KEY_DOOR_TEMP = "door_temperature"
-SENSOR_KEY_GARAGE_BATTERY = "garage_battery"
-SENSOR_KEY_GARAGE_HUMDITY = "garage_humidty"
-SENSOR_KEY_GARAGE_TEMP = "garage_temperature"
 
-GARAGE_SENSOR_DESCRIPTIONS = (
-    SensorEntityDescription(
-        key=SENSOR_KEY_DOOR_TEMP,
-        name="Outside temperature",
+@dataclass(frozen=True, kw_only=True)
+class ZimiSensorEntityDescription(SensorEntityDescription):
+    """Class describing Zimi sensor entities."""
+
+    value_fn: Callable[[ControlPointDevice], StateType]
+
+
+GARAGE_SENSOR_DESCRIPTIONS: tuple[ZimiSensorEntityDescription, ...] = (
+    ZimiSensorEntityDescription(
+        key="door_temperature",
+        translation_key="door_temperature",
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
+        value_fn=lambda device: device.door_temp,
     ),
-    SensorEntityDescription(
-        key=SENSOR_KEY_GARAGE_BATTERY,
-        name="Battery Level",
+    ZimiSensorEntityDescription(
+        key="garage_battery",
         native_unit_of_measurement=PERCENTAGE,
         entity_category=EntityCategory.DIAGNOSTIC,
         device_class=SensorDeviceClass.BATTERY,
+        value_fn=lambda device: device.battery_level,
     ),
-    SensorEntityDescription(
-        key=SENSOR_KEY_GARAGE_TEMP,
-        name="Garage temperature",
+    ZimiSensorEntityDescription(
+        key="garage_temperature",
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=SensorDeviceClass.TEMPERATURE,
+        value_fn=lambda device: device.garage_temp,
     ),
-    SensorEntityDescription(
-        key=SENSOR_KEY_GARAGE_HUMDITY,
-        name="Garage humidity",
+    ZimiSensorEntityDescription(
+        key="garage_humidty",
         native_unit_of_measurement=PERCENTAGE,
         device_class=SensorDeviceClass.HUMIDITY,
+        value_fn=lambda device: device.garage_humidity,
     ),
 )
 
@@ -62,50 +69,35 @@ async def async_setup_entry(
 ) -> None:
     """Set up the Zimi Sensor platform."""
 
-    api: ControlPoint = config_entry.runtime_data
+    api = config_entry.runtime_data
 
-    for description in GARAGE_SENSOR_DESCRIPTIONS:
-        sensors: list[ZimiSensor] = [
-            ZimiSensor(device, description, api) for device in api.sensors
-        ]
-
-        async_add_entities(sensors)
+    async_add_entities(
+        ZimiSensor(device, description, api)
+        for device in api.sensors
+        for description in GARAGE_SENSOR_DESCRIPTIONS
+    )
 
 
 class ZimiSensor(ZimiEntity, SensorEntity):
     """Representation of a Zimi sensor."""
 
+    entity_description: ZimiSensorEntityDescription
+
     def __init__(
         self,
         device: ControlPointDevice,
-        description: SensorEntityDescription,
+        description: ZimiSensorEntityDescription,
         api: ControlPoint,
     ) -> None:
         """Initialize an ZimiSensor with specified type."""
 
-        super().__init__(device, api)
+        super().__init__(device, api, use_device_name=False)
 
         self.entity_description = description
         self._attr_unique_id = device.identifier + "." + self.entity_description.key
 
-        _LOGGER.debug(
-            "Initialising ZimiSensor %s in %s", self._device.name, self._device.room
-        )
-
     @property
-    def native_value(self) -> float | None:
+    def native_value(self) -> StateType:
         """Return the state of the sensor."""
 
-        if self.entity_description.key == SENSOR_KEY_DOOR_TEMP:
-            return self._device.door_temp
-
-        if self.entity_description.key == SENSOR_KEY_GARAGE_BATTERY:
-            return self._device.battery_level
-
-        if self.entity_description.key == SENSOR_KEY_GARAGE_HUMDITY:
-            return self._device.garage_humidity
-
-        if self.entity_description.key == SENSOR_KEY_GARAGE_TEMP:
-            return self._device.garage_temp
-
-        return None
+        return self.entity_description.value_fn(self._device)

custom_components/zimi/strings.json

@@ -27,20 +27,27 @@
           "port": "[%key:common::config_flow::data::port%]"
         },
         "data_description": {
-          "host": "Mandatory - ZCC IP address.",
-          "port": "Mandatory - ZCC port number (default=5003)."
+          "host": "[%key:component::zimi::config::step::selection::data_description::host%]",
+          "port": "[%key:component::zimi::config::step::selection::data_description::port%]"
         }
       }
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "unknown": "[%key:common::config_flow::error::unknown%]",
-      "timeout": "Connection timed out",
-      "invalid_host": "Invalid hostname",
+      "timeout": "[%key:common::config_flow::error::timeout_connect%]",
+      "invalid_host": "[%key:common::config_flow::error::invalid_host%]",
       "connection_refused": "Connection refused"
     },
     "abort": {
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
     }
+  },
+  "entity": {
+    "sensor": {
+      "door_temperature": {
+        "name": "Outside temperature"
+      }
+    }
   }
 }