feat: Added support for weighting for target timeframes not in minimum and maximum mode (3 hours dev time)

Author: BottlecapDave

_docs/setup/rolling_target_timeframe.md

@@ -100,7 +100,7 @@ There may be times that you want the target timeframe sensors to not take into a
 
 !!! info
 
-    This is only available for **continuous** target value sensors in **exact** hours mode.
+    This is only available for **continuous** target value sensors.
 
 There may be times when the device you're wanting the target value sensor to turn on doesn't have a consistent power draw. You can specify a weighting/multiplier which can be applied to the value of each discovered 30 minute slot. This can be specified in a few different ways. Take the following example weighting/multiplier for a required 2 hours.
 

_docs/setup/target_timeframe.md

@@ -128,7 +128,7 @@ There may be times that you want the target timeframe sensors to not take into a
 
 !!! info
 
-    This is only available for **continuous** target value sensors in **exact** hours mode.
+    This is only available for **continuous** target value sensors.
 
 There may be times when the device you're wanting the target value sensor to turn on doesn't have a consistent power draw. You can specify a weighting/multiplier which can be applied to the value of each discovered 30 minute slot. This can be specified in a few different ways. Take the following example weighting/multiplier for a required 2 hours.
 

custom_components/target_timeframes/config/rolling_target_timeframe.py

@@ -6,6 +6,7 @@
   CONFIG_TARGET_HOURS,
   CONFIG_TARGET_HOURS_MODE,
   CONFIG_TARGET_HOURS_MODE_EXACT,
+  CONFIG_TARGET_HOURS_MODE_MAXIMUM,
   CONFIG_TARGET_HOURS_MODE_MINIMUM,
   CONFIG_TARGET_MAX_VALUE,
   CONFIG_TARGET_MIN_VALUE,
@@ -120,14 +121,19 @@ def validate_rolling_target_timeframe_config(data):
       number_of_slots = int(data[CONFIG_TARGET_HOURS] * 2)
       weighting = create_weighting(data[CONFIG_TARGET_WEIGHTING], number_of_slots)
 
-      if (len(weighting) != number_of_slots):
-        errors[CONFIG_TARGET_WEIGHTING] = "invalid_weighting_slots"
+      if (weighting is None or len(weighting) != number_of_slots):
+        if CONFIG_TARGET_HOURS_MODE in data and data[CONFIG_TARGET_HOURS_MODE] == CONFIG_TARGET_HOURS_MODE_MINIMUM:
+          errors[CONFIG_TARGET_WEIGHTING] = "invalid_minimum_weighting_slots"
+        elif CONFIG_TARGET_HOURS_MODE in data and data[CONFIG_TARGET_HOURS_MODE] == CONFIG_TARGET_HOURS_MODE_MAXIMUM:
+          errors[CONFIG_TARGET_WEIGHTING] = "invalid_maximum_weighting_slots"
+        else:
+          errors[CONFIG_TARGET_WEIGHTING] = "invalid_weighting_slots"
+
+      if CONFIG_TARGET_HOURS_MODE in data and data[CONFIG_TARGET_HOURS_MODE] != CONFIG_TARGET_HOURS_MODE_EXACT and "*" not in data[CONFIG_TARGET_WEIGHTING]:
+        errors[CONFIG_TARGET_WEIGHTING] = "weighting_not_varied_for_hour_mode"
 
     if data[CONFIG_TARGET_TYPE] != CONFIG_TARGET_TYPE_CONTINUOUS:
       errors[CONFIG_TARGET_WEIGHTING] = "weighting_not_supported_for_type"
-    
-    if CONFIG_TARGET_HOURS_MODE in data and data[CONFIG_TARGET_HOURS_MODE] != CONFIG_TARGET_HOURS_MODE_EXACT:
-      errors[CONFIG_TARGET_WEIGHTING] = "weighting_not_supported_for_hour_mode"
 
   if CONFIG_TARGET_HOURS_MODE in data and data[CONFIG_TARGET_HOURS_MODE] == CONFIG_TARGET_HOURS_MODE_MINIMUM:
     if (CONFIG_TARGET_MIN_VALUE not in data or data[CONFIG_TARGET_MIN_VALUE] is None) and (CONFIG_TARGET_MAX_VALUE not in data or data[CONFIG_TARGET_MAX_VALUE] is None):

custom_components/target_timeframes/config/target_timeframe.py

@@ -9,6 +9,7 @@
   CONFIG_TARGET_HOURS,
   CONFIG_TARGET_HOURS_MODE,
   CONFIG_TARGET_HOURS_MODE_EXACT,
+  CONFIG_TARGET_HOURS_MODE_MAXIMUM,
   CONFIG_TARGET_HOURS_MODE_MINIMUM,
   CONFIG_TARGET_MAX_VALUE,
   CONFIG_TARGET_MIN_VALUE,
@@ -146,14 +147,19 @@ def validate_target_timeframe_config(data):
       number_of_slots = int(data[CONFIG_TARGET_HOURS] * 2)
       weighting = create_weighting(data[CONFIG_TARGET_WEIGHTING], number_of_slots)
 
-      if (len(weighting) != number_of_slots):
-        errors[CONFIG_TARGET_WEIGHTING] = "invalid_weighting_slots"
+      if (weighting is None or len(weighting) != number_of_slots):
+        if CONFIG_TARGET_HOURS_MODE in data and data[CONFIG_TARGET_HOURS_MODE] == CONFIG_TARGET_HOURS_MODE_MINIMUM:
+          errors[CONFIG_TARGET_WEIGHTING] = "invalid_minimum_weighting_slots"
+        elif CONFIG_TARGET_HOURS_MODE in data and data[CONFIG_TARGET_HOURS_MODE] == CONFIG_TARGET_HOURS_MODE_MAXIMUM:
+          errors[CONFIG_TARGET_WEIGHTING] = "invalid_maximum_weighting_slots"
+        else:
+          errors[CONFIG_TARGET_WEIGHTING] = "invalid_weighting_slots"
+
+      if CONFIG_TARGET_HOURS_MODE in data and data[CONFIG_TARGET_HOURS_MODE] != CONFIG_TARGET_HOURS_MODE_EXACT and "*" not in data[CONFIG_TARGET_WEIGHTING]:
+        errors[CONFIG_TARGET_WEIGHTING] = "weighting_not_varied_for_hour_mode"
 
     if data[CONFIG_TARGET_TYPE] != CONFIG_TARGET_TYPE_CONTINUOUS:
       errors[CONFIG_TARGET_WEIGHTING] = "weighting_not_supported_for_type"
-    
-    if CONFIG_TARGET_HOURS_MODE in data and data[CONFIG_TARGET_HOURS_MODE] != CONFIG_TARGET_HOURS_MODE_EXACT:
-      errors[CONFIG_TARGET_WEIGHTING] = "weighting_not_supported_for_hour_mode"
 
   if CONFIG_TARGET_HOURS_MODE in data and data[CONFIG_TARGET_HOURS_MODE] == CONFIG_TARGET_HOURS_MODE_MINIMUM:
     if (CONFIG_TARGET_MIN_VALUE not in data or data[CONFIG_TARGET_MIN_VALUE] is None) and (CONFIG_TARGET_MAX_VALUE not in data or data[CONFIG_TARGET_MAX_VALUE] is None):

custom_components/target_timeframes/entities/__init__.py

@@ -141,7 +141,7 @@ def calculate_continuous_times(
     find_latest_values = False,
     min_value = None,
     max_value = None,
-    weighting: list = None,
+    weighting: str = None,
     hours_mode = CONFIG_TARGET_HOURS_MODE_EXACT,
     context: str = None
   ):
@@ -151,9 +151,6 @@ def calculate_continuous_times(
   applicable_time_periods_count = len(applicable_time_periods)
   total_required_time_periods = math.ceil(target_hours * 2)
 
-  if weighting is not None and len(weighting) != total_required_time_periods:
-    raise ValueError(f"{context} - Weighting does not match target hours")
-
   best_continuous_time_periods = None
   best_continuous_time_periods_total = None
 
@@ -169,8 +166,6 @@ def calculate_continuous_times(
       continue
 
     continuous_time_periods = [time_period]
-    value_weight = Decimal(time_period["weighting"]) if "weighting" in time_period else 1
-    continuous_rates_total = Decimal(time_period["value"]) * value_weight * (weighting[0] if weighting is not None and len(weighting) > 0 else 1)
 
     for offset in range(1, total_required_time_periods if hours_mode != CONFIG_TARGET_HOURS_MODE_MINIMUM else applicable_time_periods_count):
       if (index + offset) < applicable_time_periods_count:
@@ -183,21 +178,12 @@ def calculate_continuous_times(
           break
 
         continuous_time_periods.append(offset_time_period)
-        value_weight = Decimal(offset_time_period["weighting"]) if "weighting" in offset_time_period else 1
-        continuous_rates_total += Decimal(offset_time_period["value"]) * value_weight * (weighting[offset] if weighting is not None else 1)
       else:
         break
 
     current_continuous_time_periods_length = len(continuous_time_periods)
     best_continuous_time_periods_length = len(best_continuous_time_periods) if best_continuous_time_periods is not None else 0
 
-    is_best_continuous_rates = False
-    if best_continuous_time_periods is not None:
-      if search_for_highest_value:
-        is_best_continuous_rates = (continuous_rates_total >= best_continuous_time_periods_total if find_latest_values else continuous_rates_total > best_continuous_time_periods_total)
-      else:
-        is_best_continuous_rates = (continuous_rates_total <= best_continuous_time_periods_total if find_latest_values else continuous_rates_total < best_continuous_time_periods_total)
-
     has_required_hours = False
     if hours_mode == CONFIG_TARGET_HOURS_MODE_EXACT:
       has_required_hours = current_continuous_time_periods_length == total_required_time_periods
@@ -206,12 +192,26 @@ def calculate_continuous_times(
     elif hours_mode == CONFIG_TARGET_HOURS_MODE_MAXIMUM:
       has_required_hours = current_continuous_time_periods_length <= total_required_time_periods and current_continuous_time_periods_length >= best_continuous_time_periods_length
 
-    if ((best_continuous_time_periods is None or is_best_continuous_rates) and has_required_hours):
-      best_continuous_time_periods = continuous_time_periods
-      best_continuous_time_periods_total = continuous_rates_total
-      _LOGGER.debug(f'{context} - New best block discovered {continuous_rates_total} ({continuous_time_periods[0]["start"] if len(continuous_time_periods) > 0 else None} - {continuous_time_periods[-1]["end"] if len(continuous_time_periods) > 0 else None})')
-    else:
-      _LOGGER.debug(f'{context} - Total rates for current block {continuous_rates_total} ({continuous_time_periods[0]["start"] if len(continuous_time_periods) > 0 else None} - {continuous_time_periods[-1]["end"] if len(continuous_time_periods) > 0 else None}). Total rates for best block {best_continuous_time_periods_total}')
+    if has_required_hours:
+      weighting_values = create_weighting(weighting, len(continuous_time_periods))
+      if weighting_values is not None:
+        continuous_rates_total = sum([Decimal(rate["value"]) * weighting_values[index] for index, rate in enumerate(continuous_time_periods)])
+      else:
+        continuous_rates_total = sum([Decimal(rate["value"]) for rate in continuous_time_periods])
+
+      is_best_continuous_rates = False
+      if best_continuous_time_periods is not None:
+        if search_for_highest_value:
+          is_best_continuous_rates = (continuous_rates_total >= best_continuous_time_periods_total if find_latest_values else continuous_rates_total > best_continuous_time_periods_total)
+        else:
+          is_best_continuous_rates = (continuous_rates_total <= best_continuous_time_periods_total if find_latest_values else continuous_rates_total < best_continuous_time_periods_total)
+
+      if is_best_continuous_rates or best_continuous_time_periods is None:
+        best_continuous_time_periods = continuous_time_periods
+        best_continuous_time_periods_total = continuous_rates_total
+        _LOGGER.debug(f'{context} - New best block discovered {continuous_rates_total} ({continuous_time_periods[0]["start"] if len(continuous_time_periods) > 0 else None} - {continuous_time_periods[-1]["end"] if len(continuous_time_periods) > 0 else None})')
+      else:
+        _LOGGER.debug(f'{context} - Total rates for current block {continuous_rates_total} ({continuous_time_periods[0]["start"] if len(continuous_time_periods) > 0 else None} - {continuous_time_periods[-1]["end"] if len(continuous_time_periods) > 0 else None}). Total rates for best block {best_continuous_time_periods_total}')
 
   if best_continuous_time_periods is not None:
     # Make sure our rates are in ascending order before returning
@@ -409,6 +409,9 @@ def create_weighting(config: str, number_of_slots: int):
 
   parts = config.split(',')
   parts_length = len(parts)
+  if parts_length > number_of_slots:
+    return None
+
   weighting = []
   for index in range(parts_length):
     if (parts[index] == "*"):

custom_components/target_timeframes/entities/rolling_target_timeframe.py

@@ -163,8 +163,7 @@ async def async_update(self):
         )
 
         if applicable_time_periods is not None:
-          number_of_slots = math.ceil(target_hours * 2)
-          weighting = create_weighting(self._config[CONFIG_TARGET_WEIGHTING] if CONFIG_TARGET_WEIGHTING in self._config else None, number_of_slots)
+          weighting = self._config[CONFIG_TARGET_WEIGHTING] if CONFIG_TARGET_WEIGHTING in self._config else None
 
           if (self._config[CONFIG_TARGET_TYPE] == CONFIG_TARGET_TYPE_CONTINUOUS):
             self._target_timeframes = calculate_continuous_times(

custom_components/target_timeframes/entities/target_timeframe.py

@@ -195,8 +195,7 @@ async def async_update(self):
         )
 
         if applicable_time_periods is not None and is_target_timeframe_complete == False:
-          number_of_slots = math.ceil(target_hours * 2)
-          weighting = create_weighting(self._config[CONFIG_TARGET_WEIGHTING] if CONFIG_TARGET_WEIGHTING in self._config else None, number_of_slots)
+          weighting = self._config[CONFIG_TARGET_WEIGHTING] if CONFIG_TARGET_WEIGHTING in self._config else None
 
           proposed_target_timeframes = None
           if (self._config[CONFIG_TARGET_TYPE] == CONFIG_TARGET_TYPE_CONTINUOUS):

custom_components/target_timeframes/translations/en.json

@@ -130,8 +130,10 @@
         "invalid_value": "Value must be in decimal format (e.g. 0.10)",
         "invalid_weighting": "The weighting format is not supported. Please consult documentation for more information.",
         "invalid_weighting_slots": "The number of weighting blocks does not equal the specified number of hours.",
+        "invalid_minimum_weighting_slots": "The number of weighting blocks is higher than the specified number of minimum hours.",
+        "invalid_maximum_weighting_slots": "The number of weighting blocks is higher than the specified number of maximum hours.",
+        "weighting_not_varied_for_hour_mode": "The weighting must include a variable block (*) if the hour mode is not exact",
         "weighting_not_supported_for_type": "Weighting is only supported for continuous target values",
-        "weighting_not_supported_for_hour_mode": "Weighting is not supported for this hour mode",
         "minimum_or_maximum_value_not_specified": "Either minimum and/or maximum value must be specified for minimum hours mode",
         "minimum_value_not_less_than_maximum_value": "Minimum value must be less or equal to the maximum value if both are specified",
         "invalid_integer": "Value must be a number with no decimal places",
@@ -212,8 +214,10 @@
         "invalid_value": "Value must be in decimal format (e.g. 0.10)",
         "invalid_weighting": "The weighting format is not supported. Please consult documentation for more information.",
         "invalid_weighting_slots": "The number of weighting blocks does not equal the specified number of hours.",
+        "invalid_minimum_weighting_slots": "The number of weighting blocks is higher than the specified number of minimum hours.",
+        "invalid_maximum_weighting_slots": "The number of weighting blocks is higher than the specified number of maximum hours.",
+        "weighting_not_varied_for_hour_mode": "The weighting must include a variable block (*) if the hour mode is not exact",
         "weighting_not_supported_for_type": "Weighting is only supported for continuous target values",
-        "weighting_not_supported_for_hour_mode": "Weighting is not supported for this hour mode",
         "minimum_or_maximum_value_not_specified": "Either minimum and/or maximum value must be specified for minimum hours mode",
         "minimum_value_not_less_than_maximum_value": "Minimum value must be less or equal to the maximum value if both are specified",
         "invalid_integer": "Value must be a number with no decimal places",

tests/unit/config/test_validate_rolling_target_timeframe_config.py

@@ -321,15 +321,15 @@ async def test_when_minimum_value_greater_to_maximum_value_is_specified_then_err
   (CONFIG_TARGET_HOURS_MODE_MINIMUM),
   (CONFIG_TARGET_HOURS_MODE_MAXIMUM),
 ])
-async def test_when_hour_mode_is_not_exact_and_weighting_specified_then_error_returned(hour_mode: str):
+async def test_when_hour_mode_is_not_exact_and_weighting_is_not_varied_then_error_returned(hour_mode: str):
   # Arrange
   data = {
     CONFIG_TARGET_TYPE: CONFIG_TARGET_TYPE_CONTINUOUS,
     CONFIG_TARGET_NAME: "test",
     CONFIG_TARGET_HOURS: "1.5",
     CONFIG_ROLLING_TARGET_HOURS_LOOK_AHEAD: "2",
     CONFIG_TARGET_OFFSET: "-00:30:00",
-    CONFIG_TARGET_WEIGHTING: "2,*,2",
+    CONFIG_TARGET_WEIGHTING: "2,1,2,2",
     CONFIG_TARGET_MIN_VALUE: "0.18",
     CONFIG_TARGET_HOURS_MODE: hour_mode
   }
@@ -339,7 +339,51 @@ async def test_when_hour_mode_is_not_exact_and_weighting_specified_then_error_re
 
   # Assert
   assert CONFIG_TARGET_WEIGHTING in errors
-  assert errors[CONFIG_TARGET_WEIGHTING] == "weighting_not_supported_for_hour_mode"
+  assert errors[CONFIG_TARGET_WEIGHTING] == "weighting_not_varied_for_hour_mode"
+  assert_errors_not_present(errors, default_keys, CONFIG_TARGET_WEIGHTING)
+
+@pytest.mark.asyncio
+async def test_when_hour_mode_is_minimum_and_weighting_too_small_then_error_returned():
+  # Arrange
+  data = {
+    CONFIG_TARGET_TYPE: CONFIG_TARGET_TYPE_CONTINUOUS,
+    CONFIG_TARGET_NAME: "test",
+    CONFIG_TARGET_HOURS: "1.5",
+    CONFIG_ROLLING_TARGET_HOURS_LOOK_AHEAD: "2",
+    CONFIG_TARGET_OFFSET: "-00:30:00",
+    CONFIG_TARGET_WEIGHTING: "2,*,2,2",
+    CONFIG_TARGET_MIN_VALUE: "0.18",
+    CONFIG_TARGET_HOURS_MODE: CONFIG_TARGET_HOURS_MODE_MINIMUM
+  }
+
+  # Act
+  errors = validate_rolling_target_timeframe_config(data)
+
+  # Assert
+  assert CONFIG_TARGET_WEIGHTING in errors
+  assert errors[CONFIG_TARGET_WEIGHTING] == "invalid_minimum_weighting_slots"
+  assert_errors_not_present(errors, default_keys, CONFIG_TARGET_WEIGHTING)
+
+@pytest.mark.asyncio
+async def test_when_hour_mode_is_maximum_and_weighting_too_large_then_error_returned():
+  # Arrange
+  data = {
+    CONFIG_TARGET_TYPE: CONFIG_TARGET_TYPE_CONTINUOUS,
+    CONFIG_TARGET_NAME: "test",
+    CONFIG_TARGET_HOURS: "1.5",
+    CONFIG_ROLLING_TARGET_HOURS_LOOK_AHEAD: "2",
+    CONFIG_TARGET_OFFSET: "-00:30:00",
+    CONFIG_TARGET_WEIGHTING: "2,1,*,2,2",
+    CONFIG_TARGET_MIN_VALUE: "0.18",
+    CONFIG_TARGET_HOURS_MODE: CONFIG_TARGET_HOURS_MODE_MAXIMUM
+  }
+
+  # Act
+  errors = validate_rolling_target_timeframe_config(data)
+
+  # Assert
+  assert CONFIG_TARGET_WEIGHTING in errors
+  assert errors[CONFIG_TARGET_WEIGHTING] == "invalid_maximum_weighting_slots"
   assert_errors_not_present(errors, default_keys, CONFIG_TARGET_WEIGHTING)
 
 @pytest.mark.asyncio