entity: move common entity helpers

Author: vooon

custom_components/myheat/api.py

@@ -95,7 +95,7 @@
                     "dataActual": bool,
                     "severity": int,
                     "severityDesc": str,
-                    "weatherTemp": float,
+                    "weatherTemp": vol.Coerce(float),
                     "city": str,
                 },
                 extra=vol.ALLOW_EXTRA,

custom_components/myheat/binary_sensor.py

@@ -9,7 +9,7 @@
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
 from .const import CONF_NAME, DEFAULT_NAME, DOMAIN
-from .entity import MhEntity
+from .entity import MhEngEntity, MhEntity, MhEnvEntity, MhHeaterEntity
 
 _logger = logging.getLogger(__package__)
 
@@ -27,6 +27,7 @@ async def async_setup_entry(
     async_add_entities(
         [
             MhSeverityBinarySensor(coordinator, entry),
+            MhDataActualBinarySensor(coordinator, entry),
         ]
         + list(
             chain.from_iterable(
@@ -39,150 +40,129 @@ async def async_setup_entry(
             )
         )
         + list(
-            MhEngBinarySensor(coordinator, entry, eng)
-            for eng in coordinator.data.get("engs", [])
+            MhEnvSeverityBinarySensor(coordinator, entry, env)
+            for env in coordinator.data.get("envs", [])
+        )
+        + list(
+            chain.from_iterable(
+                [
+                    MhEngTurnedOnBinarySensor(coordinator, entry, eng),
+                    MhEngSeverityBinarySensor(coordinator, entry, eng),
+                ]
+                for eng in coordinator.data.get("engs", [])
+            )
         )
     )
 
 
-class MhHeaterBinarySensor(MhEntity, BinarySensorEntity):
-    """myheat Binary Sensor class."""
-
-    _key = ""
+class MhDataActualBinarySensor(MhEntity, BinarySensorEntity):
+    """myheat Data Actual (connected) Binary Sensor class."""
 
-    def __init__(self, coordinator, config_entry, heater: dict):
-        super().__init__(coordinator, config_entry)
-        self.heater_name = heater["name"]
-        self.heater_id = heater["id"]
+    _attr_device_class = "connectivity"
 
     @property
-    def name(self):
-        """Return the name of the sensor."""
-        name = self.config_entry.data.get(CONF_NAME, DEFAULT_NAME)
-        return f"{name} {self.heater_name} {self._key}"
+    def name(self) -> str:
+        return f"{self._mh_name} dataActual"
 
     @property
     def unique_id(self):
-        """Return a unique ID to use for this entity."""
-        return f"{super().unique_id}htr{self.heater_id}{self._key}"
-
-    @property
-    def is_on(self):
-        """Return true if the binary_sensor is on."""
-        return self._heater().get(self._key)
-
-    @property
-    def _mh_dev_name_suffix(self):
-        return f" {self.heater_name}"
+        return f"{super().unique_id}dataActual"
 
     @property
-    def _mh_identifiers(self):
-        return (DOMAIN, f"{super().unique_id}htr{self.heater_id}")
-
-    def _heater(self) -> dict:
-        if not self.coordinator.data.get("dataActual", False):
-            _logger.warninig("data not actual! %s", self.coordinator.data)
-            return {}
-
-        heaters = self.coordinator.data.get("heaters", [])
-        for h in heaters:
-            if h["id"] == self.heater_id:
-                return h
-        return {}
-
-
-class MhHeaterDisabledBinarySensor(MhHeaterBinarySensor):
-    _key = "disabled"
-    _attr_icon = "mdi:electric-switch"
-    _attr_device_class = None
-
-
-class MhHeaterBurnerWaterBinarySensor(MhHeaterBinarySensor):
-    _key = "burnerWater"
-    _attr_icon = "mdi:fire"
-    _attr_device_class = "heat"
-
-
-class MhHeaterBurnerHeatingBinarySensor(MhHeaterBinarySensor):
-    _key = "burnerHeating"
-    _attr_icon = "mdi:fire"
-    _attr_device_class = "heat"
-
+    def is_on(self) -> bool | None:
+        return self.coordinator.data.get("dataActual")
 
-class MhSeverityBinarySensor(MhEntity, BinarySensorEntity):
-    """myheat Binary Sensor class."""
 
+class MhSeverityBinarySensorBase(BinarySensorEntity):
     _attr_device_class = "problem"
-    _attr_icon = "mdi:water-boiler-alert"
 
-    @property
-    def name(self) -> str:
-        """Return the name of the sensor."""
-        name = self.config_entry.data.get(CONF_NAME, DEFAULT_NAME)
-        return f"{name} severity"
-
-    @property
-    def unique_id(self):
-        """Return a unique ID to use for this entity."""
-        return f"{super().unique_id}severity"
+    def _severity(self) -> (int | None, str | None):
+        return None, None
 
     @property
     def is_on(self) -> bool | None:
-        """Return true if the binary_sensor is on."""
-
-        severity = self.coordinator.data.get("severity")
+        severity, _ = self._severity()
         if severity is None:
             return None
 
-        return severity > 1
+        # device_class:problem -> on means problem detected
+        return severity != 1
 
     @property
     def extra_state_attributes(self):
-        desc = self.coordinator.data.get("severityDesc")
+        severity, desc = self._severity()
         return {
+            "value": severity,
             "description": desc,
         }
 
 
-class MhEngBinarySensor(MhEntity, BinarySensorEntity):
-    """myheat Binary Sensor class."""
+class MhSeverityBinarySensor(MhEntity, MhSeverityBinarySensorBase):
+    _attr_icon = "mdi:water-boiler-alert"
 
-    def __init__(self, coordinator, config_entry, eng: dict):
-        super().__init__(coordinator, config_entry)
-        self.eng_name = eng["name"]
-        self.eng_id = eng["id"]
+    def _severity(self) -> (int | None, str | None):
+        return (
+            self.coordinator.data.get("severity"),
+            self.coordinator.data.get("severityDesc"),
+        )
 
     @property
-    def name(self):
-        """Return the name of the sensor."""
-        name = self.config_entry.data.get(CONF_NAME, DEFAULT_NAME)
-        return f"{name} {self.eng_name}"
+    def name(self) -> str:
+        return f"{self._mh_name} severity"
 
     @property
     def unique_id(self):
-        """Return a unique ID to use for this entity."""
-        return f"{super().unique_id}eng{self.eng_id}"
+        return f"{super().unique_id}severity"
 
+
+class MhEnvSeverityBinarySensor(MhEnvEntity, MhSeverityBinarySensorBase):
+    _key = "severity"
+    _attr_icon = "mdi:water-boiler-alert"
+
+    def _severity(self) -> (int | None, str | None):
+        e = self.get_env()
+        return (
+            e.get("severity"),
+            e.get("severityDesc"),
+        )
+
+
+class MhEngSeverityBinarySensor(MhEngEntity, MhSeverityBinarySensorBase):
+    _key = "severity"
+
+    def _severity(self) -> (int | None, str | None):
+        e = self.get_eng()
+        return (
+            e.get("severity"),
+            e.get("severityDesc"),
+        )
+
+
+class MhHeaterBinarySensor(MhHeaterEntity, BinarySensorEntity):
     @property
     def is_on(self):
-        """Return true if the binary_sensor is on."""
-        return self._eng().get("turnedOn")
+        return self.get_heater().get(self._key)
 
-    @property
-    def _mh_dev_name_suffix(self):
-        return f" {self.eng_name}"
 
+class MhHeaterDisabledBinarySensor(MhHeaterBinarySensor):
+    _key = "disabled"
+    _attr_icon = "mdi:electric-switch"
+    _attr_device_class = None
+
+
+class MhHeaterBurnerWaterBinarySensor(MhHeaterBinarySensor):
+    _key = "burnerWater"
+    _attr_icon = "mdi:fire"
+    _attr_device_class = "heat"
+
+
+class MhHeaterBurnerHeatingBinarySensor(MhHeaterBinarySensor):
+    _key = "burnerHeating"
+    _attr_icon = "mdi:fire"
+    _attr_device_class = "heat"
+
+
+class MhEngTurnedOnBinarySensor(MhEngEntity, BinarySensorEntity):
     @property
-    def _mh_identifiers(self):
-        return (DOMAIN, f"{super().unique_id}eng{self.eng_id}")
-
-    def _eng(self) -> dict:
-        if not self.coordinator.data.get("dataActual", False):
-            _logger.warninig("data not actual! %s", self.coordinator.data)
-            return {}
-
-        engs = self.coordinator.data.get("engs", [])
-        for e in engs:
-            if e["id"] == self.eng_id:
-                return e
-        return {}
+    def is_on(self):
+        return self.get_eng().get("turnedOn")

custom_components/myheat/climate.py

@@ -21,8 +21,8 @@
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
-from .const import CONF_NAME, DEFAULT_NAME, DOMAIN
-from .entity import MhEntity
+from .const import DOMAIN
+from .entity import MhEnvEntity
 
 _logger = logging.getLogger(__package__)
 
@@ -56,13 +56,11 @@ async def async_setup_entry(
     )
 
 
-class MhEnvClimate(MhEntity, ClimateEntity):
+class MhEnvClimate(MhEnvEntity, ClimateEntity):
     """myheat Climate class."""
 
     def __init__(self, coordinator, config_entry, env: dict):
-        super().__init__(coordinator, config_entry)
-        self.env_name = env["name"]
-        self.env_id = env["id"]
+        super().__init__(coordinator, config_entry, env)
 
         self._attr_supported_features = (
             ClimateEntityFeature.TARGET_TEMPERATURE | ClimateEntityFeature.PRESET_MODE
@@ -100,17 +98,6 @@ def __init__(self, coordinator, config_entry, env: dict):
 
         self._attr_temperature_unit = UnitOfTemperature.CELSIUS
 
-    @property
-    def name(self):
-        """Return the name of the sensor."""
-        name = self.config_entry.data.get(CONF_NAME, DEFAULT_NAME)
-        return f"{name} {self.env_name}"
-
-    @property
-    def unique_id(self):
-        """Return a unique ID to use for this entity."""
-        return f"{super().unique_id}env{self.env_id}"
-
     async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
         """Set new target hvac mode."""
 
@@ -132,15 +119,15 @@ async def async_set_preset_mode(self, preset_mode: str) -> None:
 
     async def async_set_temperature(self, **kwargs) -> None:
         """Set new target temperature."""
-        goal = kwargs.get("temperature", 0)
+        goal = kwargs.get("temperature", 0.0)
         await self.coordinator.api.async_set_env_goal(obj_id=self.env_id, goal=goal)
         await self.coordinator.async_request_refresh()
 
     @callback
     def _handle_coordinator_update(self):
         """Get the latest state from the thermostat."""
 
-        e = self._env()
+        e = self.get_env()
 
         self._attr_current_temperature = e.get("value")
         self._attr_target_temperature = e.get("target")
@@ -156,23 +143,3 @@ def _handle_coordinator_update(self):
         )
 
         self.async_write_ha_state()
-
-    @property
-    def _mh_dev_name_suffix(self):
-        return f" {self.env_name}"
-
-    @property
-    def _mh_identifiers(self):
-        return (DOMAIN, f"{super().unique_id}env{self.env_id}")
-
-    def _env(self) -> dict:
-        if not self.coordinator.data.get("dataActual", False):
-            _logger.warninig("data not actual! %s", self.coordinator.data)
-            return {}
-
-        envs = self.coordinator.data.get("envs", [])
-        for e in envs:
-            if e["id"] == self.env_id:
-                return e
-
-        return {}