Fix TypeError: int and str - ensure interval_minutes is int and always_allow_discharge_limit is float

Co-authored-by: MaStr <1036501+MaStr@users.noreply.github.com>

Author: Copilot

src/batcontrol/logic/common.py

@@ -16,14 +16,17 @@
 logger = logging.getLogger(__name__)
 
 # Singleton pattern to ensure only one instance of CommonLogic exists
+
+
 class CommonLogic:
     """ General logic for battery control that is not specific to control strategies. """
 
     _instance = None  # Singleton instance
     charge_rate_multiplier: float
     always_allow_discharge_limit: float
     max_capacity: float  # Maximum capacity of the battery in Wh
-    min_charge_energy: float = 100  # Minimum amount of energy before charging from grid in Wh
+    # Minimum amount of energy before charging from grid in Wh
+    min_charge_energy: float = 100
 
     @classmethod
     def get_instance(cls, charge_rate_multiplier=1.1,
@@ -34,9 +37,9 @@ def get_instance(cls, charge_rate_multiplier=1.1,
         if cls._instance is None:
             cls._instance = cls.__new__(cls)
             cls._instance.initialize(charge_rate_multiplier,
-                                 always_allow_discharge_limit,
-                                 max_capacity,
-                                 min_charge_energy)
+                                     always_allow_discharge_limit,
+                                     max_capacity,
+                                     min_charge_energy)
         return cls._instance
 
     def __init__(self, *args, **kwargs):
@@ -47,25 +50,41 @@ def __init__(self, *args, **kwargs):
         self.initialize(*args, **kwargs)
 
     def initialize(self, charge_rate_multiplier=1.1,
-               always_allow_discharge_limit=0.9,
-               max_capacity=10000,
-               min_charge_energy=100):
+                   always_allow_discharge_limit=0.9,
+                   max_capacity=10000,
+                   min_charge_energy=100):
         """ Private initialization method. """
-        self.charge_rate_multiplier = charge_rate_multiplier
-        self.always_allow_discharge_limit = always_allow_discharge_limit
-        self.max_capacity = max_capacity
-        self.min_charge_energy = min_charge_energy
+        self.charge_rate_multiplier = float(charge_rate_multiplier)
+        self.always_allow_discharge_limit = self._to_float(
+            always_allow_discharge_limit)
+        self.max_capacity = float(max_capacity)
+        self.min_charge_energy = float(min_charge_energy)
 
     def set_charge_rate_multiplier(self, multiplier: float):
         """ Set the charge rate multiplier. """
         logger.debug('Setting charge rate multiplier to %s', multiplier)
         self.charge_rate_multiplier = multiplier
 
+    @staticmethod
+    def _to_float(value) -> float:
+        """ Convert a value to float, handling European comma decimal notation.
+        Args:
+            value: The value to convert. Can be a float, int, or string
+                   (including European notation like '0,9').
+        Returns:
+            float: The converted value.
+        Raises:
+            ValueError: If the value cannot be converted to float.
+        """
+        if isinstance(value, str):
+            return float(value.replace(',', '.'))
+        return float(value)
+
     def set_always_allow_discharge_limit(self, limit: float):
         """ Set the always allowed discharge limit. """
         logger.debug(
             'Setting always allowed discharge limit to %s', limit)
-        self.always_allow_discharge_limit = limit
+        self.always_allow_discharge_limit = self._to_float(limit)
 
     def get_always_allow_discharge_limit(self) -> float:
         """ Get the always allowed discharge limit. """
@@ -92,11 +111,11 @@ def is_discharge_always_allowed_capacity(self, capacity: float) -> bool:
 
         if capacity >= self.max_capacity * self.always_allow_discharge_limit:
             logger.debug(
-                'Discharge is \'always allowed\' for current capacity: %.0f Wh', round(capacity,0))
+                'Discharge is \'always allowed\' for current capacity: %.0f Wh', round(capacity, 0))
             return True
 
         logger.debug(
-            'Discharge is NOT \'always allowed\' for current capacity: %.0f Wh', round(capacity,0))
+            'Discharge is NOT \'always allowed\' for current capacity: %.0f Wh', round(capacity, 0))
         return False
 
     def is_charging_above_minimum(self, needed_energy: float) -> bool:

src/batcontrol/logic/logic.py

@@ -6,22 +6,25 @@
 
 logger = logging.getLogger(__name__)
 
+
 class Logic:
     """ Factory for logic classes. """
     print_class_message = True
+
     @staticmethod
     def create_logic(config: dict, timezone) -> LogicInterface:
         """ Select and configure a logic class based on the given configuration """
         request_type = config.get('type', 'default').lower()
-        interval_minutes = config.get('time_resolution_minutes', 60)
+        interval_minutes = int(config.get('time_resolution_minutes', 60))
         logic = None
         if request_type == 'default':
             if Logic.print_class_message:
                 logger.info('Using default logic')
                 Logic.print_class_message = False
             logic = DefaultLogic(timezone, interval_minutes=interval_minutes)
             if config.get('battery_control_expert', None) is not None:
-                battery_control_expert = config.get( 'battery_control_expert', {})
+                battery_control_expert = config.get(
+                    'battery_control_expert', {})
                 attribute_list = [
                     'soften_price_difference_on_charging',
                     'soften_price_difference_on_charging_factor',
@@ -30,9 +33,10 @@ def create_logic(config: dict, timezone) -> LogicInterface:
                 ]
                 for attribute in attribute_list:
                     if attribute in battery_control_expert:
-                        logger.debug('Setting %s to %s', attribute ,
-                                                    battery_control_expert[attribute])
-                        setattr(logic, attribute, battery_control_expert[attribute])
+                        logger.debug('Setting %s to %s', attribute,
+                                     battery_control_expert[attribute])
+                        setattr(logic, attribute,
+                                battery_control_expert[attribute])
         else:
             raise RuntimeError(f'[Logic] Unknown logic type {config["type"]}')
         return logic

tests/batcontrol/logic/test_common.py

@@ -43,6 +43,25 @@ def test_set_always_allowed_discharge_limit(self):
         self.assertEqual(self.logic.always_allow_discharge_limit, new_limit)
         self.assertEqual(self.logic.get_always_allow_discharge_limit(), new_limit)
 
+    def test_set_always_allowed_discharge_limit_string(self):
+        """Test setting the always allowed discharge limit with a string value (dot notation)"""
+        self.logic.set_always_allow_discharge_limit('0.85')
+        self.assertIsInstance(self.logic.always_allow_discharge_limit, float)
+        self.assertAlmostEqual(self.logic.always_allow_discharge_limit, 0.85)
+
+    def test_set_always_allowed_discharge_limit_european_comma(self):
+        """Test setting the always allowed discharge limit with European comma notation"""
+        self.logic.set_always_allow_discharge_limit('0,85')
+        self.assertIsInstance(self.logic.always_allow_discharge_limit, float)
+        self.assertAlmostEqual(self.logic.always_allow_discharge_limit, 0.85)
+
+    def test_initialize_always_allow_discharge_limit_from_string(self):
+        """Test that initialize converts always_allow_discharge_limit string to float"""
+        CommonLogic._instance = None
+        logic = CommonLogic.get_instance(always_allow_discharge_limit='0,75')
+        self.assertIsInstance(logic.always_allow_discharge_limit, float)
+        self.assertAlmostEqual(logic.always_allow_discharge_limit, 0.75)
+
     def test_is_discharge_always_allowed_soc(self):
         """Test discharge always allowed when SOC is above threshold"""
         # SOC above the threshold (90%)

tests/batcontrol/logic/test_default.py

@@ -4,6 +4,7 @@
 import numpy as np
 
 from batcontrol.logic.default import DefaultLogic
+from batcontrol.logic.logic import Logic as LogicFactory
 from batcontrol.logic.logic_interface import CalculationInput, CalculationParameters, InverterControlSettings
 from batcontrol.logic.common import CommonLogic
 
@@ -46,6 +47,19 @@ def test_set_calculation_parameters(self):
         """Test setting calculation parameters"""
         self.assertEqual(self.logic.calculation_parameters, self.calculation_parameters)
 
+    def test_interval_minutes_is_int(self):
+        """Test that interval_minutes is always an int even when config provides a string"""
+        logic = LogicFactory.create_logic({'time_resolution_minutes': '60'}, datetime.timezone.utc)
+        self.assertIsInstance(logic.interval_minutes, int)
+        self.assertEqual(logic.interval_minutes, 60)
+
+    def test_interval_minutes_is_int_default(self):
+        """Test that interval_minutes defaults to int 60 when not in config"""
+        CommonLogic._instance = None
+        logic = LogicFactory.create_logic({}, datetime.timezone.utc)
+        self.assertIsInstance(logic.interval_minutes, int)
+        self.assertEqual(logic.interval_minutes, 60)
+
     def test_calculate_inverter_mode_high_soc(self):
         """Test calculate_inverter_mode with high SOC should allow discharge"""
         #max_capacity = 10000  # 10 kWh