Align with core integration

Author: tomer-w

custom_components/victron_mqtt/binary_sensor.py

@@ -1,43 +1,40 @@
-"""Support for Victron Venus binary sensors."""
+"""Support for Victron GX binary sensors."""
 
-import logging
 from typing import Any
-from functools import cached_property
 
 from victron_mqtt import (
     Device as VictronVenusDevice,
     Metric as VictronVenusMetric,
     MetricKind,
+    VictronEnum,
 )
 
 from homeassistant.components.binary_sensor import BinarySensorEntity
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .const import SWITCH_ON
 from .entity import VictronBaseEntity
-from .hub import Hub, VictronGxConfigEntry
+from .hub import VictronGxConfigEntry
 
-
-_LOGGER = logging.getLogger(__name__)
+PARALLEL_UPDATES = 0  # There is no I/O in the entity itself.
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
     config_entry: VictronGxConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up Victron Venus sensors from a config entry."""
-    hub: Hub = config_entry.runtime_data
+    """Set up Victron GX binary sensors from a config entry."""
+    hub = config_entry.runtime_data
 
     def on_new_metric(
         device: VictronVenusDevice,
         metric: VictronVenusMetric,
         device_info: DeviceInfo,
     ) -> None:
-        """Handle new sensor metric discovery."""
+        """Handle new binary sensor metric discovery."""
         assert hub._hub.installation_id is not None
         async_add_entities(
             [
@@ -51,7 +48,7 @@ def on_new_metric(
 
 
 class VictronBinarySensor(VictronBaseEntity, BinarySensorEntity):
-    """Implementation of a Victron Venus binary sensor."""
+    """Implementation of a Victron GX binary sensor."""
 
     def __init__(
         self,
@@ -62,25 +59,21 @@ def __init__(
         installation_id: str,
     ) -> None:
         """Initialize the binary sensor."""
-        self._attr_is_on = self._is_on(metric.value)
         super().__init__(
             device, metric, device_info, "binary_sensor", simple_naming, installation_id
         )
-
-    @staticmethod
-    def _is_on(value: Any) -> bool:
-        return str(value) == SWITCH_ON
+        self._attr_is_on = self._is_on(metric.value)
 
     @callback
-    def _on_update_task(self, value: Any) -> None:
-        new_val = self._is_on(value)
-        if self._attr_is_on == new_val:
-            return
-        self._attr_is_on = new_val
+    def _on_update_cb(self, value: Any) -> None:
+        self._attr_is_on = self._is_on(value)
         self.async_write_ha_state()
 
-    @cached_property
-    def is_on(self) -> bool:
-        """Return the current state of the binary sensor."""
-        assert self._attr_is_on is not None
-        return self._attr_is_on
+    @staticmethod
+    def _is_on(value: Any) -> bool | None:
+        """Convert a Victron switch value to a boolean."""
+        return (
+            value.id == SWITCH_ON
+            if value is not None and isinstance(value, VictronEnum)
+            else None
+        )

custom_components/victron_mqtt/button.py

@@ -1,4 +1,4 @@
-"""Support for Victron Venus buttons."""
+"""Support for Victron GX button entities."""
 
 import logging
 from typing import Any
@@ -11,32 +11,33 @@
 )
 
 from homeassistant.components.button import ButtonEntity
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .const import SWITCH_ON
 from .entity import VictronBaseEntity
-from .hub import Hub
+from .hub import VictronGxConfigEntry
 
 _LOGGER = logging.getLogger(__name__)
 
+PARALLEL_UPDATES = 0  # There is no I/O in the entity itself.
+
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: ConfigEntry,
+    config_entry: VictronGxConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up Victron Venus sensors from a config entry."""
-    hub: Hub = config_entry.runtime_data
+    """Set up Victron GX button entities from a config entry."""
+    hub = config_entry.runtime_data
 
     def on_new_metric(
         device: VictronVenusDevice,
         metric: VictronVenusMetric,
         device_info: DeviceInfo,
     ) -> None:
-        """Handle new sensor metric discovery."""
+        """Handle new button metric discovery."""
         assert isinstance(metric, VictronVenusWritableMetric)
         assert hub._hub.installation_id is not None
         async_add_entities(
@@ -55,7 +56,7 @@ def on_new_metric(
 
 
 class VictronButton(VictronBaseEntity, ButtonEntity):
-    """Implementation of a Victron Venus button using ButtonEntity."""
+    """Implementation of a Victron GX button entity."""
 
     def __init__(
         self,
@@ -71,11 +72,11 @@ def __init__(
         )
 
     @callback
-    def _on_update_task(self, value: Any) -> None:
+    def _on_update_cb(self, value: Any) -> None:
         pass
 
     def press(self) -> None:
         """Press the button."""
-        _LOGGER.info("Pressing button: %s", self._attr_unique_id)
         assert isinstance(self._metric, VictronVenusWritableMetric)
+        _LOGGER.debug("Pressing button: %s", self._attr_unique_id)
         self._metric.set(SWITCH_ON)

custom_components/victron_mqtt/const.py

@@ -1,9 +1,11 @@
 """Constants for the victron_mqtt integration."""
+from victron_mqtt import MetricNature
+
+from homeassistant.components.sensor import SensorStateClass
 
 # Integration specific values (custom / builtin Home Assistant)
 DOMAIN = "victron_mqtt"
 DEFAULT_SIMPLE_NAMING = True
-ENTITY_PREFIX = "victron_mqtt"
 
 # generic config values
 CONF_INSTALLATION_ID = "installation_id"
@@ -32,10 +34,12 @@
 ATTR_VALUE = "value"
 
 # Not using GenericOnOff as some switches use different enums.
-# It has to be with value "On" to be on and "Off" to be off.
-SWITCH_ON = "On"
-SWITCH_OFF = "Off"
+# It has to be with id "on" to be on and "off" to be off.
+SWITCH_ON = "on"
+SWITCH_OFF = "off"
+
 
-# Entity IDs which needs special treatment
-ENTITIES_CATEGORY_DIAGNOSTIC = ["system_heartbeat", "solarcharger_device_off_reason"]
-ENTITIES_DISABLE_BY_DEFAULT = ["system_heartbeat", "solarcharger_device_off_reason"]
+METRIC_NATURE_TO_STATE_CLASS: dict[MetricNature, SensorStateClass] = {
+    MetricNature.CUMULATIVE: SensorStateClass.TOTAL_INCREASING,
+    MetricNature.INSTANTANEOUS: SensorStateClass.MEASUREMENT,
+}

custom_components/victron_mqtt/entity.py

@@ -1,30 +1,25 @@
-"""Common code for Victron Venus integration."""
+"""Base entity for entities in victron_gx integration."""
 
 from abc import abstractmethod
-import logging
 from typing import Any
 
-from victron_mqtt import (
-    Device as VictronVenusDevice,
-    Metric as VictronVenusMetric,
-    MetricKind,
-    MetricNature,
-    MetricType,
-)
+from victron_mqtt import Device as VictronVenusDevice, Metric as VictronVenusMetric
 
-from homeassistant.components.sensor import SensorDeviceClass, SensorStateClass
 from homeassistant.const import EntityCategory
 from homeassistant.core import callback
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity import Entity
 
-from .const import ENTITIES_CATEGORY_DIAGNOSTIC, ENTITIES_DISABLE_BY_DEFAULT, ENTITY_PREFIX
+# Entities that should be marked as diagnostic
+ENTITIES_CATEGORY_DIAGNOSTIC = ["system_heartbeat", "solarcharger_device_off_reason"]
+# Entities that should be disabled by default
+ENTITIES_DISABLE_BY_DEFAULT = ["system_heartbeat", "solarcharger_device_off_reason"]
 
-_LOGGER = logging.getLogger(__name__)
+ENTITY_PREFIX = "victron_mqtt"
 
 
 class VictronBaseEntity(Entity):
-    """Implementation of a Victron Venus base entity."""
+    """Implementation of a Victron GX base entity."""
 
     _attr_should_poll = False
     _attr_has_entity_name = True
@@ -42,7 +37,6 @@ def __init__(
         self._device = device
         self._metric = metric
         self._attr_device_info = device_info
-        self._metric = metric
         if simple_naming:
             entity_id = f"{entity_platform}.{ENTITY_PREFIX}_{metric.unique_id}"
         else:
@@ -51,19 +45,9 @@ def __init__(
         self._attr_suggested_display_precision = metric.precision
         self._attr_translation_key = metric.generic_short_id.replace("{", "").replace(
             "}", ""
-        )  # same as in merge_topics.py
+        )
         self._attr_translation_placeholders = metric.key_values
 
-        # Some attributes are relevant only for certain metric kinds
-        if metric.metric_kind in [MetricKind.SENSOR, MetricKind.NUMBER]:
-            self._attr_device_class = self._map_metric_to_device_class(metric)
-            self._attr_state_class = self._map_metric_to_stateclass(metric)
-            # Only set native_unit_of_measurement when a device_class is present.
-            # Entities without a device_class get their display unit from
-            # the translation files instead (set by merge_topics.py).
-            if self._attr_device_class is not None:
-                self._attr_native_unit_of_measurement = metric.unit_of_measurement
-
         self._attr_entity_category = (
             EntityCategory.DIAGNOSTIC
             if metric.generic_short_id in ENTITIES_CATEGORY_DIAGNOSTIC
@@ -73,76 +57,22 @@ def __init__(
             metric.generic_short_id not in ENTITIES_DISABLE_BY_DEFAULT
         )
 
-
-    def __repr__(self) -> str:
-        """Return a string representation of the entity."""
-        return (
-            f"VictronBaseEntity(device={self._device.name}, "
-            f"unique_id={self._attr_unique_id}, "
-            f"metric={self._metric.short_id}, "
-            f"translation_key={self._attr_translation_key}, "
-            f"translation_placeholders={self._attr_translation_placeholders})"
-        )
-
     @callback
     @abstractmethod
-    def _on_update_task(self, value: Any) -> None:
+    def _on_update_cb(self, value: Any) -> None:
         """Handle the metric update. Must be implemented by subclasses."""
 
     @callback
     def _on_update(self, _: VictronVenusMetric, value: Any) -> None:
-        self._on_update_task(value)
+        self._on_update_cb(value)
 
     async def async_added_to_hass(self) -> None:
         """Run when entity about to be added to hass."""
         await super().async_added_to_hass()
-        # Now we can safely register for updates as the entity is fully registered with Home Assistant
         self._metric.on_update = self._on_update
 
     async def async_will_remove_from_hass(self) -> None:
         """Run when entity will be removed from hass."""
-        # Remove our update callback by setting a no-op function
+        # Unregister update callback
         self._metric.on_update = None
         await super().async_will_remove_from_hass()
-
-    def _map_metric_to_device_class(
-        self, metric: VictronVenusMetric
-    ) -> SensorDeviceClass | None:
-        match metric.metric_type:
-            case MetricType.POWER:
-                return SensorDeviceClass.POWER
-            case MetricType.APPARENT_POWER:
-                return SensorDeviceClass.APPARENT_POWER
-            case MetricType.ENERGY:
-                return SensorDeviceClass.ENERGY
-            case MetricType.VOLTAGE:
-                return SensorDeviceClass.VOLTAGE
-            case MetricType.CURRENT:
-                return SensorDeviceClass.CURRENT
-            case MetricType.FREQUENCY:
-                return SensorDeviceClass.FREQUENCY
-            case MetricType.ELECTRIC_STORAGE_PERCENTAGE:
-                return SensorDeviceClass.BATTERY
-            case MetricType.TEMPERATURE:
-                return SensorDeviceClass.TEMPERATURE
-            case MetricType.SPEED:
-                return SensorDeviceClass.SPEED
-            case MetricType.LIQUID_VOLUME:
-                return SensorDeviceClass.VOLUME_STORAGE
-            case MetricType.DURATION:
-                return SensorDeviceClass.DURATION
-            case MetricType.TIME:
-                # Sadly, there is no SensorDeviceClass for time
-                return None
-            case _:
-                return None
-
-    def _map_metric_to_stateclass(
-        self, metric: VictronVenusMetric
-    ) -> SensorStateClass | None:
-        if metric.metric_nature == MetricNature.CUMULATIVE:
-            return SensorStateClass.TOTAL
-        if metric.metric_nature == MetricNature.INSTANTANEOUS:
-            return SensorStateClass.MEASUREMENT
-
-        return None