Refactor fix hour tariff price calculation for quarter hours

packages/control/optional.py

@@ -19,6 +19,7 @@
 
 log = logging.getLogger(__name__)
 AS_EURO_PER_KWH = 1000.0  # Umrechnung von €/Wh in €/kWh
+MQTT_PREFIX = "openWB/set/optional/ep"
 
 
 class Optional(OcppMixin):
@@ -43,7 +44,7 @@ def flexible_tariff_module(self, value: TypingOptional[ConfigurableFlexibleTarif
                 (self._flexible_tariff_module and value and
                  self._flexible_tariff_module.config.name != value.config.name)):
             self.data.electricity_pricing.flexible_tariff.get = PricingGet()
-            self._reset_state(self.data.electricity_pricing.flexible_tariff, "flexible_tariff")
+            self._reset_state(self.data.electricity_pricing.flexible_tariff)
         self._flexible_tariff_module = value
         self._set_ep_configured()
 
@@ -54,9 +55,10 @@ def grid_fee_module(self) -> TypingOptional[ConfigurableGridFee]:
     @grid_fee_module.setter
     def grid_fee_module(self, value: TypingOptional[ConfigurableGridFee]):
         if (value is None or
-                (self._grid_fee_module and value and self._grid_fee_module.config.name != value.config.name)):
+                (self._grid_fee_module and value and
+                 self._grid_fee_module.config.name != value.config.name)):
             self.data.electricity_pricing.grid_fee.get = PricingGet()
-            self._reset_state(self.data.electricity_pricing.grid_fee, "grid_fee")
+            self._reset_state(self.data.electricity_pricing.grid_fee)
         self._grid_fee_module = value
         self._set_ep_configured()
 
@@ -68,15 +70,15 @@ def _set_ep_configured(self):
             self.data.electricity_pricing.configured = False
             Pub().pub("openWB/set/optional/ep/configured", False)
 
-    def _reset_state(self, module: Union[FlexibleTariff, GridFee], module_name: str):
+    def _reset_state(self, module: Union[FlexibleTariff, GridFee]):
         if (module.get.fault_state != 0 or module.get.fault_str != NO_ERROR):
             module.get.fault_state = 0
             module.get.fault_str = NO_ERROR
-            Pub().pub(f"openWB/set/optional/ep/{module_name}/get/fault_state", 0)
-            Pub().pub(f"openWB/set/optional/ep/{module_name}/get/fault_str", NO_ERROR)
-        Pub().pub(f"openWB/set/optional/ep/{module_name}/get/prices", {})
+            Pub().pub(f"openWB/set/optional/ep/{module.name}/get/fault_state", 0)
+            Pub().pub(f"openWB/set/optional/ep/{module.name}/get/fault_str", NO_ERROR)
+            Pub().pub(f"openWB/set/optional/ep/{module.name}/get/prices", {})
+            Pub().pub(f"openWB/set/optional/ep/{module.name}/get/next_query_time", None)
         Pub().pub("openWB/set/optional/ep/get/prices", {})
-        Pub().pub("openWB/set/optional/ep/get/next_query_time", None)
 
     def monitoring_start(self):
         if self.monitoring_module is not None:
@@ -103,7 +105,7 @@ def ep_is_charging_allowed_hours_list(self, selected_hours: list[int]) -> bool:
             if self.data.electricity_pricing.configured:
                 return self.__get_current_timeslot_start() in selected_hours
             else:
-                log.info("Prüfe strompreisbasiertes Laden: Nicht konfiguriert")
+                log.debug("Prüfe strompreisbasiertes Laden: Nicht konfiguriert")
                 return False
         except Exception as e:
             log.exception(f"Fehler im Optional-Modul: {e}")
@@ -143,30 +145,33 @@ def __get_first_entry(self) -> tuple[str, float]:
             return timestamp, first
 
     def remove_outdated_prices(self):
-        def remove(price_data: Dict) -> Dict:
-            price_timeslot_seconds = self.__calculate_price_timeslot_length(price_data)
+        def remove(price_data: Dict, last_active_timestamp: int = 0) -> Dict:
             now = timecheck.create_timestamp()
-            return {
-                price[0]: price[1]
-                for price in price_data.items()
-                if float(price[0]) > now - (price_timeslot_seconds - 1)
-            }
+            first_timestamp = (max([timestamp for timestamp in price_data.keys()
+                                    if float(timestamp) <= now], default=0))
+            return {int(timestamp): price for timestamp, price in price_data.items()
+                    if int(timestamp) >= int(first_timestamp) and
+                    (int(timestamp) <= last_active_timestamp if last_active_timestamp > 0 else True)}
 
         try:
             if self.data.electricity_pricing.configured:
-                if len(self.data.electricity_pricing.get.prices) >= 0:
-                    ep = self.data.electricity_pricing
-                    ep.get.prices = remove(ep.get.prices)
+                ep = self.data.electricity_pricing
+                #  prices lists are updated in optional_data via mqtt listener
+                if len(ep.get.prices) > 0:
+                    Pub().pub(f"{MQTT_PREFIX}/get/prices", remove(ep.get.prices))
                 if self._flexible_tariff_module:
-                    ep.flexible_tariff.get.prices = remove(ep.flexible_tariff.get.prices)
+                    Pub().pub(f"{MQTT_PREFIX}/flexible_tariff/get/prices", remove(ep.flexible_tariff.get.prices))
                 if self._grid_fee_module:
-                    ep.grid_fee.get.prices = remove(ep.grid_fee.get.prices)
-        except Exception:
-            log.exception("Fehler beim Entfernen veralteter Preise")
+                    Pub().pub(f"{MQTT_PREFIX}/grid_fee/get/prices",
+                              remove(ep.grid_fee.get.prices,
+                                     last_active_timestamp=int(max(ep.get.prices.keys()))
+                                     if ep.get.prices else 0))
+        except Exception as e:
+            log.exception("Fehler beim Entfernen veralteter Preise: %s", e)
 
     def __get_current_timeslot_start(self) -> int:
         timestamp = self.__get_first_entry()[0]
-        return float(timestamp)
+        return int(timestamp)
 
     def ep_get_current_price(self) -> float:
         if self.data.electricity_pricing.configured:
@@ -176,7 +181,7 @@ def ep_get_current_price(self) -> float:
             raise Exception("Kein Anbieter für strompreisbasiertes Laden konfiguriert.")
 
     def __calculate_price_timeslot_length(self, prices: dict) -> int:
-        first_timestamps = list(prices.keys())[:2]
+        first_timestamps = sorted(list(prices.keys()))[:2]
         return float(first_timestamps[1]) - float(first_timestamps[0])
 
     def ep_get_loading_hours(self, duration: float, remaining_time: float) -> List[int]:
@@ -195,7 +200,12 @@ def ep_get_loading_hours(self, duration: float, remaining_time: float) -> List[i
             raise Exception("Kein Anbieter für strompreisbasiertes Laden konfiguriert.")
         try:
             prices = self.data.electricity_pricing.get.prices
+            log.debug("Berechne günstige Zeit-Slots für strompreisbasiertes Laden, "
+                      "benötigte Ladezeit: %.2f Sekunden, Restzeit bis Termin: %.2f Sekunden",
+                      duration, remaining_time)
+            log.debug("Verfügbare Preise: %s", prices)
             price_timeslot_seconds = self.__calculate_price_timeslot_length(prices)
+            log.debug("Preis-Zeitslot-Länge: %.2f Sekunden", price_timeslot_seconds)
             now = timecheck.create_timestamp()
             price_candidates = {
                 timestamp: price
@@ -212,43 +222,47 @@ def ep_get_loading_hours(self, duration: float, remaining_time: float) -> List[i
                       duration,
                       datetime.fromtimestamp(now),
                       datetime.fromtimestamp(now + remaining_time),
-                      datetime.fromtimestamp(float(min(price_candidates))),
-                      datetime.fromtimestamp(float(max(price_candidates))+price_timeslot_seconds))
+                      datetime.fromtimestamp(float(min(price_candidates, default=0))),
+                      datetime.fromtimestamp(float(max(price_candidates, default=0))+price_timeslot_seconds))
             ordered_by_date_reverse = reversed(sorted(price_candidates.items(), key=lambda x: x[0]))
             ordered_by_price = sorted(ordered_by_date_reverse, key=lambda x: x[1])
             selected_time_slots = {float(i[0]): float(i[1])
                                    for i in ordered_by_price[:1 + ceil(duration/price_timeslot_seconds)]}
             selected_lenght = (
                 price_timeslot_seconds * (len(selected_time_slots)-1) -
-                (float(now) - min(selected_time_slots))
+                (float(now) - min(selected_time_slots, default=now))
             )
             return sorted(selected_time_slots.keys()
-                          if not (min(selected_time_slots) > now or duration <= selected_lenght)
+                          if not (min(selected_time_slots, default=0) > now or duration <= selected_lenght)
                           else [timestamp[0] for timestamp in iter(selected_time_slots.items())][:-1]
                           )
             # if sum() sorted([int(i[0]) for i in ordered_by_price][:ceil(duration/price_timeslot_seconds)])
         except Exception as e:
             log.exception("Fehler im Optional-Modul: %s", e)
             return []
 
+    def _is_et_price_update_required_for_module(self, module: Union[FlexibleTariff, GridFee]) -> bool:
+        if module is None:
+            return False
+        if module.get.next_query_time is None:
+            return True
+        now = timecheck.create_timestamp()
+        next_query_formatted = datetime.fromtimestamp(module.get.next_query_time).strftime("%Y%m%d-%H:%M:%S")
+        if now > module.get.next_query_time:
+            log.debug(f'Wartezeit {next_query_formatted} für {module.name} abgelaufen, Strompreise werden abgefragt')
+            return True
+        else:
+            log.debug(f'Nächster Abruf der {module.name} Strompreise {next_query_formatted}.')
+            return False
+
     def et_price_update_required(self) -> bool:
         self._set_ep_configured()
         if self.data.electricity_pricing.configured is False:
             return False
         if len(self.data.electricity_pricing.get.prices) == 0:
             return True
-        if self.data.electricity_pricing.get.next_query_time is None:
-            return True
-        if timecheck.create_timestamp() > self.data.electricity_pricing.get.next_query_time:
-            next_query_formatted = datetime.fromtimestamp(
-                self.data.electricity_pricing.get.next_query_time).strftime("%Y%m%d-%H:%M:%S")
-            log.info(f'Wartezeit {next_query_formatted} abgelaufen, Strompreise werden abgefragt')
-            return True
-        else:
-            next_query_formatted = datetime.fromtimestamp(
-                self.data.electricity_pricing.get.next_query_time).strftime("%Y%m%d-%H:%M:%S")
-            log.info(f'Nächster Abruf der Strompreise {next_query_formatted}.')
-            return False
+        return (self._is_et_price_update_required_for_module(self.data.electricity_pricing.flexible_tariff) or
+                self._is_et_price_update_required_for_module(self.data.electricity_pricing.grid_fee))
 
     def ocpp_transfer_meter_values(self):
         try:

packages/control/optional_data.py

@@ -1,20 +1,15 @@
 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:
     fault_state: int = field(default=0)
+    next_query_time: int = field(default=0)
     fault_str: str = field(default=NO_ERROR)
     prices: Dict = field(default_factory=empty_dict_factory)
 
@@ -25,6 +20,7 @@ def create_pricing_get_with_topics(topic_prefix: str) -> PricingGet:
     pricing_get.__dataclass_fields__['fault_state'].metadata = {"topic": f"{topic_prefix}/get/fault_state"}
     pricing_get.__dataclass_fields__['fault_str'].metadata = {"topic": f"{topic_prefix}/get/fault_str"}
     pricing_get.__dataclass_fields__['prices'].metadata = {"topic": f"{topic_prefix}/get/prices"}
+    pricing_get.__dataclass_fields__['next_query_time'].metadata = {"topic": f"{topic_prefix}/get/next_query_time"}
     return pricing_get
 
 
@@ -39,6 +35,7 @@ def grid_fee_get_factory() -> PricingGet:
 @dataclass
 class FlexibleTariff:
     get: PricingGet = field(default_factory=flexible_tariff_get_factory)
+    name: str = field(default="flexible_tariff")
 
 
 def get_flexible_tariff_factory() -> FlexibleTariff:
@@ -48,6 +45,7 @@ def get_flexible_tariff_factory() -> FlexibleTariff:
 @dataclass
 class GridFee:
     get: PricingGet = field(default_factory=grid_fee_get_factory)
+    name: str = field(default="grid_fee")
 
 
 def get_grid_fee_factory() -> GridFee:
@@ -56,7 +54,6 @@ def get_grid_fee_factory() -> GridFee:
 
 @dataclass
 class ElectricityPricingGet:
-    next_query_time: Optional[float] = field(default=None, metadata={"topic": "ep/next_query_time"})
     _prices: Dict = field(default_factory=empty_dict_factory, metadata={"topic": "ep/prices"})
 
     @property
@@ -66,23 +63,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/control/optional_test.py

@@ -441,33 +441,43 @@ def test_et_charging_available_exception(monkeypatch):
 
 
 @pytest.mark.parametrize(
-    "prices, next_query_time, current_timestamp, expected",
+    "flexible_tariff, grid_fee, current_timestamp, expected",
     [
         pytest.param(
-            {}, None, 1698224400, True,
+            {"prices": {}, "next_query_time": None},
+            {"prices": {}, "next_query_time": None},
+            1698224400, True,
             id="update_required_when_no_prices"
         ),
         pytest.param(
-            {"1698224400": 0.1, "1698228000": 0.2}, 1698310800, 1698224400, False,
+            {"prices": {"1698224400": 0.1, "1698228000": 0.2}, "next_query_time": 1698310800},
+            {"prices": {}, "next_query_time": None},
+            1698224400, False,
             id="no_update_required_when_next_query_time_not_reached"
         ),
         pytest.param(
-            {"1698224400": 0.1, "1698228000": 0.2}, 1698224000, 1698310800, True,
+            {"prices": {"1698224400": 0.1, "1698228000": 0.2}, "next_query_time": 1698224000},
+            {"prices": {}, "next_query_time": None},
+            1698310800, True,
             id="update_required_when_next_query_time_passed"
         ),
         pytest.param(
-            {"1609459200": 0.1, "1609462800": 0.2}, None, 1698224400, True,
+            {"prices": {"1609459200": 0.1, "1609462800": 0.2}, "next_query_time": None},
+            {"prices": {}, "next_query_time": None},
+            1698224400, True,
             id="update_required_when_prices_from_yesterday"
         ),
     ]
 )
-def test_et_price_update_required(monkeypatch, prices, next_query_time, current_timestamp, expected):
+def test_et_price_update_required(monkeypatch, flexible_tariff, grid_fee, current_timestamp, expected):
     # setup
     opt = Optional()
     opt._flexible_tariff_module = Mock()
     opt._grid_fee_module = Mock()
-    opt.data.electricity_pricing.get.prices = prices
-    opt.data.electricity_pricing.get.next_query_time = next_query_time
+    opt.data.electricity_pricing.get.prices = flexible_tariff["prices"]
+    opt.data.electricity_pricing.flexible_tariff.get.prices = flexible_tariff["prices"]
+    opt.data.electricity_pricing.flexible_tariff.get.next_query_time = flexible_tariff["next_query_time"]
+    opt.data.electricity_pricing.grid_fee = None
 
     monkeypatch.setattr(timecheck, "create_timestamp", Mock(return_value=current_timestamp))
     opt.data.electricity_pricing.configured = True

packages/helpermodules/setdata.py

@@ -872,12 +872,12 @@ def process_optional_topic(self, msg: mqtt.MQTTMessage):
                     self._validate_value(msg, float)
                 elif re.search(f"{pricing_regex}get/fault_state$", msg.topic) is not None:
                     self._validate_value(msg, int, [(0, 2)])
+                elif re.search(f"{pricing_regex}get/next_query_time$", msg.topic) is not None:
+                    self._validate_value(msg, int)
                 elif re.search(f"{pricing_regex}get/fault_str$", msg.topic) is not None:
                     self._validate_value(msg, str)
             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)
             elif "openWB/set/optional/ep/configured" in msg.topic:
                 self._validate_value(msg, bool)
             elif "module_update_completed" in msg.topic: