Fixes

packages/control/algorithm/common.py

@@ -60,15 +60,15 @@ def get_min_current(chargepoint: Chargepoint) -> Tuple[List[float], List[int]]:
 # tested
 
 
-def set_current_counterdiff(diff_curent: float,
+def set_current_counterdiff(diff_current: float,
                             current: float,
                             chargepoint: Chargepoint,
                             surplus: bool = False) -> None:
     required_currents = chargepoint.data.control_parameter.required_currents
     considered_current = consider_less_charging_chargepoint_in_loadmanagement(
         chargepoint, current)
     # gar nicht ladende Autos?
-    diff = max(considered_current - diff_curent, 0)
+    diff = max(considered_current - diff_current, 0)
     diffs = [diff if required_currents[i] != 0 else 0 for i in range(3)]
     if max(diffs) > 0:
         counters = data.data.counter_all_data.get_counters_to_check(chargepoint.num)

packages/control/algorithm/integration_test/instant_charging_test.py

@@ -119,8 +119,8 @@ def test_instant_charging_limit(params: ParamsLimit, all_cp_instant_charging_1p,
     data.data.counter_data["counter0"].data.set.raw_power_left = params.raw_power_left
     data.data.counter_data["counter0"].data.set.raw_currents_left = params.raw_currents_left_counter0
     data.data.counter_data["counter6"].data.set.raw_currents_left = params.raw_currents_left_counter6
-    mockget_component_name_by_id = Mock(return_value="Garage")
-    monkeypatch.setattr(loadmanagement, "get_component_name_by_id", mockget_component_name_by_id)
+    mock_get_component_name_by_id = Mock(return_value="Garage")
+    monkeypatch.setattr(loadmanagement, "get_component_name_by_id", mock_get_component_name_by_id)
     # execution
     Algorithm().calc_current()
 
@@ -196,8 +196,8 @@ def test_control_parameter_instant_charging(params: ParamsControlParameter, all_
     data.data.counter_data["counter0"].data.set.raw_power_left = 22080
     data.data.counter_data["counter0"].data.set.raw_currents_left = [32]*3
     data.data.counter_data["counter6"].data.set.raw_currents_left = [16]*3
-    mockget_component_name_by_id = Mock(return_value="Garage")
-    monkeypatch.setattr(loadmanagement, "get_component_name_by_id", mockget_component_name_by_id)
+    mock_get_component_name_by_id = Mock(return_value="Garage")
+    monkeypatch.setattr(loadmanagement, "get_component_name_by_id", mock_get_component_name_by_id)
 
     # execution
     Algorithm().calc_current()

packages/control/algorithm/integration_test/pv_charging_test.py

@@ -221,8 +221,8 @@ def test_surplus(params: ParamsSurplus, all_cp_pv_charging_3p, all_cp_charging_3
     data.data.counter_data["counter0"].data.set.raw_power_left = params.raw_power_left
     data.data.counter_data["counter0"].data.set.raw_currents_left = params.raw_currents_left_counter0
     data.data.counter_data["counter6"].data.set.raw_currents_left = params.raw_currents_left_counter6
-    mockget_component_name_by_id = Mock(return_value="Garage")
-    monkeypatch.setattr(loadmanagement, "get_component_name_by_id", mockget_component_name_by_id)
+    mock_get_component_name_by_id = Mock(return_value="Garage")
+    monkeypatch.setattr(loadmanagement, "get_component_name_by_id", mock_get_component_name_by_id)
     data.data.cp_data["cp3"].data.set.charge_template.data.chargemode.pv_charging.phases_to_use = 1
     data.data.cp_data["cp4"].data.set.charge_template.data.chargemode.pv_charging.phases_to_use = 1
     data.data.cp_data["cp5"].data.set.charge_template.data.chargemode.pv_charging.phases_to_use = 1

packages/control/algorithm/surplus_controlled.py

@@ -64,7 +64,7 @@ def _set(self,
                 dif_to_old_current = available_for_cp + cp.data.set.target_current - cp.data.set.current_prev
                 # Wenn die Differenz zwischen altem und neuem Soll-Strom größer als der Regelbereich ist, trotzdem
                 # nachregeln, auch wenn der Regelbereich eingehalten wird. Sonst würde zB nicht berücksichtigt werden,
-                # wenn noch ein Fahrzeug dazu kommmt.
+                # wenn noch ein Fahrzeug dazu kommt.
                 if ((pv_charging.control_range[1] - pv_charging.control_range[0]) /
                         (sum(counter.data.get.voltages) / len(counter.data.get.voltages)) < abs(dif_to_old_current)):
                     current = available_for_cp

packages/control/auto_phase_switch_test.py

@@ -1,5 +1,5 @@
-import threading
 import pytest
+from threading import Event
 from typing import List, Optional
 from unittest.mock import Mock
 from control.chargepoint.control_parameter import ControlParameter
@@ -23,7 +23,7 @@ def vehicle() -> Ev:
 
 @pytest.fixture(autouse=True)
 def data_module() -> None:
-    data.data_init(threading.Event())
+    data.data_init(Event())
     data.data.general_data = General()
     data.data.pv_all_data = PvAll()
     data.data.bat_all_data = BatAll()

packages/control/chargepoint/chargepoint.py

@@ -18,7 +18,7 @@
 from dataclasses import asdict
 import dataclasses
 import logging
-import threading
+from threading import Thread, Event
 import traceback
 from typing import Dict, Optional, Tuple
 
@@ -70,7 +70,7 @@ class Chargepoint(ChargepointRfidMixin):
     """
     MAX_FAILED_PHASE_SWITCHES = 2
 
-    def __init__(self, index: int, event: Optional[threading.Event]):
+    def __init__(self, index: int, event: Optional[Event]):
         try:
             self.template: CpTemplate = None
             self.chargepoint_module: AbstractChargepoint = None
@@ -321,7 +321,7 @@ def initiate_control_pilot_interruption(self):
                     # Wird die Ladung gestartet?
                     if self.data.set.current_prev == 0 and self.data.set.current != 0:
                         # Die CP-Unterbrechung erfolgt in Threads, da diese länger als ein Zyklus dauert.
-                        if thread_handler(threading.Thread(
+                        if thread_handler(Thread(
                                 target=self.chargepoint_module.interrupt_cp,
                                 args=(charging_ev.ev_template.data.control_pilot_interruption_duration,),
                                 name=f"cp{self.chargepoint_module.config.id}")):

packages/control/chargepoint/chargepoint_data.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, field
-import threading
+from threading import Event
 from typing import Dict, List, Optional, Protocol
 from control.chargepoint.chargepoint_template import CpTemplate
 
@@ -174,7 +174,7 @@ class Config:
     ocpp_chargebox_id: Optional[str] = None
 
     def __post_init__(self):
-        self.event_update_state: threading.Event
+        self.event_update_state: Event
 
     @property
     def ev(self) -> int:
@@ -217,7 +217,7 @@ class ChargepointData:
     set: Set = field(default_factory=set_factory)
     config: Config = field(default_factory=config_factory)
 
-    def set_event(self, event: Optional[threading.Event] = None) -> None:
+    def set_event(self, event: Optional[Event] = None) -> None:
         self.event_update_state = event
         if event:
             self.config.event_update_state = event

packages/control/chargepoint/chargepoint_state_update.py

@@ -1,7 +1,6 @@
 import copy
 import logging
-from threading import Thread
-import threading
+from threading import Thread, Event
 from typing import Dict
 
 from control.chargepoint.chargepoint import Chargepoint
@@ -14,13 +13,13 @@
 class ChargepointStateUpdate:
     def __init__(self,
                  index: int,
-                 event_copy_data: threading.Event,
-                 event_global_data_initialized: threading.Event,
+                 event_copy_data: Event,
+                 event_global_data_initialized: Event,
                  cp_template_data: Dict,
                  ev_data: Dict,
                  ev_charge_template_data: Dict,
                  ev_template_data: Dict) -> None:
-        self.event_update_state = threading.Event()
+        self.event_update_state = Event()
         self.event_copy_data = event_copy_data
         self.event_global_data_initialized = event_global_data_initialized
         self.chargepoint: Chargepoint = Chargepoint(index, self.event_update_state)

packages/control/chargepoint/get_phases_test.py

@@ -1,4 +1,4 @@
-import threading
+from threading import Event
 from unittest.mock import Mock
 from typing import Optional
 import pytest
@@ -21,7 +21,7 @@ def cp() -> Chargepoint:
 
 @pytest.fixture(autouse=True)
 def general() -> None:
-    data.data_init(threading.Event())
+    data.data_init(Event())
     data.data.general_data = General()
 
 
@@ -131,36 +131,36 @@ def __init__(self,
                  prevent_phase_switch: bool,
                  phases_in_use: int,
                  imported_since_plugged: float,
-                 phase_switch_suppported: bool,
+                 phase_switch_supported: bool,
                  expected_phases: int) -> None:
         self.name = name
         self.phases = phases
         self.prevent_phase_switch = prevent_phase_switch
         self.phases_in_use = phases_in_use
         self.imported_since_plugged = imported_since_plugged
-        self.phase_switch_suppported = phase_switch_suppported
+        self.phase_switch_supported = phase_switch_supported
         self.expected_phases = expected_phases
 
 
 cases_set_phases = [
     SetPhasesParams(name="Phases don't change", phases=1, phases_in_use=1, prevent_phase_switch=True,
-                    imported_since_plugged=0, phase_switch_suppported=True, expected_phases=1),
+                    imported_since_plugged=0, phase_switch_supported=True, expected_phases=1),
     SetPhasesParams(name="Charging didn't started yet", phases=1, phases_in_use=3, prevent_phase_switch=True,
-                    imported_since_plugged=0, phase_switch_suppported=True, expected_phases=1),
+                    imported_since_plugged=0, phase_switch_supported=True, expected_phases=1),
     SetPhasesParams(name="EV doesn't support phase wich", phases=1, phases_in_use=3, prevent_phase_switch=True,
-                    imported_since_plugged=1, phase_switch_suppported=True, expected_phases=3),
+                    imported_since_plugged=1, phase_switch_supported=True, expected_phases=3),
     SetPhasesParams(name="Switch phases", phases=1, phases_in_use=3, prevent_phase_switch=False,
-                    imported_since_plugged=1, phase_switch_suppported=True, expected_phases=1),
+                    imported_since_plugged=1, phase_switch_supported=True, expected_phases=1),
     SetPhasesParams(name="Phase switch not supported by cp", phases=1, phases_in_use=3, prevent_phase_switch=False,
-                    imported_since_plugged=1, phase_switch_suppported=False, expected_phases=1)
+                    imported_since_plugged=1, phase_switch_supported=False, expected_phases=1)
 ]
 
 
 @pytest.mark.parametrize("params", cases_set_phases, ids=[c.name for c in cases_set_phases])
 def test_set_phases(monkeypatch, cp: Chargepoint, params: SetPhasesParams):
     # setup
-    mock_phase_switch_suppported = Mock(name="phase_switch_suppported", return_value=params.phase_switch_suppported)
-    monkeypatch.setattr(Chargepoint, "cp_ev_support_phase_switch", mock_phase_switch_suppported)
+    mock_phase_switch_supported = Mock(name="phase_switch_supported", return_value=params.phase_switch_supported)
+    monkeypatch.setattr(Chargepoint, "cp_ev_support_phase_switch", mock_phase_switch_supported)
     cp.data.get.phases_in_use = params.phases_in_use
     cp.data.set.log.imported_since_plugged = params.imported_since_plugged
     charging_ev_data = cp.data.set.charging_ev_data

packages/control/data.py

@@ -4,7 +4,7 @@
 """
 import copy
 import logging
-import threading
+from threading import Event, Lock
 from functools import wraps
 from typing import Dict
 from control.bat import Bat
@@ -30,27 +30,27 @@
 from modules.common.abstract_io import AbstractIoDevice
 
 log = logging.getLogger(__name__)
-bat_data_lock = threading.Lock()
-bat_all_data_lock = threading.Lock()
-graph_data_lock = threading.Lock()
-counter_data_lock = threading.Lock()
-counter_all_data_lock = threading.Lock()
-cp_data_lock = threading.Lock()
-cp_all_data_lock = threading.Lock()
-cp_template_data_lock = threading.Lock()
-ev_charge_template_data_lock = threading.Lock()
-ev_data_lock = threading.Lock()
-ev_template_data_lock = threading.Lock()
-general_data_lock = threading.Lock()
-io_actions_lock = threading.Lock()
-io_states_lock = threading.Lock()
-optional_data_lock = threading.Lock()
-pv_data_lock = threading.Lock()
-pv_all_data_lock = threading.Lock()
-system_data_lock = threading.Lock()
-
-
-def locked(lock: threading.Lock):
+bat_data_lock = Lock()
+bat_all_data_lock = Lock()
+graph_data_lock = Lock()
+counter_data_lock = Lock()
+counter_all_data_lock = Lock()
+cp_data_lock = Lock()
+cp_all_data_lock = Lock()
+cp_template_data_lock = Lock()
+ev_charge_template_data_lock = Lock()
+ev_data_lock = Lock()
+ev_template_data_lock = Lock()
+general_data_lock = Lock()
+io_actions_lock = Lock()
+io_states_lock = Lock()
+optional_data_lock = Lock()
+pv_data_lock = Lock()
+pv_all_data_lock = Lock()
+system_data_lock = Lock()
+
+
+def locked(lock: Lock):
     def decorate(method):
         @wraps(method)
         def inner(*args, **kwargs):
@@ -65,7 +65,7 @@ def inner(*args, **kwargs):
 
 
 class Data:
-    def __init__(self, event_module_update_completed: threading.Event):
+    def __init__(self, event_module_update_completed: Event):
         self.event_module_update_completed = event_module_update_completed
         self._bat_data: Dict[str, Bat] = {}
         self._bat_all_data = BatAll()
@@ -489,7 +489,7 @@ def __exit__(self, exception_type, exception, exception_traceback) -> bool:
 data: Data
 
 
-def data_init(event_module_update_completed: threading.Event):
+def data_init(event_module_update_completed: Event):
     """instanziiert die Data-Klasse.
     """
     global data

packages/control/ev/ev.py

@@ -288,9 +288,9 @@ def _check_phase_switch_conditions(self,
             feed_in_yield = 0
         all_surplus = data.data.counter_all_data.get_evu_counter().get_usable_surplus(feed_in_yield)
         required_surplus = control_parameter.min_current * max_phases_ev * 230 - get_power
-        unblanced_load_limit_reached = limit.limiting_value == LimitingValue.UNBALANCED_LOAD
+        unbalanced_load_limit_reached = limit.limiting_value == LimitingValue.UNBALANCED_LOAD
         condition_1_to_3 = (((get_medium_charging_current(get_currents) > max_current and
-                            all_surplus > required_surplus) or unblanced_load_limit_reached) and
+                            all_surplus > required_surplus) or unbalanced_load_limit_reached) and
                             phases_in_use == 1)
         condition_3_to_1 = get_medium_charging_current(
             get_currents) < min_current and all_surplus <= 0 and phases_in_use > 1

packages/control/limiting_value.py

@@ -7,7 +7,7 @@ class LimitingValue(Enum):
     CURRENT = ", da der Maximal-Strom an Zähler {} erreicht ist."
     POWER = ", da die maximale Leistung an Zähler {} erreicht ist."
     UNBALANCED_LOAD = ", da die maximale Schieflast an Zähler {} erreicht ist."
-    DIMMING = ", da die Dimmung die Ladeleistung bgrenzt."
+    DIMMING = ", da die Dimmung die Ladeleistung begrenzt."
     DIMMING_VIA_DIRECT_CONTROL = ", da die Dimmung per Direkt-Steuerung die Ladeleistung auf 4,2 kW begrenzt."
     RIPPLE_CONTROL_RECEIVER = (", da der Ladepunkt durch den RSE-Kontakt auf {}% der konfigurierten Anschlussleistung "
                                "reduziert wird.")

packages/control/ocpp.py

@@ -74,10 +74,10 @@ def start_transaction(self: OptionalProtocol,
                     timestamp=self._get_formatted_time()
                 ))
                 if ws:
-                    tansaction_id = json.loads(ws.messages[0])[2]["transactionId"]
-                    log.debug(f"Transaction ID: {tansaction_id} für Chargebox ID: {chargebox_id} mit Tag: {id_tag} und "
-                              f"Zählerstand: {imported} erhalten.")
-                    return tansaction_id
+                    transaction_id = json.loads(ws.messages[0])[2]["transactionId"]
+                    log.debug(f"Transaction ID: {transaction_id} für Chargebox ID: {chargebox_id} mit Tag: {id_tag} "
+                              f"und Zählerstand: {imported} erhalten.")
+                    return transaction_id
             except Exception as e:
                 fault_state.from_exception(e)
             return None

packages/control/optional.py

@@ -1,8 +1,8 @@
 """Optionale Module
 """
 import logging
-from math import ceil  # Aufrunden
-import threading
+from math import ceil
+from threading import Thread
 from typing import List
 
 from control import data
@@ -102,7 +102,7 @@ def et_get_loading_hours(self, duration: float, remaining_time: float) -> List[i
     def et_get_prices(self):
         try:
             if self.et_module:
-                thread_handler(threading.Thread(target=self.et_module.update, args=(), name="electricity tariff"))
+                thread_handler(Thread(target=self.et_module.update, args=(), name="electricity tariff"))
             else:
                 # Wenn kein Modul konfiguriert ist, Fehlerstatus zurücksetzen.
                 if self.data.et.get.fault_state != 0 or self.data.et.get.fault_str != NO_ERROR:
@@ -114,15 +114,15 @@ def et_get_prices(self):
     def ocpp_transfer_meter_values(self):
         try:
             if self.data.ocpp.active:
-                thread_handler(threading.Thread(target=self._transfer_meter_values, args=(), name="OCPP Client"))
+                thread_handler(Thread(target=self._transfer_meter_values, args=(), name="OCPP Client"))
         except Exception:
             log.exception("Fehler im OCPP-Optional-Modul")
 
     def _transfer_meter_values(self):
         for cp in data.data.cp_data.values():
             try:
                 if self.data.ocpp.boot_notification_sent is False:
-                    # Boot-Notfification nicht in der init-Funktion aufrufen, da noch nicht alles initialisiert ist
+                    # Boot-Notification nicht in der init-Funktion aufrufen, da noch nicht alles initialisiert ist
                     self.boot_notification(cp.data.config.ocpp_chargebox_id,
                                            cp.chargepoint_module.fault_state,
                                            cp.chargepoint_module.config.type,

packages/control/phase_switch.py

@@ -1,7 +1,7 @@
 """ Modul, das die Phasenumschaltung durchführt.
 """
 import logging
-import threading
+from threading import Thread
 import time
 
 from control.ev.ev import Ev
@@ -17,7 +17,7 @@ def thread_phase_switch(cp) -> None:
     """
     try:
         log.debug("Starte Thread zur Phasenumschaltung an LP"+str(cp.num))
-        return thread_handler(threading.Thread(
+        return thread_handler(Thread(
             target=_perform_phase_switch,
             args=(cp.chargepoint_module,
                   cp.data.control_parameter.phases,