feat: added support to evaluate with incomplete data (1 hour dev time)

Author: BottlecapDave

_docs/setup/rolling_target_timeframe.md

@@ -113,6 +113,14 @@ Each slot weighting/multiplier must be a whole number or decimal number and be p
 
 You can also use weightings/multipliers to ignore slots. This can be done by assigning a value of 0 for the desired slot.
 
+### Dangerous settings
+
+These settings can have undesired effects and are not recommended to be changed, but there might be certain scenarios where this is the desired outcome.
+
+#### Calculate with incomplete data
+
+By default, the target timeframe isn't calculated if there isn't enough data for the period of time being evaluated. For example, if you have a look ahead hours set to 4 hours, it's 9pm and you only have data up to midnight, then the next target timeframe will not be calculated. If you turn this setting on, then the sensor will attempt to look for 4 hours worth of data if available, otherwise it will evaluate with whatever data is available (in this scenario 2 hours between 10pm and 12am).
+
 ## Attributes
 
 The following attributes are available on each sensor
@@ -141,6 +149,7 @@ The following attributes are available on each sensor
 | `next_min_value` | `float` | The average value for the next continuous discovered period. This will only be populated if `target_times` has been calculated and at least one period/block is in the future. |
 | `next_max_value` | `float` | The average value for the next continuous discovered period. This will only be populated if `target_times` has been calculated and at least one period/block is in the future. |
 | `target_times_last_evaluated` | datetime | The datetime the target times collection was last evaluated. This will occur if all previous target times are in the past and all values are available for the requested future time period. For example, if you are targeting 16:00 (day 1) to 16:00 (day 2), and you only have values up to 23:00 (day 1), then the target timeframes won't be calculated. |
+| `calculate_with_incomplete_data` | boolean | Determines if calculations should occur when there isn't enough data to satisfy the look ahead hours |
 
 ## Services
 

_docs/setup/target_timeframe.md

@@ -123,6 +123,14 @@ Each slot weighting/multiplier must be a whole number or decimal number and be p
 
 You can also use weightings/multipliers to ignore slots. This can be done by assigning a value of 0 for the desired slot.
 
+### Dangerous settings
+
+These settings can have undesired effects and are not recommended to be changed, but there might be certain scenarios where this is the desired outcome.
+
+#### Calculate with incomplete data
+
+By default, the target timeframe isn't calculated if there isn't enough data for the period of time being evaluated. For example, if you have a timeframe looking between 10pm and 2am, it's 9pm and you only have data up to midnight, then the next target timeframe will not be calculated. If you turn this setting on, then the sensor will attempt to look for data between 10pm and 2am if available, otherwise it will evaluate with whatever data is available (in this scenario 10pm to 12am).
+
 ## Attributes
 
 The following attributes are available on each sensor
@@ -154,6 +162,7 @@ The following attributes are available on each sensor
 | `next_min_value` | `float` | The average value for the next continuous discovered period. This will only be populated if `target_times` has been calculated and at least one period/block is in the future. |
 | `next_max_value` | `float` | The average value for the next continuous discovered period. This will only be populated if `target_times` has been calculated and at least one period/block is in the future. |
 | `target_times_last_evaluated` | datetime | The datetime the target times collection was last evaluated. This will occur if all previous target times are in the past and all values are available for the requested future time period. For example, if you are targeting 16:00 (day 1) to 16:00 (day 2), and you only have values up to 23:00 (day 1), then the target values won't be calculated. |
+| `calculate_with_incomplete_data` | boolean | Determines if calculations should occur when there isn't enough data to satisfy the look ahead hours |
 
 ## Services
 

custom_components/target_timeframes/const.py

@@ -1,6 +1,7 @@
 import voluptuous as vol
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers import selector
+from homeassistant.data_entry_flow import section
 
 DOMAIN = "target_timeframes"
 INTEGRATION_VERSION = "1.2.1"
@@ -37,6 +38,8 @@
 CONFIG_TARGET_TARGET_TIMES_EVALUATION_MODE_ALL_IN_PAST = "all_target_times_in_past"
 CONFIG_TARGET_TARGET_TIMES_EVALUATION_MODE_ALL_IN_FUTURE_OR_PAST = "all_target_times_in_future_or_past"
 CONFIG_TARGET_TARGET_TIMES_EVALUATION_MODE_ALWAYS = "always"
+CONFIG_TARGET_DANGEROUS_SETTINGS = "dangerous_settings"
+CONFIG_TARGET_CALCULATE_WITH_INCOMPLETE_DATA = "calculate_with_incomplete_data"
 
 CONFIG_ROLLING_TARGET_HOURS_LOOK_AHEAD = "look_ahead_hours"
 
@@ -54,7 +57,8 @@
   CONFIG_TARGET_MAX_VALUE,
   CONFIG_TARGET_WEIGHTING,
   CONFIG_ROLLING_TARGET_HOURS_LOOK_AHEAD,
-  CONFIG_TARGET_TARGET_TIMES_EVALUATION_MODE
+  CONFIG_TARGET_TARGET_TIMES_EVALUATION_MODE,
+  CONFIG_TARGET_DANGEROUS_SETTINGS
 ]
 
 REGEX_HOURS = "^[0-9]+(\\.[0-9]+)*$"
@@ -112,9 +116,17 @@
   vol.Optional(CONFIG_TARGET_ROLLING_TARGET, default=False): bool,
   vol.Optional(CONFIG_TARGET_LATEST_VALUES, default=False): bool,
   vol.Optional(CONFIG_TARGET_FIND_HIGHEST_VALUES, default=False): bool,
-  vol.Optional(CONFIG_TARGET_MIN_VALUE): vol.Coerce(float),
-  vol.Optional(CONFIG_TARGET_MAX_VALUE): vol.Coerce(float),
+  vol.Optional(CONFIG_TARGET_MIN_VALUE): float,
+  vol.Optional(CONFIG_TARGET_MAX_VALUE): float,
   vol.Optional(CONFIG_TARGET_WEIGHTING): str,
+  vol.Required(CONFIG_TARGET_DANGEROUS_SETTINGS): section(
+    vol.Schema(
+        {
+            vol.Required(CONFIG_TARGET_CALCULATE_WITH_INCOMPLETE_DATA, default=False): bool,
+        }
+    ),
+    {"collapsed": True},
+  ),
 })
 
 DATA_SCHEMA_ROLLING_TARGET_TIME_PERIOD = vol.Schema({
@@ -156,6 +168,14 @@
   vol.Optional(CONFIG_TARGET_MIN_VALUE): float,
   vol.Optional(CONFIG_TARGET_MAX_VALUE): float,
   vol.Optional(CONFIG_TARGET_WEIGHTING): str,
+  vol.Required(CONFIG_TARGET_DANGEROUS_SETTINGS): section(
+    vol.Schema(
+        {
+            vol.Required(CONFIG_TARGET_CALCULATE_WITH_INCOMPLETE_DATA, default=False): bool,
+        }
+    ),
+    {"collapsed": True},
+  ),
 })
 
 EVENT_DATA_SOURCE = "target_time_period_data_source_updated"

custom_components/target_timeframes/entities/__init__.py

@@ -76,7 +76,7 @@ def get_start_and_end_times(current_date: datetime, target_start_time: str, targ
 
   return (target_start, target_end)
 
-def get_fixed_applicable_time_periods(target_start: datetime, target_end: datetime, time_period_values: list, context: str = None):
+def get_fixed_applicable_time_periods(target_start: datetime, target_end: datetime, time_period_values: list, calculate_with_incomplete_data = False, context: str = None):
   _LOGGER.debug(f'{context} - Finding rates between {target_start} and {target_end}')
 
   # Retrieve the rates that are applicable for our target rate
@@ -92,13 +92,13 @@ def get_fixed_applicable_time_periods(target_start: datetime, target_end: dateti
   date_diff = target_end - target_start
   hours = (date_diff.days * 24) + (date_diff.seconds // 3600)
   periods = hours * 2
-  if len(applicable_rates) < periods:
+  if len(applicable_rates) < periods and calculate_with_incomplete_data == False:
     _LOGGER.debug(f'{context} - Incorrect number of periods discovered. Require {periods}, but only have {len(applicable_rates)}')
     return None
 
   return applicable_rates
 
-def get_rolling_applicable_time_periods(current_date: datetime, time_period_values: list, target_hours: float, context: str = None):
+def get_rolling_applicable_time_periods(current_date: datetime, time_period_values: list, target_hours: float, calculate_with_incomplete_data = False, context: str = None):
   # Retrieve the rates that are applicable for our target rate
   applicable_time_periods = []
   periods = target_hours * 2
@@ -113,7 +113,7 @@ def get_rolling_applicable_time_periods(current_date: datetime, time_period_valu
           break
 
   # Make sure that we have enough rates that meet our target period
-  if len(applicable_time_periods) < periods:
+  if len(applicable_time_periods) < periods and calculate_with_incomplete_data == False:
     _LOGGER.debug(f'{context} - Incorrect number of periods discovered. Require {periods}, but only have {len(applicable_time_periods)}')
     return None
 

custom_components/target_timeframes/entities/rolling_target_timeframe.py

@@ -20,6 +20,8 @@
 
 from ..const import (
   CONFIG_ROLLING_TARGET_HOURS_LOOK_AHEAD,
+  CONFIG_TARGET_CALCULATE_WITH_INCOMPLETE_DATA,
+  CONFIG_TARGET_DANGEROUS_SETTINGS,
   CONFIG_TARGET_TARGET_TIMES_EVALUATION_MODE,
   CONFIG_TARGET_HOURS_MODE,
   CONFIG_TARGET_MAX_VALUE,
@@ -69,16 +71,7 @@ def __init__(self, hass: HomeAssistant, data_source_id: str, config_entry, confi
     self._last_evaluated = None
     self._data_source_id = data_source_id
     self._attributes["data_source_id"] = self._data_source_id
-    
-    is_rolling_target = True
-    if CONFIG_TARGET_ROLLING_TARGET in self._config:
-      is_rolling_target = self._config[CONFIG_TARGET_ROLLING_TARGET]
-    self._attributes[CONFIG_TARGET_ROLLING_TARGET] = is_rolling_target
-
-    find_last_rates = False
-    if CONFIG_TARGET_LATEST_VALUES in self._config:
-      find_last_rates = self._config[CONFIG_TARGET_LATEST_VALUES]
-    self._attributes[CONFIG_TARGET_LATEST_VALUES] = find_last_rates
+    self.update_default_attributes()
 
     self._data_source_data = initial_data if initial_data is not None else []
     self._target_timeframes = []
@@ -150,10 +143,15 @@ async def async_update(self):
         if CONFIG_TARGET_MAX_VALUE in self._config:
           max_value = self._config[CONFIG_TARGET_MAX_VALUE]
 
+        calculate_with_incomplete_data = False
+        if CONFIG_TARGET_DANGEROUS_SETTINGS in self._config and CONFIG_TARGET_CALCULATE_WITH_INCOMPLETE_DATA in self._config[CONFIG_TARGET_DANGEROUS_SETTINGS]:
+          calculate_with_incomplete_data = self._config[CONFIG_TARGET_DANGEROUS_SETTINGS][CONFIG_TARGET_CALCULATE_WITH_INCOMPLETE_DATA]
+
         applicable_time_periods = get_rolling_applicable_time_periods(
           current_local_date,
           self._data_source_data,
           self._config[CONFIG_ROLLING_TARGET_HOURS_LOOK_AHEAD],
+          calculate_with_incomplete_data,
           self._config[CONFIG_TARGET_NAME]
         )
 
@@ -191,7 +189,7 @@ async def async_update(self):
           self._attributes["target_times_last_evaluated"] = current_date
           _LOGGER.debug(f"{self._config[CONFIG_TARGET_NAME]} - calculated rates: {self._target_timeframes}")
 
-        self._attributes["time_periods_incomplete"] = applicable_time_periods is None
+        self._attributes["time_periods_incomplete"] = applicable_time_periods is None or len(applicable_time_periods) < (target_hours * 2)
 
     active_result = get_target_time_period_info(current_date, self._target_timeframes, offset)
 
@@ -242,6 +240,7 @@ async def async_added_to_hass(self):
       if compare_config(self._config, self._attributes) == False:
         self._state = False
         self._attributes = self._config.copy()
+        self.update_default_attributes()
         self._target_timeframes = None
 
       _LOGGER.debug(f'{self._config[CONFIG_TARGET_NAME]} - Restored state: {self._state}')
@@ -300,6 +299,7 @@ async def async_update_rolling_target_timeframe_config(self, target_hours=None,
 
     self._config = config
     self._attributes = self._config.copy()
+    self.update_default_attributes()
     self._target_timeframes = []
     await self.async_update()
     self.async_write_ha_state()
@@ -313,4 +313,24 @@ async def async_update_rolling_target_timeframe_config(self, target_hours=None,
         self._config_entry,
         self._config_subentry,
         data = new_config_data
-      )
+      )
+
+  def update_default_attributes(self):
+    """Update the default attributes."""
+    self._attributes["data_source_id"] = self._data_source_id
+
+    is_rolling_target = True
+    if CONFIG_TARGET_ROLLING_TARGET in self._config:
+      is_rolling_target = self._config[CONFIG_TARGET_ROLLING_TARGET]
+    self._attributes[CONFIG_TARGET_ROLLING_TARGET] = is_rolling_target
+
+    find_last_rates = False
+    if CONFIG_TARGET_LATEST_VALUES in self._config:
+      find_last_rates = self._config[CONFIG_TARGET_LATEST_VALUES]
+    self._attributes[CONFIG_TARGET_LATEST_VALUES] = find_last_rates
+
+    calculate_with_incomplete_data = False
+    if CONFIG_TARGET_DANGEROUS_SETTINGS in self._config and CONFIG_TARGET_CALCULATE_WITH_INCOMPLETE_DATA in self._config[CONFIG_TARGET_DANGEROUS_SETTINGS]:
+      calculate_with_incomplete_data = self._config[CONFIG_TARGET_DANGEROUS_SETTINGS][CONFIG_TARGET_CALCULATE_WITH_INCOMPLETE_DATA]
+      del self._attributes[CONFIG_TARGET_DANGEROUS_SETTINGS]
+    self._attributes[CONFIG_TARGET_CALCULATE_WITH_INCOMPLETE_DATA] = calculate_with_incomplete_data

custom_components/target_timeframes/entities/target_timeframe.py

@@ -20,6 +20,8 @@
 from homeassistant.helpers import translation
 
 from ..const import (
+  CONFIG_TARGET_CALCULATE_WITH_INCOMPLETE_DATA,
+  CONFIG_TARGET_DANGEROUS_SETTINGS,
   CONFIG_TARGET_TARGET_TIMES_EVALUATION_MODE,
   CONFIG_TARGET_TARGET_TIMES_EVALUATION_MODE_ALL_IN_PAST,
   CONFIG_TARGET_HOURS_MODE,
@@ -73,17 +75,8 @@ def __init__(self, hass: HomeAssistant, data_source_id: str, config_entry, confi
     self._attributes = self._config.copy()
     self._last_evaluated = None
     self._data_source_id = data_source_id
-    self._attributes["data_source_id"] = self._data_source_id
-    
-    is_rolling_target = True
-    if CONFIG_TARGET_ROLLING_TARGET in self._config:
-      is_rolling_target = self._config[CONFIG_TARGET_ROLLING_TARGET]
-    self._attributes[CONFIG_TARGET_ROLLING_TARGET] = is_rolling_target
 
-    find_last_rates = False
-    if CONFIG_TARGET_LATEST_VALUES in self._config:
-      find_last_rates = self._config[CONFIG_TARGET_LATEST_VALUES]
-    self._attributes[CONFIG_TARGET_LATEST_VALUES] = find_last_rates
+    self.update_default_attributes()
 
     self._data_source_data = initial_data if initial_data is not None else []
     self._target_timeframes = []
@@ -167,11 +160,16 @@ async def async_update(self):
         if CONFIG_TARGET_MAX_VALUE in self._config:
           max_rate = self._config[CONFIG_TARGET_MAX_VALUE]
 
+        calculate_with_incomplete_data = False
+        if CONFIG_TARGET_DANGEROUS_SETTINGS in self._config and CONFIG_TARGET_CALCULATE_WITH_INCOMPLETE_DATA in self._config[CONFIG_TARGET_DANGEROUS_SETTINGS]:
+          calculate_with_incomplete_data = self._config[CONFIG_TARGET_DANGEROUS_SETTINGS][CONFIG_TARGET_CALCULATE_WITH_INCOMPLETE_DATA]
+
         target_start, target_end = get_start_and_end_times(current_local_date, start_time, end_time, True, self._config[CONFIG_TARGET_NAME])
         applicable_time_periods = get_fixed_applicable_time_periods(
           target_start,
           target_end,
           self._data_source_data,
+          calculate_with_incomplete_data,
           self._config[CONFIG_TARGET_NAME]
         )
 
@@ -220,7 +218,7 @@ async def async_update(self):
           self._attributes["target_times_last_evaluated"] = current_date
           _LOGGER.debug(f"{self._config[CONFIG_TARGET_NAME]} - calculated rates: {self._target_timeframes}")
 
-        self._attributes["time_periods_incomplete"] = applicable_time_periods is None
+        self._attributes["time_periods_incomplete"] = applicable_time_periods is None or len(applicable_time_periods) < (target_hours * 2)
 
     active_result = get_target_time_period_info(current_date, self._target_timeframes, offset)
 
@@ -271,6 +269,7 @@ async def async_added_to_hass(self):
       if compare_config(self._config, self._attributes) == False:
         self._state = False
         self._attributes = self._config.copy()
+        self.update_default_attributes()
         self._target_timeframes = None
 
       _LOGGER.debug(f'{self._config[CONFIG_TARGET_NAME]} - Restored state: {self._state}')
@@ -335,6 +334,7 @@ async def async_update_target_timeframe_config(self, target_start_time=None, tar
 
     self._config = config
     self._attributes = self._config.copy()
+    self.update_default_attributes()
     self._target_timeframes = []
     await self.async_update()
     self.async_write_ha_state()
@@ -348,4 +348,24 @@ async def async_update_target_timeframe_config(self, target_start_time=None, tar
         self._config_entry,
         self._config_subentry,
         data = new_config_data
-      )
+      )
+
+  def update_default_attributes(self):
+    """Update the default attributes."""
+    self._attributes["data_source_id"] = self._data_source_id
+
+    is_rolling_target = True
+    if CONFIG_TARGET_ROLLING_TARGET in self._config:
+      is_rolling_target = self._config[CONFIG_TARGET_ROLLING_TARGET]
+    self._attributes[CONFIG_TARGET_ROLLING_TARGET] = is_rolling_target
+
+    find_last_rates = False
+    if CONFIG_TARGET_LATEST_VALUES in self._config:
+      find_last_rates = self._config[CONFIG_TARGET_LATEST_VALUES]
+    self._attributes[CONFIG_TARGET_LATEST_VALUES] = find_last_rates
+
+    calculate_with_incomplete_data = False
+    if CONFIG_TARGET_DANGEROUS_SETTINGS in self._config and CONFIG_TARGET_CALCULATE_WITH_INCOMPLETE_DATA in self._config[CONFIG_TARGET_DANGEROUS_SETTINGS]:
+      calculate_with_incomplete_data = self._config[CONFIG_TARGET_DANGEROUS_SETTINGS][CONFIG_TARGET_CALCULATE_WITH_INCOMPLETE_DATA]
+      del self._attributes[CONFIG_TARGET_DANGEROUS_SETTINGS]
+    self._attributes[CONFIG_TARGET_CALCULATE_WITH_INCOMPLETE_DATA] = calculate_with_incomplete_data