Add configurable optimizer area sensors

custom_components/solaredge_optimizers/sensor.py

@@ -13,13 +13,16 @@ from homeassistant.components.sensor import (
     SensorStateClass,
 )
 from homeassistant.const import UnitOfEnergy, UnitOfPower
-from homeassistant.core import callback
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
+from homeassistant.util import slugify
 
 from . import SolarEdgeOptimizerConfigEntry
 from .api import OptimizerData
+from .areas import configured_area_mapping
 from .const import DOMAIN
 from .coordinator import SolarEdgeOptimizerCoordinator
 
@@ -54,14 +57,44 @@ SENSOR_DESCRIPTIONS = (
     ),
 )
 
+AREA_SENSOR_DESCRIPTIONS = (
+    SolarEdgeOptimizerSensorDescription(
+        key="daily_energy",
+        translation_key="area_daily_energy",
+        device_class=SensorDeviceClass.ENERGY,
+        native_unit_of_measurement=UnitOfEnergy.WATT_HOUR,
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        suggested_display_precision=1,
+        value_fn=lambda optimizer: optimizer.daily_energy_wh,
+    ),
+    SolarEdgeOptimizerSensorDescription(
+        key="current_power",
+        translation_key="area_current_power",
+        device_class=SensorDeviceClass.POWER,
+        native_unit_of_measurement=UnitOfPower.WATT,
+        state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=1,
+        value_fn=lambda optimizer: optimizer.current_power_w,
+    ),
+)
+
 
 async def async_setup_entry(
-    hass: Any,
+    hass: HomeAssistant,
     entry: SolarEdgeOptimizerConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up optimizer sensors from a config entry."""
     coordinator = entry.runtime_data
+    area_mapping = configured_area_mapping(coordinator.data.site_id, entry.options)
+    area_entities = [
+        SolarEdgeAreaSensor(coordinator, area, optimizer_ids, description)
+        for area, optimizer_ids in area_mapping.items()
+        for description in AREA_SENSOR_DESCRIPTIONS
+    ]
+    _remove_stale_area_entities(hass, entry, area_entities)
+    async_add_entities(area_entities)
+
     known_serials: set[str] = set()
 
     @callback
@@ -84,6 +117,34 @@ async def async_setup_entry(
     entry.async_on_unload(coordinator.async_add_listener(async_add_new_optimizers))
 
 
+def _remove_stale_area_entities(
+    hass: HomeAssistant,
+    entry: SolarEdgeOptimizerConfigEntry,
+    area_entities: list[SolarEdgeAreaSensor],
+) -> None:
+    """Remove registry entries for areas no longer configured."""
+    entity_registry = er.async_get(hass)
+    desired_unique_ids = {entity.unique_id for entity in area_entities}
+    area_prefix = f"{entry.runtime_data.data.site_id}_area_"
+    for entity in er.async_entries_for_config_entry(entity_registry, entry.entry_id):
+        if (
+            entity.unique_id.startswith(area_prefix)
+            and entity.unique_id not in desired_unique_ids
+        ):
+            entity_registry.async_remove(entity.entity_id)
+
+
+def _site_device_info(coordinator: SolarEdgeOptimizerCoordinator) -> DeviceInfo:
+    """Return the shared SolarEdge site device information."""
+    site_id = coordinator.data.site_id
+    return DeviceInfo(
+        identifiers={(DOMAIN, site_id)},
+        manufacturer="SolarEdge",
+        model="Optimizer Monitoring Site",
+        name=f"SolarEdge Site {site_id}",
+    )
+
+
 class SolarEdgeOptimizerSensor(
     CoordinatorEntity[SolarEdgeOptimizerCoordinator], SensorEntity
 ):
@@ -126,13 +187,7 @@ class SolarEdgeOptimizerSensor(
     @property
     def device_info(self) -> DeviceInfo:
         """Return the shared SolarEdge site device information."""
-        site_id = self.coordinator.data.site_id
-        return DeviceInfo(
-            identifiers={(DOMAIN, site_id)},
-            manufacturer="SolarEdge",
-            model="Optimizer Monitoring Site",
-            name=f"SolarEdge Site {site_id}",
-        )
+        return _site_device_info(self.coordinator)
 
     @property
     def extra_state_attributes(self) -> dict[str, Any]:
@@ -145,3 +200,67 @@ class SolarEdgeOptimizerSensor(
             "inverter_id": optimizer.inverter_id,
             "last_measurement": optimizer.last_measurement,
         }
+
+
+class SolarEdgeAreaSensor(
+    CoordinatorEntity[SolarEdgeOptimizerCoordinator], SensorEntity
+):
+    """Represent the sum of one optimizer area."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: SolarEdgeOptimizerCoordinator,
+        area: str,
+        optimizer_ids: tuple[str, ...],
+        description: SolarEdgeOptimizerSensorDescription,
+    ) -> None:
+        """Initialize an area sum sensor."""
+        super().__init__(coordinator)
+        self.entity_description = description
+        self._area = area
+        self._optimizer_ids = optimizer_ids
+        self._attr_unique_id = (
+            f"{coordinator.data.site_id}_area_{slugify(area)}_{description.key}"
+        )
+        self._attr_translation_placeholders = {"area": area}
+
+    @property
+    def _values(self) -> tuple[OptimizerValue, ...]:
+        optimizers_by_id = self.coordinator.data.optimizers_by_id
+        return tuple(
+            self.entity_description.value_fn(optimizer)
+            if (optimizer := optimizers_by_id.get(optimizer_id)) is not None
+            else None
+            for optimizer_id in self._optimizer_ids
+        )
+
+    @property
+    def native_value(self) -> OptimizerValue:
+        """Return the sum when every configured optimizer value is available."""
+        values = self._values
+        if not values or any(value is None for value in values):
+            return None
+        return sum(value for value in values if value is not None)
+
+    @property
+    def available(self) -> bool:
+        """Return whether every optimizer in the area is available."""
+        return super().available and self.native_value is not None
+
+    @property
+    def device_info(self) -> DeviceInfo:
+        """Return the shared SolarEdge site device information."""
+        return _site_device_info(self.coordinator)
+
+    @property
+    def extra_state_attributes(self) -> dict[str, Any]:
+        """Return area membership and completeness information."""
+        values = self._values
+        return {
+            "area": self._area,
+            "optimizer_ids": list(self._optimizer_ids),
+            "optimizer_count": len(self._optimizer_ids),
+            "available_optimizer_count": sum(value is not None for value in values),
+        }