Change validation type from float to int - move flexible tariff next query time calculation

Author: tpd-opitz

packages/control/optional_data.py

@@ -1,16 +1,10 @@
 from dataclasses import dataclass, field
-from datetime import datetime, timedelta
-import random
 from typing import Dict, Optional, Protocol
 
 from dataclass_utils.factories import empty_dict_factory
 from helpermodules.constants import NO_ERROR
-from helpermodules.pub import Pub
 from modules.display_themes.cards.config import CardsDisplayTheme
 
-# Stunden für tägliche Tarifaktualisierung, manche Anbieter aktualisieren mehrfach täglich
-TARIFF_UPDATE_HOURS = [2, 8, 14, 20]
-
 
 @dataclass
 class PricingGet:
@@ -56,7 +50,7 @@ def get_grid_fee_factory() -> GridFee:
 
 @dataclass
 class ElectricityPricingGet:
-    next_query_time: Optional[float] = field(default=None, metadata={"topic": "ep/next_query_time"})
+    next_query_time: Optional[int] = field(default=None, metadata={"topic": "ep/next_query_time"})
     _prices: Dict = field(default_factory=empty_dict_factory, metadata={"topic": "ep/prices"})
 
     @property
@@ -66,23 +60,6 @@ def prices(self) -> Dict:
     @prices.setter
     def prices(self, value: Dict):
         self._prices = value
-        if value:
-            now = datetime.now()
-            current_hour = now.hour
-            next_hour = None
-            for hour in TARIFF_UPDATE_HOURS:
-                if hour > current_hour:
-                    next_hour = hour
-                    break
-            # Wenn keine Stunde heute gefunden, nimm die erste Stunde vom nächsten Tag
-            if next_hour is None:
-                next_hour = TARIFF_UPDATE_HOURS[0]
-                next_query_time = (now + timedelta(days=1)).replace(hour=next_hour, minute=0, second=0, microsecond=0)
-            else:
-                next_query_time = now.replace(hour=next_hour, minute=0, second=0, microsecond=0)
-            # reduce serverload on their site by trying early and randomizing query time
-            next_query_time += timedelta(minutes=random.randint(1, 7) * -5)
-            Pub().pub("openWB/set/optional/ep/get/next_query_time", next_query_time.timestamp())
 
 
 def electricity_pricing_get_factory() -> ElectricityPricingGet:

packages/helpermodules/setdata.py

@@ -861,7 +861,7 @@ def process_optional_topic(self, msg: mqtt.MQTTMessage):
             elif "openWB/set/optional/ep/get/prices" in msg.topic:
                 self._validate_value(msg, "json")
             elif "openWB/set/optional/ep/get/next_query_time" in msg.topic:
-                self._validate_value(msg, float)
+                self._validate_value(msg, int)
             elif "openWB/set/optional/ep/configured" in msg.topic:
                 self._validate_value(msg, bool)
             elif "module_update_completed" in msg.topic:

packages/modules/common/configurable_tariff.py

@@ -1,16 +1,22 @@
+from datetime import datetime, timedelta
+import random
 from typing import TypeVar, Generic, Callable
 from helpermodules import timecheck
 import logging
+from helpermodules.pub import Pub
 from modules.common import store
 from modules.common.component_context import SingleComponentUpdateContext
 from modules.common.component_state import TariffState
 from modules.common.component_type import ComponentType
 from modules.common.fault_state import ComponentInfo, FaultState
 
 
+# Stunden für tägliche Tarifaktualisierung, manche Anbieter aktualisieren mehrfach täglich
+TARIFF_UPDATE_HOURS = [2, 8, 14, 20]
 T_TARIFF_CONFIG = TypeVar("T_TARIFF_CONFIG")
 TARIFF_UPDATE_HOUR = 14  # latest expected time for daily tariff update
 ONE_HOUR_SECONDS: int = 3600
+
 log = logging.getLogger(__name__)
 
 
@@ -28,17 +34,36 @@ def __init__(self,
 
     def update(self) -> None:
         if hasattr(self, "_component_updater"):
-            with SingleComponentUpdateContext(self.fault_state):
-                tariff_state, timeslot_length_seconds = self.__update_et_provider_data()
-                self.__store_and_publish_updated_data(tariff_state)
-                self.__log_and_publish_progress(timeslot_length_seconds, tariff_state)
+            try:
+                with SingleComponentUpdateContext(self.fault_state):
+                    tariff_state, timeslot_length_seconds = self.__update_et_provider_data()
+                    self.__store_and_publish_updated_data(tariff_state)
+                    self.__log_and_publish_progress(timeslot_length_seconds, tariff_state)
+            except Exception as e:
+                log.exception(f"Fehler beim Aktualisieren der Tarifdaten {e}")
+                self.fault_state.warning("Error updating tariff data, retry in 5 minutes")
 
     def __update_et_provider_data(self) -> tuple[TariffState, int]:
-        tariff_state = self._component_updater()
+        tariff_state = self.__call_component_updater()
         timeslot_length_seconds = self.__calculate_price_timeslot_length(tariff_state)
         tariff_state = self._remove_outdated_prices(tariff_state, timeslot_length_seconds)
         return tariff_state, timeslot_length_seconds
 
+    def __calculate_next_query_time(self) -> float:
+        now = datetime.now()
+        current_hour = now.hour
+        next_hour = min([hour for hour in TARIFF_UPDATE_HOURS
+                         if hour > current_hour], default=TARIFF_UPDATE_HOURS[0])
+        # reduce serverload on their site by trying early and randomizing query time minutes and seconds
+        next_query_time = (now.replace(hour=next_hour, minute=0, second=0, microsecond=0) +
+                           timedelta(days=1, minutes=random.randint(1, 35) * -1, seconds=random.randint(0, 5) * 10))
+        Pub().pub("openWB/set/optional/ep/get/next_query_time", int(next_query_time.timestamp()))
+
+    def __call_component_updater(self) -> TariffState:
+        tariff_state = self._component_updater()
+        self.__calculate_next_query_time()
+        return tariff_state
+
     def __log_and_publish_progress(self, timeslot_length_seconds, tariff_state):
         def publish_info(message_extension: str) -> None:
             self.fault_state.no_error(

packages/modules/common/store/_tariff.py

@@ -58,8 +58,8 @@ def sum_prices(self):
         grid_fee_prices = data.data.optional_data.data.electricity_pricing.grid_fee.get.prices
         if len(grid_fee_prices) == 0 and data.data.optional_data.grid_fee_module is not None:
             raise ValueError("Keine Preise für konfigurierten Netzentgelttarif vorhanden.")
-        flexible_tariff_prices = {float(k): v for k, v in flexible_tariff_prices.items()}
-        grid_fee_prices = {float(k): v for k, v in grid_fee_prices.items()}
+        flexible_tariff_prices = {int(float(k)): v for k, v in flexible_tariff_prices.items()}
+        grid_fee_prices = {int(float(k)): v for k, v in grid_fee_prices.items()}
         if len(flexible_tariff_prices) == 0 and len(grid_fee_prices) > 0:
             return grid_fee_prices
         if len(grid_fee_prices) == 0 and len(flexible_tariff_prices) > 0: