Refresh of calculation methods

custom_components/entsoe/const.py

@@ -21,10 +21,13 @@
 
 # default is only for internal use / backwards compatibility
 CALCULATION_MODE = {
-    "default": "publish",
-    "rotation": "rotation",
-    "sliding": "sliding",
-    "publish": "publish",
+    "default":      "publish",
+    "publish":      "publish",       
+    "daily":        "daily",         
+    "sliding":      "sliding",       
+    "sliding-12":   "sliding-12",   # new half day sliding
+    "forward":      "forward",     # 24hrs forward looking
+    "forward-12":   "forward-12",  # 12hrs forward looking
 }
 
 ENERGY_SCALES = { "kWh": 1000, "MWh": 1 }

custom_components/entsoe/coordinator.py

@@ -121,7 +121,8 @@ async def _async_update_data(self) -> dict:
             self.data = parsed_data
             self.filtered_hourprices = self._filter_calculated_hourprices(parsed_data)
             return parsed_data
-
+
+    # fetching of new data is needed when (1) we have no data, (2) when todays data is below 20 hrs or (3) tomorrows data is below 20hrs and its after 11
     def check_update_needed(self, now):
         if self.data is None:
             return True
@@ -178,6 +179,7 @@ async def get_energy_prices(self, start_date, end_date):
             }
         return self.parse_hourprices(await self.fetch_prices(start_date, end_date))
 
+    # TODO: this method is called by each sensor, each hour. Change the code so only the first will update 
     def update_data(self):
         now = dt.now()
         if self.today.date() != now.date():
@@ -190,27 +192,43 @@ def today_data_available(self):
         return len(self.get_data_today()) > MIN_HOURS
 
     def _filter_calculated_hourprices(self, data):
-        # rotation = calculations made upon 24hrs today
-        if self.calculation_mode == CALCULATION_MODE["rotation"]:
+        if self.calculation_mode == CALCULATION_MODE["daily"]:
+            self.logger.debug(f"Filter dataset for prices today -> refresh each day")
             return {
                 hour: price
                 for hour, price in data.items()
                 if hour >= self.today and hour < self.today + timedelta(days=1)
             }
-        # sliding = calculations made on all data from the current hour and beyond (future data only)
+
         elif self.calculation_mode == CALCULATION_MODE["sliding"]:
-            now = dt.now().replace(minute=0, second=0, microsecond=0)
-            return {hour: price for hour, price in data.items() if hour >= now}
-        # publish >48 hrs of data = calculations made on all data of today and tomorrow (48 hrs)
-        elif self.calculation_mode == CALCULATION_MODE["publish"] and len(data) > 48:
-            return {hour: price for hour, price in data.items() if hour >= self.today}
-        # publish <=48 hrs of data = calculations made on all data of yesterday and today (48 hrs) 
-        elif self.calculation_mode == CALCULATION_MODE["publish"]:
-            return {
-                hour: price
-                for hour, price in data.items()
-                if hour >= self.today - timedelta(days=1)
-            }
+            start = dt.now().replace(minute=0, second=0, microsecond=0)
+            start -= timedelta(hours=12)
+            end = start + timedelta(hours=24)
+            self.logger.debug(f"Filter dataset to surrounding 24hrs {start} - {end} -> refresh each hour")
+            return {hour: price for hour, price in data.items() if start < hour < end }
+
+        elif self.calculation_mode == CALCULATION_MODE["sliding-12"]:
+            start = dt.now().replace(minute=0, second=0, microsecond=0)
+            start -= timedelta(hours=6)
+            end = start + timedelta(hours=12)
+            self.logger.debug(f"Filter dataset to surrounding 12hrs {start} - {end} -> refresh each hour")
+            return {hour: price for hour, price in data.items() if start < hour < end }
+
+        elif self.calculation_mode == CALCULATION_MODE["forward"]:
+            start = dt.now().replace(minute=0, second=0, microsecond=0)
+            end = start + timedelta(hours=24)
+            self.logger.debug(f"Filter dataset to upcomming 24hrs {start} - {end} -> refresh each hour")
+            return {hour: price for hour, price in data.items() if start < hour < end }
+
+        elif self.calculation_mode == CALCULATION_MODE["forward-12"]:
+            start = dt.now().replace(minute=0, second=0, microsecond=0)
+            end = start + timedelta(hours=12)
+            self.logger.debug(f"Filter dataset to upcomming 12hrs {start} - {end} -> refresh each hour")
+            return {hour: price for hour, price in data.items() if start < hour < end }
+
+        # default elif self.calculation_mode == CALCULATION_MODE["publish"]:
+        self.logger.debug(f"Do not filter the dataset, use the complete dataset as fetched")
+        return { hour: price for hour, price in data.items() }
 
     def get_prices_today(self):
         return self.get_timestamped_prices(self.get_data_today())