Implement code to write the amount of energy bought and timestamps to file

Author: felixschndr

solar_forecast_and_power_buy_logger.sh

@@ -14,23 +14,6 @@ source "${env_temp}"
 log_directory=${DIRECTORY_OF_LOGS:-logs/}
 logfile=${log_directory}/app${environment}.log
 
-###### Find values of energy buy ######
-start_string="Starting to work..."
-temp_file_output_energy_buy=$(mktemp)
-
-tac "$logfile" | while read -r line; do
-    echo "$line" >>"${temp_file_output_energy_buy}"
-    [[ "$line" == *"$start_string"* ]] && break
-done
-
-timestamp_start=$(grep "Starting to charge" "${temp_file_output_energy_buy}" | awk '{print $1}' | tr -d '[]')
-if [[ -n ${timestamp_start} ]]; then
-    # happens if there was no need to charge and thus no charging occurred
-    timestamp_end=$(grep "Charging finished" "${temp_file_output_energy_buy}" | awk '{print $1}' | tr -d '[]')
-    amount_of_energy_bought=$(grep "Bought" "${temp_file_output_energy_buy}" | sed -n 's/.*Bought \([0-9]*\) Wh.*/\1/p')
-
-    echo -e "${timestamp_start}\t${timestamp_end}\t${amount_of_energy_bought}" >>"${log_directory}/energy_buy${environment}.log"
-fi
 
 ###### Find values of solar forecast ######
 start_string="The expected solar output for today"
@@ -50,4 +33,4 @@ echo -e "${date}\t${solar_forecast_expected}\t${solar_forecast_real}" >>"${log_d
 
 ###### Cleanup ######
 
-rm "${temp_file_output_energy_buy}" "${temp_output_solar_forecast}" "${env_temp}"
+rm "${temp_output_solar_forecast}" "${env_temp}"

source/inverter_charge_controller.py

@@ -1,4 +1,4 @@
-from datetime import date, datetime, timedelta
+from datetime import datetime, timedelta
 
 import pause
 from abscence_handler import AbsenceHandler
@@ -164,9 +164,23 @@ def _do_iteration(self) -> datetime:  # FIXME: Find better name
             f"Need to charge to {required_state_of_charge} % in order to reach the next minimum with {target_min_state_of_charge} % left"
         )
 
+        energy_bought_before_charging = self.sems_portal_api_handler.get_energy_buy()
+        timestamp_starting_to_charge = datetime.now(tz=self.timezone)
+        self.log.debug(f"The amount of energy bought before charging is {energy_bought_before_charging}")
+
         # TODO: Implement error handling
         self._charge_inverter(required_state_of_charge)
 
+        timestamp_ending_to_charge = datetime.now(tz=self.timezone)
+        energy_bought = self._calculate_amount_of_energy_bought(
+            energy_bought_before_charging, timestamp_starting_to_charge, timestamp_ending_to_charge
+        )
+        self.log.info(f"Bought {energy_bought} to charge the battery")
+
+        self._write_energy_buy_statistics_to_file(
+            timestamp_starting_to_charge, timestamp_ending_to_charge, energy_bought
+        )
+
         return next_price_minimum
 
     def _charge_inverter(self, target_state_of_charge: int) -> None:
@@ -180,10 +194,6 @@ def _charge_inverter(self, target_state_of_charge: int) -> None:
         charging_progress_check_interval = timedelta(minutes=5)
         dry_run = EnvironmentVariableGetter.get(name_of_variable="DRY_RUN", default_value=True)
 
-        energy_bought_before_charging = self.sems_portal_api_handler.get_energy_buy()
-        date_starting_to_charge = date.today()
-        self.log.debug(f"The amount of energy bought before charging is {energy_bought_before_charging}")
-
         self.log.info("Starting to charge")
         self.inverter.set_operation_mode(OperationMode.ECO_CHARGE)
 
@@ -219,15 +229,13 @@ def _charge_inverter(self, target_state_of_charge: int) -> None:
                 f"Charging is still ongoing (current: {current_state_of_charge} %, target: >= {target_state_of_charge} %) --> Waiting for another {charging_progress_check_interval}..."
             )
 
-        energy_bought = self._calculate_amount_of_energy_bought(energy_bought_before_charging, date_starting_to_charge)
-        self.log.info(f"Bought {energy_bought} to charge the battery")
-
     def _calculate_amount_of_energy_bought(
-        self, energy_bought_before_charging: EnergyAmount, date_starting_to_charge: date
+        self,
+        energy_bought_before_charging: EnergyAmount,
+        timestamp_starting_to_charge: datetime,
+        timestamp_ending_to_charge: datetime,
     ) -> EnergyAmount:
-        date_ending_to_charge = date.today()
-
-        if date_starting_to_charge == date_ending_to_charge:
+        if timestamp_starting_to_charge.date() == timestamp_ending_to_charge.date():
             energy_bought_today_after_charging = self.sems_portal_api_handler.get_energy_buy()
             self.log.debug(
                 f"It is till the same day since starting to charge, the amount of energy bought after charging is {energy_bought_today_after_charging}"
@@ -240,3 +248,12 @@ def _calculate_amount_of_energy_bought(
             f"It is the next day since starting to charge, the amount of energy bought after charging (today) is {energy_bought_today_after_charging}, the amount of energy bought after charging (yesterday) is {energy_bought_yesterday}"
         )
         return energy_bought_today_after_charging + energy_bought_yesterday
+
+    def _write_energy_buy_statistics_to_file(
+        self, timestamp_starting_to_charge: datetime, timestamp_ending_to_charge: datetime, energy_bought: EnergyAmount
+    ) -> None:
+        filename = super().directory_of_logs + "/energy_buy_prod.log"
+        with open(filename, "a") as f:
+            f.write(
+                f"{timestamp_starting_to_charge.isoformat()}\t{timestamp_ending_to_charge.isoformat()}\t{energy_bought.watt_hours}\n"
+            )

source/logger.py

@@ -36,11 +36,11 @@ def _set_logger(self, root_logger: logging.Logger) -> None:
         directory_of_repository = pathlib.Path(__file__).parent.parent.resolve()
         directory_of_logs_default_value = os.path.join(directory_of_repository, "logs")
 
-        directory_of_logs = EnvironmentVariableGetter.get(
+        self._directory_of_logs = EnvironmentVariableGetter.get(
             name_of_variable="DIRECTORY_OF_LOGS",
             default_value=directory_of_logs_default_value,
         )
-        self._create_logging_directory_if_necessary(directory_of_logs)
+        self._create_logging_directory_if_necessary(self._directory_of_logs)
 
         log_level = EnvironmentVariableGetter.get(name_of_variable="LOGLEVEL", default_value="INFO").upper()
         environment = EnvironmentVariableGetter.get("ENVIRONMENT", "")
@@ -52,7 +52,7 @@ def _set_logger(self, root_logger: logging.Logger) -> None:
         )
 
         file_handler = RotatingFileHandler(
-            os.path.join(directory_of_logs, f"app{environment}.log"),
+            os.path.join(self._directory_of_logs, f"app{environment}.log"),
             maxBytes=1024 * 1024,
             backupCount=7,
         )
@@ -116,3 +116,7 @@ def _write_newlines_to_log_file(self, amount_of_newlines: int = 2) -> None:
             amount_of_newlines: Number of newline characters to write. Default is 2.
         """
         self.log.parent.handlers[0].stream.write("".join("\n" for _ in range(amount_of_newlines)))
+
+    @property
+    def directory_of_logs(self) -> str:
+        return self._directory_of_logs