Merge pull request #19 from derolli1976/feature/tageserzeugung

* Added additional solar production sensor with daily reset
* Also: More robust loading of wallbox entities (timeout issues)

Author: derolli1976

custom_components/enpal_webparser/sensor.py

@@ -1,20 +1,23 @@
-from datetime import timedelta, datetime
-import re
+from datetime import datetime, timedelta
+import asyncio
 import logging
+import re
+
 import aiohttp
 from bs4 import BeautifulSoup
 
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.components.sensor import SensorEntity
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, CoordinatorEntity, UpdateFailed
 from homeassistant.helpers.entity import EntityCategory
 from homeassistant.helpers.restore_state import RestoreEntity
-
+from homeassistant.helpers.event import async_track_state_change_event
 
 from .const import DOMAIN, DEFAULT_INTERVAL, DEFAULT_URL, DEFAULT_WALLBOX_API_ENDPOINT
 
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -75,12 +78,15 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry, async_add_e
     groups = entry.options.get("groups", [])
     _LOGGER.debug("[Enpal] Configuration - URL: %s, Interval: %s, Groups: %s", url, interval, groups)
 
+    last_successful_data = []
+
     async def async_update_data():
+        nonlocal last_successful_data
         try:
             async with aiohttp.ClientSession() as session:
                 async with session.get(url, timeout=30) as resp:
                     if resp.status != 200:
-                        raise UpdateFailed(f"Unexpected status code: {resp.status}")
+                        raise Exception(f"Unexpected status code: {resp.status}")
                     html = await resp.text()
 
             _LOGGER.debug("[Enpal] HTML content fetched successfully from %s", url)
@@ -92,7 +98,6 @@ async def async_update_data():
             for card in cards:
                 group = card.find("h2").text.strip()
                 if group not in groups:
-                    _LOGGER.debug("[Enpal] Skipping group not in selected groups: %s", group)
                     continue
 
                 rows = card.find_all("tr")[1:]
@@ -139,14 +144,19 @@ async def async_update_data():
                             "enabled": group in groups,
                             "enpal_last_update": timestamp_iso
                         }
-                        _LOGGER.debug("[Enpal] Parsed sensor: %s", sensor_data)
                         sensors.append(sensor_data)
 
             _LOGGER.info("[Enpal] Loaded %d sensor(s) from HTML", len(sensors))
+            last_successful_data = sensors
             return sensors
+
         except Exception as e:
-            _LOGGER.exception("[Enpal] Error during HTML parsing or request: %s", e)
-            raise UpdateFailed(f"Data fetch failed: {e}")
+            if last_successful_data:
+                _LOGGER.warning("[Enpal] Error during update, using last known good values: %s", e)
+                return last_successful_data
+            else:
+                _LOGGER.exception("[Enpal] No previous data available")
+                raise UpdateFailed(f"Initial data fetch failed: {e}")
 
     coordinator = DataUpdateCoordinator(
         hass,
@@ -165,6 +175,10 @@ async def async_update_data():
     hass.data[DOMAIN]["coordinator"] = coordinator
 
     await coordinator.async_config_entry_first_refresh()
+    _LOGGER.info("[Enpal] Verfügbare Sensoren nach HTML-Parsing:")
+    for sensor in coordinator.data:
+        _LOGGER.info("[Enpal]   Name: %s -> UID: %s", sensor["name"], make_id(sensor["name"]))
+
 
     entities = []
     for sensor in coordinator.data:
@@ -173,24 +187,34 @@ async def async_update_data():
         entities.append(EnpalSensor(uid, sensor, coordinator))
 
     entities.append(CumulativeEnergySensor(hass, coordinator, "Inverter Power DC Total (Huawei)", interval))
+    entities.append(DailyResetFromEntitySensor(hass, "sensor.inverter_energy_produced_total_dc"))
+
+
 
     if entry.options.get("use_wallbox_addon", False):
         wallbox_url = f"{DEFAULT_WALLBOX_API_ENDPOINT}/status"
-
         _LOGGER.info("[Enpal] Wallbox add-on enabled, URL: %s", wallbox_url)
 
+        wallbox_data = {}
+
         async def async_wallbox_update():
+            nonlocal wallbox_data
             try:
                 async with aiohttp.ClientSession() as session:
-                    async with session.get(wallbox_url, timeout=30) as resp:
+                    async with session.get(wallbox_url, timeout=10) as resp:
                         if resp.status != 200:
-                            raise UpdateFailed(f"Wallbox API Error: {resp.status}")
+                            raise Exception(f"Wallbox API Error: {resp.status}")
                         data = await resp.json()
                         _LOGGER.debug("[Enpal] Wallbox status data: %s", data)
+                        wallbox_data = data
                         return data
             except Exception as e:
-                _LOGGER.exception("[Enpal] Error fetching wallbox status: %s", e)
-                raise UpdateFailed(f"Wallbox update failed: {e}")
+                if wallbox_data:
+                    _LOGGER.warning("[Enpal] Wallbox update failed – using last known data: %s", e)
+                    return wallbox_data
+                else:
+                    _LOGGER.warning("[Enpal] Wallbox update failed – no previous data yet: %s", e)
+                    raise UpdateFailed(f"Wallbox update failed and no previous data: {e}")
 
         wallbox_coordinator = DataUpdateCoordinator(
             hass,
@@ -200,12 +224,16 @@ async def async_wallbox_update():
             update_interval=timedelta(seconds=interval),
         )
 
-        await wallbox_coordinator.async_config_entry_first_refresh()
+        # KEIN await – Hintergrund-Task starten, damit Home Assistant nicht crasht
+        hass.async_create_task(wallbox_coordinator.async_refresh())
 
         entities.extend([
             WallboxModeSensor(wallbox_coordinator),
             WallboxStatusSensor(wallbox_coordinator),
         ])
+        _LOGGER.debug("[Enpal] Wallbox-Sensoren hinzugefügt")
+
+
 
     async_add_entities(entities)
 
@@ -325,6 +353,86 @@ def device_info(self):
         }
 
 
+
+
+class DailyResetFromEntitySensor(SensorEntity, RestoreEntity):
+    def __init__(self, hass: HomeAssistant, source_entity_id: str):
+        self.hass = hass
+        self._attr_name = "Inverter: Energy produced total (DC)"
+        self._attr_unique_id = "daily_energy_produced_dc_kwh"
+        self._attr_device_class = "energy"
+        self._attr_state_class = "total"
+        self._attr_native_unit_of_measurement = "kWh"
+        self._attr_icon = "mdi:calendar-refresh"
+        self._source_entity_id = source_entity_id
+        self._today_start_value = None
+        self._value = 0.0
+        self._last_reset = datetime.now().date()
+
+    @property
+    def native_value(self):
+        return round(self._value or 0.0, 3)
+
+    @property
+    def extra_state_attributes(self):
+        return {
+            "last_reset": self._last_reset.isoformat(),
+            "start_value": self._today_start_value if self._today_start_value is not None else "Not set"
+        }
+
+    async def async_added_to_hass(self):
+        await RestoreEntity.async_added_to_hass(self)
+        # Statt self.hass.helpers.event.async_track_state_change_event(...),
+        # verwende den importierten async_track_state_change_event:
+        
+        async_track_state_change_event(
+            self.hass, self._source_entity_id, self._handle_state_update
+        )
+        last_state = await self.async_get_last_state()
+        if last_state and last_state.state not in (None, 'unknown', 'unavailable'):
+            try:
+                self._value = float(last_state.state)
+                self._today_start_value = self._try_float(last_state.attributes.get("start_value"))
+                last_reset_str = last_state.attributes.get("last_reset")
+                if last_reset_str:
+                    self._last_reset = datetime.fromisoformat(last_reset_str).date()
+            except Exception:
+                pass
+
+    def _try_float(self, val):
+        try:
+            return float(val)
+        except (TypeError, ValueError):
+            return None
+
+    @callback
+    def _handle_state_update(self, event):
+        today = datetime.now().date()
+        try:
+            new_total = float(event.data["new_state"].state)
+        except (TypeError, ValueError):
+            return
+
+        if self._today_start_value is None or self._last_reset != today:
+            self._today_start_value = new_total
+            self._last_reset = today
+            self._value = 0.0
+        else:
+            self._value = max(new_total - self._today_start_value, 0)
+
+        self.async_schedule_update_ha_state()
+
+    @property
+    def device_info(self):
+        return {
+            "identifiers": {(DOMAIN, "enpal_device")},
+            "name": "Enpal Webgerät",
+            "manufacturer": "Enpal",
+            "model": "Webparser",
+        }
+
+
+
 class WallboxCoordinatorEntity(CoordinatorEntity, SensorEntity):
     def __init__(self, coordinator, name, unique_id, key):
         super().__init__(coordinator)
@@ -345,7 +453,9 @@ def device_info(self):
 
     @property
     def native_value(self):
-        return self.coordinator.data.get(self._key)
+        if self.coordinator.data:
+            return self.coordinator.data.get(self._key)
+        return None
 
 
 class WallboxModeSensor(WallboxCoordinatorEntity):