WIP: Handle the state that it is not possible to reach the next price minimum

Author: felixschndr

source/inverter_charge_controller.py

@@ -245,8 +245,13 @@ def _calculate_target_soc(
                     "--> Proceeding with normal operation to determine the target state of charge"
                 )
             else:
-                # TODO: What to do in this case?
-                pass
+                self.log.info(
+                    f"It is not possible to reach the next price minimum with charging to {soc_full} "
+                    "--> Will determine the optimal points in time for charging around the price spike"
+                )
+                # This method charges the inverter itself and thus does not need the normal flow of operation
+                self._handle_next_price_minimum_is_unreachable()
+                return None
 
         if current_energy_rate > self.next_price_minimum:
             self.log.info(
@@ -285,6 +290,28 @@ def _calculate_target_soc(
 
         return charging_target_soc
 
+    def _handle_next_price_minimum_is_unreachable(self) -> None:
+        soc_full = StateOfCharge.from_percentage(100)
+
+        upcoming_energy_rates = self._get_upcoming_energy_rates()
+        energy_rate_before_price_rises_over_average, energy_rate_after_price_drops_after_average = (
+            self.tibber_api_handler.get_energy_rate_before_and_after_the_price_is_higher_than_the_average_until_timestamp(
+                upcoming_energy_rates, self.next_price_minimum.timestamp
+            )
+        )
+        self.log.info(
+            f"The last energy rate before the price rises over the average is "
+            f"{energy_rate_before_price_rises_over_average}. "
+            f"The first energy rate after the price drops is {energy_rate_after_price_drops_after_average}."
+            f"--> Will charge now to {soc_full} and then wait until "
+            f"{energy_rate_before_price_rises_over_average.timestamp}"
+        )
+        self.handle_charging(soc_full)
+        self.log.info(f"Waiting until {energy_rate_before_price_rises_over_average.timestamp}")
+        pause.until(energy_rate_before_price_rises_over_average.timestamp)
+
+        # TODO: Continue here
+
     def handle_charging(self, charging_target_soc: StateOfCharge) -> None:
         """
         Handles the charging process. This involves getting the energy bought before charging, charging the inverter,

source/tibber_api_handler.py

@@ -292,6 +292,59 @@ def _check_if_minimum_is_at_end_of_day_and_energy_rates_of_tomorrow_are_unavaila
 
         return is_price_minimum_near_end_of_day and are_tomorrows_rates_unavailable
 
+    def get_energy_rate_before_and_after_the_price_is_higher_than_the_average_until_timestamp(
+        self, upcoming_energy_rates: list[EnergyRate], ending_timestamp: datetime
+    ) -> tuple[EnergyRate, EnergyRate]:
+        """
+        Identifies two specific energy rates from a list of upcoming energy rates up to a given timestamp:
+        the last rate before the price is higher than the average and the first rate
+
+        Args:
+            upcoming_energy_rates (list[EnergyRate]): The list of upcoming energy rates.
+            ending_timestamp (datetime): A timestamp limiting the processing to only consider energy rates up to and
+                including this time.
+
+        Returns:
+            tuple[EnergyRate, EnergyRate]: A tuple containing:
+                - The energy rate before the price is higher than the average price up to the provided timestamp.
+                - The energy rate after the price is higher than the average price up to the provided timestamp.
+        """
+        average_price = self._get_average_price_of_energy_rates(upcoming_energy_rates)
+        self.log.debug(f"The average price of all upcoming energy rates is {average_price}")
+
+        upcoming_energy_rates_until_ending_timestamp = [
+            energy_rate for energy_rate in upcoming_energy_rates if energy_rate.timestamp <= ending_timestamp
+        ]
+
+        self.log.trace("Determining the last energy rate before the price is higher than the average price...")
+        energy_rate_before_the_price_is_higher_than_the_average = upcoming_energy_rates_until_ending_timestamp[0]
+        for energy_rate in upcoming_energy_rates_until_ending_timestamp:
+            if energy_rate.rate < average_price:
+                self.log.trace(f"The energy rate {energy_rate} is cheaper than the average price")
+                energy_rate_before_the_price_is_higher_than_the_average = energy_rate
+            else:
+                self.log.trace(f"The energy rate {energy_rate} is more expensive than the average price")
+                break
+
+        self.log.trace("Determining the first energy rate after the price was higher than the average price...")
+        energy_rate_after_the_price_is_higher_than_the_average = upcoming_energy_rates_until_ending_timestamp[-1]
+        for energy_rate in reversed(upcoming_energy_rates_until_ending_timestamp):
+            if energy_rate.rate < average_price:
+                self.log.trace(f"The energy rate {energy_rate} is cheaper than the average price")
+                energy_rate_after_the_price_is_higher_than_the_average = energy_rate
+            else:
+                self.log.trace(f"The energy rate {energy_rate} is more expensive than the average price")
+                break
+
+        return (
+            energy_rate_before_the_price_is_higher_than_the_average,
+            energy_rate_after_the_price_is_higher_than_the_average,
+        )
+
+    @staticmethod
+    def _get_average_price_of_energy_rates(energy_rates: list[EnergyRate]) -> float:
+        return sum(energy_rate.rate for energy_rate in energy_rates) / len(energy_rates)
+
     def write_energy_rates_to_database(self, energy_rates: list[EnergyRate]) -> None:
         """
         Writes the list of energy rates to the database while avoiding duplication of already existing data.