Feat/intelligent changes (#1488)

BottlecapDave · web-flow · commit f1ebf1afab8f · 2025-09-28T12:53:03.000+01:00
diff --git a/_docs/blueprints/octopus_energy_manual_intelligent_refresh.yaml b/_docs/blueprints/octopus_energy_manual_intelligent_refresh.yaml
@@ -55,31 +55,59 @@ variables:
   millisecond_jitter: >
     {{ range(1, 1000) | random }}
 
-mode: queued
-max: 4
+mode: single
 triggers:
   - trigger: state
     id: car_plugged_in
     entity_id: !input car_plugged_in_sensor
     to: !input car_plugged_in_sensor_state
+  - trigger: state
+    id: car_unplugged
+    entity_id: !input car_plugged_in_sensor
+    from: !input car_plugged_in_sensor_state
+    not_to: !input car_plugged_in_sensor_state
   - trigger: time_pattern
+    id: periodic_check
     minutes: "/1"
 conditions:
-  - condition: state
-    entity_id: !input car_plugged_in_sensor
-    state: !input car_plugged_in_sensor_state
-  # Make sure that our dispatches are either due to be updated or our automation was triggered due to the vehicle being plugged in
   - condition: or
     conditions:
+    - condition: and
+      conditions:
+      - condition: state
+        entity_id: !input car_plugged_in_sensor
+        state: !input car_plugged_in_sensor_state
+      # Make sure that our dispatches are either due to be updated or our automation was triggered due to the vehicle being plugged in
+      - condition: or
+        conditions:
+        - condition: template
+          value_template: >
+            {{ trigger.id == "car_plugged_in" }}
+        - condition: template
+          value_template: >
+            {% set next_refresh = state_attr(intelligent_dispatches_data_last_retrieved_sensor, 'next_refresh') %}
+            {{ next_refresh == None or next_refresh | as_datetime | as_local < now() }}
     - condition: template
       value_template: >
-        {{ trigger.id == "car_plugged_in" }}
+        {{ trigger.id == "car_unplugged" }}
+actions:
+  # Wait 30 seconds to give OE a chance to update the dispatches if caused by car state change
+  - if:
     - condition: template
       value_template: >
-        {{ state_attr(intelligent_dispatches_data_last_retrieved_sensor, 'next_refresh') | as_datetime | as_local < now() }}
-actions:
-  # Wait 30 seconds to give OE a chance to update the dispatches
-  - delay: 00:00:30
+        {{ trigger.id != "periodic_check" }}
+    then:
+    - delay: 00:00:30
+  # Wait until we are under the request limit
+  - wait_template: >-
+      {% set requests_current_hour = state_attr(intelligent_dispatches_data_last_retrieved_sensor, 'requests_current_hour') %}
+      {% set maximum_requests_per_hour = state_attr(intelligent_dispatches_data_last_retrieved_sensor, 'maximum_requests_per_hour') %}
+      {% set request_limits_last_reset = state_attr(intelligent_dispatches_data_last_retrieved_sensor, 'request_limits_last_reset') %}
+      {{ requests_current_hour == None or
+        (requests_current_hour | int < maximum_requests_per_hour | int) or
+        request_limits_last_reset + timedelta(hours=1) < now()
+      }}
+    continue_on_timeout: true
   # Add a bit of jitter so the API isn't hit at once
   - delay:
       milliseconds: >
diff --git a/_docs/entities/diagnostics.md b/_docs/entities/diagnostics.md
@@ -76,6 +76,9 @@ This sensor states when intelligent dispatches data was last retrieved.
 | `attempts` | `integer` | The number of attempts that have been made to retrieve the data |
 | `next_refresh` | `datetime` | The timestamp of when the data will next be attempted to be retrieved |
 | `last_error` | `string` | The error that was raised to cause the last retrieval attempt to fail |
+| `requests_current_hour` | `integer` | The number of requests that have been made during the current hour. The start of the hour starts when the first request is made. |
+| `maximum_requests_per_hour` | `integer` | The maximum number of requests that can be made during an hour. The start of the hour starts when the first request is made. |
+| `request_limits_last_reset` | `datetime` | The datetime when the request limits were last reset. This will reset when a request is made and is within the designated limits. |
 
 ## Intelligent Settings Data Last Retrieved
 
diff --git a/custom_components/octopus_energy/coordinators/intelligent_dispatches.py b/custom_components/octopus_energy/coordinators/intelligent_dispatches.py
@@ -33,7 +33,7 @@
 
 _LOGGER = logging.getLogger(__name__)
 
-MAXIMUM_RATES_PER_HOUR = 20
+MAXIMUM_DISPATCH_REQUESTS_PER_HOUR = 20
 
 class IntelligentDispatchDataUpdateCoordinator(DataUpdateCoordinator):
   
@@ -145,43 +145,46 @@ async def async_retrieve_intelligent_dispatches(
   is_manual_refresh: bool,
   planned_dispatches_supported: bool,
 ):
-  requests_current_hour = existing_intelligent_dispatches_result.requests_current_hour if existing_intelligent_dispatches_result is not None else 0
-  requests_last_reset = existing_intelligent_dispatches_result.requests_current_hour_last_reset if existing_intelligent_dispatches_result is not None else current
-
-  if current - requests_last_reset >= timedelta(hours=1):
-    requests_current_hour = 0
-    requests_last_reset = current
-
-  if requests_current_hour >= MAXIMUM_RATES_PER_HOUR:
-    _LOGGER.debug('Maximum requests reached for current hour')
-    return IntelligentDispatchesCoordinatorResult(
-      existing_intelligent_dispatches_result.last_evaluated,
-      existing_intelligent_dispatches_result.request_attempts,
-      existing_intelligent_dispatches_result.dispatches,
-      existing_intelligent_dispatches_result.requests_current_hour,
-      existing_intelligent_dispatches_result.requests_current_hour_last_reset,
-      last_error=f"Maximum requests of {MAXIMUM_RATES_PER_HOUR}/hour reached. Will reset after {requests_last_reset + timedelta(hours=1)}"
-    )
-  
-  # We don't want manual refreshing to occur too many times
-  if (is_manual_refresh and
-      existing_intelligent_dispatches_result is not None and
-      (existing_intelligent_dispatches_result.last_retrieved + timedelta(minutes=1)) > current):
-    _LOGGER.debug('Maximum requests reached for current hour')
-    return IntelligentDispatchesCoordinatorResult(
-      existing_intelligent_dispatches_result.last_evaluated,
-      existing_intelligent_dispatches_result.request_attempts,
-      existing_intelligent_dispatches_result.dispatches,
-      existing_intelligent_dispatches_result.requests_current_hour,
-      existing_intelligent_dispatches_result.requests_current_hour_last_reset,
-      last_error=f"Manual refreshing of dispatches cannot be be called again until {existing_intelligent_dispatches_result.last_retrieved + timedelta(minutes=1)}"
-    )
-
   if (account_info is not None):
     account_id = account_info["id"]
     if (existing_intelligent_dispatches_result is None or 
         current >= existing_intelligent_dispatches_result.next_refresh or
         is_manual_refresh):
+
+      requests_current_hour = existing_intelligent_dispatches_result.requests_current_hour if existing_intelligent_dispatches_result is not None else 0
+      requests_last_reset = existing_intelligent_dispatches_result.requests_current_hour_last_reset if existing_intelligent_dispatches_result is not None else current
+
+      if current - requests_last_reset >= timedelta(hours=1):
+        requests_current_hour = 0
+        requests_last_reset = current
+      
+      if requests_current_hour >= MAXIMUM_DISPATCH_REQUESTS_PER_HOUR:
+        error = f"Maximum requests of {MAXIMUM_DISPATCH_REQUESTS_PER_HOUR}/hour reached. Will reset after {requests_last_reset + timedelta(hours=1)}"
+        _LOGGER.debug(error)
+        return IntelligentDispatchesCoordinatorResult(
+          existing_intelligent_dispatches_result.last_evaluated,
+          existing_intelligent_dispatches_result.request_attempts,
+          existing_intelligent_dispatches_result.dispatches,
+          existing_intelligent_dispatches_result.requests_current_hour,
+          existing_intelligent_dispatches_result.requests_current_hour_last_reset,
+          last_error=error
+        )
+      
+      # We don't want manual refreshing to occur too many times
+      if (is_manual_refresh and
+          existing_intelligent_dispatches_result is not None and
+          (existing_intelligent_dispatches_result.last_retrieved + timedelta(minutes=1)) > current):
+        error = f"Manual refreshing of dispatches cannot be be called again until {existing_intelligent_dispatches_result.last_retrieved + timedelta(minutes=1)}"
+        _LOGGER.debug(error)
+        return IntelligentDispatchesCoordinatorResult(
+          existing_intelligent_dispatches_result.last_evaluated,
+          existing_intelligent_dispatches_result.request_attempts,
+          existing_intelligent_dispatches_result.dispatches,
+          existing_intelligent_dispatches_result.requests_current_hour,
+          existing_intelligent_dispatches_result.requests_current_hour_last_reset,
+          last_error=error
+        )
+
       dispatches = None
       raised_exception = None
       if has_intelligent_tariff(current, account_info) and intelligent_device is not None:
diff --git a/custom_components/octopus_energy/diagnostics_entities/intelligent_dispatches_data_last_retrieved.py b/custom_components/octopus_energy/diagnostics_entities/intelligent_dispatches_data_last_retrieved.py
@@ -5,7 +5,7 @@
 )
 
 from ..utils.error import exception_to_string
-from ..coordinators.intelligent_dispatches import IntelligentDispatchesCoordinatorResult
+from ..coordinators.intelligent_dispatches import MAXIMUM_DISPATCH_REQUESTS_PER_HOUR, IntelligentDispatchesCoordinatorResult
 from .base import OctopusEnergyBaseDataLastRetrieved
 
 class OctopusEnergyIntelligentDispatchesDataLastRetrieved(OctopusEnergyBaseDataLastRetrieved):
@@ -37,6 +37,7 @@ def _handle_coordinator_update(self) -> None:
       "next_refresh": result.next_refresh if result is not None else None,
       "last_error": exception_to_string(result.last_error) if result is not None else None,
       "requests_current_hour": result.requests_current_hour if result is not None else None,
+      "maximum_requests_per_hour": MAXIMUM_DISPATCH_REQUESTS_PER_HOUR,
       "request_limits_last_reset": result.requests_current_hour_last_reset if result is not None else None
     }
 

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`	`)`
`6`	`6`
`7`	`7`	`from ..utils.error import exception_to_string`
`8`		`-from ..coordinators.intelligent_dispatches import IntelligentDispatchesCoordinatorResult`
	`8`	`+from ..coordinators.intelligent_dispatches import MAXIMUM_DISPATCH_REQUESTS_PER_HOUR, IntelligentDispatchesCoordinatorResult`
`9`	`9`	`from .base import OctopusEnergyBaseDataLastRetrieved`
`10`	`10`
`11`	`11`	`class OctopusEnergyIntelligentDispatchesDataLastRetrieved(OctopusEnergyBaseDataLastRetrieved):`
`@@ -37,6 +37,7 @@ def _handle_coordinator_update(self) -> None:`
`37`	`37`	`"next_refresh": result.next_refresh if result is not None else None,`
`38`	`38`	`"last_error": exception_to_string(result.last_error) if result is not None else None,`
`39`	`39`	`"requests_current_hour": result.requests_current_hour if result is not None else None,`
	`40`	`+ "maximum_requests_per_hour": MAXIMUM_DISPATCH_REQUESTS_PER_HOUR,`
`40`	`41`	`"request_limits_last_reset": result.requests_current_hour_last_reset if result is not None else None`
`41`	`42`	`}`
`42`	`43`