PreCommit Fixed

src/akkudoktoreos/class_akku.py

@@ -88,7 +88,7 @@ def ladezustand_in_prozent(self):
         return (self.soc_wh / self.kapazitaet_wh) * 100
 
     def energie_abgeben(self, wh, hour):
-        if self.discharge_array[hour] == 0 :
+        if self.discharge_array[hour] == 0:
             return 0.0, 0.0  # No energy discharge and no losses
 
         # Calculate the maximum energy that can be discharged considering min_soc and efficiency
@@ -122,7 +122,7 @@ def energie_laden(self, wh, hour, relative_power=0.0):
         if hour is not None and self.charge_array[hour] == 0:
             return 0, 0  # Charging not allowed in this hour
         if relative_power > 0.0:
-            wh=self.max_ladeleistung_w*relative_power
+            wh = self.max_ladeleistung_w * relative_power
         # If no value for wh is given, use the maximum charging power
         wh = wh if wh is not None else self.max_ladeleistung_w
 
@@ -134,16 +134,16 @@ def energie_laden(self, wh, hour, relative_power=0.0):
         max_possible_charge_wh = max(max_possible_charge_wh, 0.0)  # Ensure non-negative
 
         # The actually charged energy cannot exceed requested energy, charging power, or maximum possible charge
-        effektive_lademenge = min(wh,  max_possible_charge_wh)
-        
+        effektive_lademenge = min(wh, max_possible_charge_wh)
+
         # Energy actually stored in the battery
         geladene_menge = effektive_lademenge * self.lade_effizienz
 
         # Update soc_wh
         self.soc_wh += geladene_menge
         # Ensure soc_wh does not exceed max_soc_wh
         self.soc_wh = min(self.soc_wh, self.max_soc_wh)
-        
+
         # Calculate losses
         verluste_wh = effektive_lademenge - geladene_menge
         return geladene_menge, verluste_wh

src/akkudoktoreos/class_ems.py

@@ -1,8 +1,10 @@
 from datetime import datetime
 from typing import Dict, List, Optional, Union
-from akkudoktoreos.config import *
+
 import numpy as np
 
+from akkudoktoreos.config import prediction_hours
+
 
 class EnergieManagementSystem:
     def __init__(
@@ -23,16 +25,16 @@ def __init__(
         self.eauto = eauto
         self.haushaltsgeraet = haushaltsgeraet
         self.wechselrichter = wechselrichter
-        self.ac_charge_hours = np.full(prediction_hours,0)
-        self.dc_charge_hours = np.full(prediction_hours,1)
-        self.ev_charge_hours = np.full(prediction_hours,0)
+        self.ac_charge_hours = np.full(prediction_hours, 0)
+        self.dc_charge_hours = np.full(prediction_hours, 1)
+        self.ev_charge_hours = np.full(prediction_hours, 0)
 
     def set_akku_discharge_hours(self, ds: List[int]) -> None:
         self.akku.set_discharge_per_hour(ds)
 
     def set_akku_ac_charge_hours(self, ds: np.ndarray) -> None:
         self.ac_charge_hours = ds
-    
+
     def set_akku_dc_charge_hours(self, ds: np.ndarray) -> None:
         self.dc_charge_hours = ds
 
@@ -52,11 +54,11 @@ def simuliere_ab_jetzt(self) -> dict:
         return self.simuliere(start_stunde)
 
     def simuliere(self, start_stunde: int) -> dict:
-        '''
+        """
         hour:
             akku_soc_pro_stunde begin of the hour, initial hour state!
             last_wh_pro_stunde integral of  last hour (end state)
-        '''
+        """
 
         lastkurve_wh = self.gesamtlast
         assert (
@@ -82,10 +84,10 @@ def simuliere(self, start_stunde: int) -> dict:
         akku_soc_pro_stunde[0] = self.akku.ladezustand_in_prozent()
         if self.eauto:
             eauto_soc_pro_stunde[0] = self.eauto.ladezustand_in_prozent()
-        
-        for stunde in range(start_stunde , ende):
+
+        for stunde in range(start_stunde, ende):
             stunde_since_now = stunde - start_stunde
-            
+
             # Accumulate loads and PV generation
             verbrauch = self.gesamtlast[stunde]
             verluste_wh_pro_stunde[stunde_since_now] = 0.0
@@ -95,28 +97,32 @@ def simuliere(self, start_stunde: int) -> dict:
                 haushaltsgeraet_wh_pro_stunde[stunde_since_now] = ha_load
 
             # E-Auto handling
-            if self.eauto and self.ev_charge_hours[stunde]>0:
-                geladene_menge_eauto, verluste_eauto = self.eauto.energie_laden(None, stunde, relative_power=self.ev_charge_hours[stunde])
+            if self.eauto and self.ev_charge_hours[stunde] > 0:
+                geladene_menge_eauto, verluste_eauto = self.eauto.energie_laden(
+                    None, stunde, relative_power=self.ev_charge_hours[stunde]
+                )
                 verbrauch += geladene_menge_eauto
                 verluste_wh_pro_stunde[stunde_since_now] += verluste_eauto
-                
+
             if self.eauto:
                 eauto_soc_pro_stunde[stunde_since_now] = self.eauto.ladezustand_in_prozent()
             # Process inverter logic
             erzeugung = self.pv_prognose_wh[stunde]
-            self.akku.set_charge_allowed_for_hour(self.dc_charge_hours[stunde],stunde)
+            self.akku.set_charge_allowed_for_hour(self.dc_charge_hours[stunde], stunde)
             netzeinspeisung, netzbezug, verluste, eigenverbrauch = (
                 self.wechselrichter.energie_verarbeiten(erzeugung, verbrauch, stunde)
             )
 
             # AC PV Battery Charge
             if self.ac_charge_hours[stunde] > 0.0:
-                self.akku.set_charge_allowed_for_hour(1,stunde)
-                geladene_menge, verluste_wh = self.akku.energie_laden(None,stunde,relative_power=self.ac_charge_hours[stunde])
-                #print(stunde, " ", geladene_menge, " ",self.ac_charge_hours[stunde]," ",self.akku.ladezustand_in_prozent())
+                self.akku.set_charge_allowed_for_hour(1, stunde)
+                geladene_menge, verluste_wh = self.akku.energie_laden(
+                    None, stunde, relative_power=self.ac_charge_hours[stunde]
+                )
+                # print(stunde, " ", geladene_menge, " ",self.ac_charge_hours[stunde]," ",self.akku.ladezustand_in_prozent())
                 verbrauch += geladene_menge
-                netzbezug +=geladene_menge
-                verluste_wh_pro_stunde[stunde_since_now] += verluste_wh      
+                netzbezug += geladene_menge
+                verluste_wh_pro_stunde[stunde_since_now] += verluste_wh
 
             netzeinspeisung_wh_pro_stunde[stunde_since_now] = netzeinspeisung
             netzbezug_wh_pro_stunde[stunde_since_now] = netzbezug

src/akkudoktoreos/class_numpy_encoder.py

@@ -1,24 +1,25 @@
 import json
+
 import numpy as np
 
+
 class NumpyEncoder(json.JSONEncoder):
     def default(self, obj):
         if isinstance(obj, np.ndarray):
             return obj.tolist()  # Convert NumPy arrays to lists
         if isinstance(obj, np.generic):
             return obj.item()  # Convert NumPy scalars to native Python types
         return super(NumpyEncoder, self).default(obj)
-    
+
     @staticmethod
     def dumps(data):
         """
         Static method to serialize a Python object into a JSON string using NumpyEncoder.
-        
+
         Args:
             data: The Python object to serialize.
-        
+
         Returns:
             str: A JSON string representation of the object.
         """
         return json.dumps(data, cls=NumpyEncoder)
-