fix(dynamic-load): only cancel Octopus Intelligent slots, never Predbat-led ones

Predbat-led charging is a different mechanism: Predbat itself decides when the
car charges, and its car_charging_slot sensor drives the charger. A second check
here, for cars Predbat plans itself, ran before publish_car_plan(), so a
cancelled slot switched that sensor off. The charger automation then stopped the
charge the check was waiting to see, and every later slot in the run stayed
cancelled.

Detection now applies only to slots load_octopus_slots() built ("octopus": True).
The second check is gone, and a single call before the rates decides every car,
including one whose slots have gone this cycle, so a stale cancellation cannot
outlive them.

This changes behaviour from main: the old dynamic_load() also zeroed
Predbat-planned slots on low load. It no longer does.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: CI

apps/predbat/fetch.py

@@ -1184,8 +1184,8 @@ def fetch_sensor_data(self, save=True):
         # Fetch sensor data for cars, e.g. car plan, car energy, car sessions etc.
         self.dispatch_timeline_pending = []
         self.fetch_sensor_data_cars(save=save)
-        # Dynamic load: cancel the slots of a car that is in one but not charging - before the rates are
-        # built, so a cancelled Intelligent dispatch never gets its cheap rate
+        # Dynamic load: cancel the Octopus Intelligent slots of a car that is in one but not charging -
+        # before the rates are built, so a cancelled dispatch never gets its cheap rate
         dynamic_load_car_changed = self.dynamic_load_car_check(save=save)
 
         if "rates_export_octopus_url" in self.args:
@@ -1314,8 +1314,6 @@ def fetch_sensor_data(self, save=True):
 
         # Work out car plan?
         self.fetch_sensor_data_car_planning()
-        # Dynamic load for the cars Predbat plans itself, whose slots only exist now
-        dynamic_load_car_changed |= self.dynamic_load_car_check(save=save, late=True)
         # Publish the car plan
         self.publish_car_plan()
 

apps/predbat/plan.py

@@ -365,27 +365,36 @@ def dynamic_load_car_in_slot(self, car_n, minute):
                 return True
         return False
 
+    def dynamic_load_car_is_octopus(self, car_n):
+        """
+        Whether car_n's slots were built by Octopus Intelligent charging (load_octopus_slots() marks them).
+
+        Only those are ever cancelled. Predbat-led charging is a different mechanism: Predbat itself
+        decides when the car charges and its car_charging_slot sensor drives the charger, so cancelling
+        a slot would stop the very charge the check is waiting to see.
+        """
+        slots = self.car_charging_slots[car_n] if car_n < len(self.car_charging_slots) else []
+        return any(slot.get("octopus", False) for slot in slots)
+
     def dynamic_load_car_trusted_by_default(self, car_n):
         """
         Whether car_n's slots are trusted while there is no evidence about them - outside a slot, or
         before the car has been seen either way inside one.
 
-        Everything is trusted unless octopus_intelligent_trust_slots is Off, which reverses that for a car
-        carrying Octopus Intelligent dispatch slots: they are assumed not to happen until the car is seen
-        charging in one. Slots Predbat plans itself are always trusted by default.
+        Trusted unless octopus_intelligent_trust_slots is Off, which reverses that for an Octopus
+        Intelligent car: its slots are assumed not to happen until the car is seen charging in one.
         """
-        if self.octopus_intelligent_trust_slots:
-            return True
-        slots = self.car_charging_slots[car_n] if car_n < len(self.car_charging_slots) else []
-        return not any(slot.get("octopus", False) for slot in slots)
+        return self.octopus_intelligent_trust_slots or not self.dynamic_load_car_is_octopus(car_n)
 
     def dynamic_load_car_active(self, car_n):
         """
-        Whether car-charging detection applies to car_n: dynamic load is on, or the car's Octopus
-        Intelligent slots are untrusted by default - which means nothing without the detection that
+        Whether car-charging detection applies to car_n: only an Octopus Intelligent car, and only with
+        dynamic load on or its slots untrusted by default - which means nothing without the detection that
         trusts them again, so it works whether dynamic load is on or not.
         """
-        return self.metric_dynamic_load_adjust or not self.dynamic_load_car_trusted_by_default(car_n)
+        if not self.dynamic_load_car_is_octopus(car_n):
+            return False
+        return self.metric_dynamic_load_adjust or not self.octopus_intelligent_trust_slots
 
     def dynamic_load_car_target(self, car_n, minute, now, record=True):
         """
@@ -455,16 +464,16 @@ def dynamic_load_car_check_config(self):
             self.dynamic_load_car_warned = cars
         return cars
 
-    def dynamic_load_car_check(self, save=True, late=False):
+    def dynamic_load_car_check(self, save=True):
         """
-        Cancel the slots of a car that is inside one of its charging slots but not charging - or, with
-        octopus_intelligent_trust_slots Off, of an Octopus Intelligent car until it is seen charging.
+        Cancel the slots of an Octopus Intelligent car that is inside one of its charging slots but not
+        charging - or, with octopus_intelligent_trust_slots Off, until it is seen charging in one. Slots
+        Predbat plans itself are never cancelled (see dynamic_load_car_is_octopus()).
 
-        Runs in fetch_sensor_data() before the rates are built, so that a cancelled Octopus Intelligent
-        dispatch never gets its cheap rate (rate_add_io_slots() and dynamic_load_car_strip_feed_rates()
-        consult dynamic_load_car_cancelled). Cars that Predbat plans itself only get their slots after the
-        rates, from the low-rate scan, so a second call with late=True decides those once they exist -
-        they have no dispatch discount to withhold.
+        Runs in fetch_sensor_data() after the Octopus slots are built and before the rates, so that a
+        cancelled dispatch never gets its cheap rate (rate_add_io_slots() and
+        dynamic_load_car_strip_feed_rates() consult dynamic_load_car_cancelled). Every car is decided,
+        including one whose slots have gone, so a stale cancellation cannot outlive them.
 
         A cancelled car has every slot ending after now set to 0 kWh, which releases "Hold for car" and the
         predicted car load; the kWh it had is kept in the slot's kwh_cancelled so the plan can still show
@@ -477,16 +486,7 @@ def dynamic_load_car_check(self, save=True, late=False):
         Returns True when a car's cancellation changed, so the plan is recomputed.
         """
         changed = False
-        if not late:
-            self.dynamic_load_car_decided = set()
-
         for car_n in range(self.num_cars):
-            if car_n in self.dynamic_load_car_decided:
-                continue
-            if not late and not (car_n < len(self.car_charging_slots) and self.car_charging_slots[car_n]):
-                continue
-            self.dynamic_load_car_decided.add(car_n)
-
             cancelled = self.dynamic_load_car_target(car_n, self.minutes_now, self.now_utc_real, record=save)
             if save:
                 was_cancelled = self.dynamic_load_car_cancelled.get(car_n, False)

apps/predbat/predbat.py

@@ -547,7 +547,6 @@ def reset(self):
         self.load_last_status = "baseline"
         self.dynamic_load_car_since = {}
         self.dynamic_load_car_cancelled = {}
-        self.dynamic_load_car_decided = set()
         self.dynamic_load_car_warned = []
         self.dynamic_load_car_warned_iog_off = False
         self.dynamic_load_car_sensors = {}

apps/predbat/tests/test_dynamic_load_car.py

@@ -17,7 +17,8 @@
 re-derived every cycle and ends as soon as the car leaves its slots or starts charging again.
 
 Evidence is car_charging_now when it is a real entity (2 minute grace), otherwise the low-load test
-when the car is inside the CT clamp (10 minute grace), otherwise nothing.
+when the car is inside the CT clamp (10 minute grace), otherwise nothing. Only slots Octopus
+Intelligent charging built are affected - Predbat-led charging is never cancelled.
 """
 import copy
 from datetime import timedelta
@@ -43,7 +44,6 @@
     "update_pending",
     "dynamic_load_car_since",
     "dynamic_load_car_cancelled",
-    "dynamic_load_car_decided",
     "dynamic_load_car_sensors",
     "dynamic_load_car_warned",
     "dynamic_load_car_warned_iog_off",
@@ -103,7 +103,6 @@ def _reset(my_predbat):
     my_predbat.load_last_period = 3.0
     my_predbat.dynamic_load_car_since = {}
     my_predbat.dynamic_load_car_cancelled = {}
-    my_predbat.dynamic_load_car_decided = set()
     my_predbat.update_pending = False
     my_predbat.octopus_intelligent_trust_slots = True
 
@@ -218,7 +217,7 @@ def _run(my_predbat):
         _sensor(my_predbat, None)
         my_predbat.car_energy_reported_load = True
         my_predbat.load_last_period = 0.5
-        early_slots = [{"start": 0, "end": 30, "kwh": 3.5}]
+        early_slots = [{"start": 0, "end": 30, "kwh": 3.5, "octopus": True}]
         _cycle(my_predbat, 0, slots=early_slots)
         _cycle(my_predbat, 5, slots=early_slots)
         failed |= _check("t6b no clock before 00:05", my_predbat.dynamic_load_car_since.get(0) is None, "since {}".format(my_predbat.dynamic_load_car_since.get(0)))
@@ -269,22 +268,31 @@ def _run(my_predbat):
         failed |= _check("t10 not applied outside the slot", _kwh(my_predbat) == [3.5, 3.5], "kwh {}".format(_kwh(my_predbat)))
         failed |= _check("t10 saved state untouched", my_predbat.dynamic_load_car_cancelled.get(0, False), "cancelled {}".format(my_predbat.dynamic_load_car_cancelled))
 
-        # Cars planned by Predbat itself get their slots after the rates are built: the late call
-        # decides the cars the early call could not
-        print("Test 11: the late call decides cars that had no slots at the early call")
+        # Predbat-led charging is a different mechanism: Predbat itself decides when the car charges, and
+        # its slot sensor drives the charger - cancelling it would stop the very charge it is waiting to
+        # see. Only slots Octopus Intelligent charging built are ever cancelled.
+        print("Test 11: a car Predbat plans itself is never cancelled, by the sensor or the load")
         _reset(my_predbat)
         _sensor(my_predbat, "off")
-        _at(my_predbat, 840)
-        my_predbat.car_charging_slots = [[]]
-        my_predbat.dynamic_load_car_check()
-        my_predbat.car_charging_slots = [_slots()]
-        my_predbat.dynamic_load_car_check(late=True)
-        _at(my_predbat, 845)
-        my_predbat.car_charging_slots = [[]]
-        my_predbat.dynamic_load_car_check()
-        my_predbat.car_charging_slots = [_slots()]
-        changed = my_predbat.dynamic_load_car_check(late=True)
-        failed |= _check("t11 late cancel", changed and _kwh(my_predbat) == [0, 0], "changed {} kwh {}".format(changed, _kwh(my_predbat)))
+        own = [{"start": 840, "end": 870, "kwh": 3.5}, {"start": 900, "end": 930, "kwh": 3.5}]
+        _cycle(my_predbat, 840, slots=own)
+        changed = _cycle(my_predbat, 850, slots=own)
+        failed |= _check("t11 sensor", (not changed) and _kwh(my_predbat) == [3.5, 3.5] and not my_predbat.dynamic_load_car_cancelled.get(0, False), "changed {} kwh {}".format(changed, _kwh(my_predbat)))
+        _sensor(my_predbat, None)
+        my_predbat.car_energy_reported_load = True
+        my_predbat.load_last_period = 0.5
+        _cycle(my_predbat, 840, slots=own)
+        _cycle(my_predbat, 855, slots=own)
+        failed |= _check("t11 load", _kwh(my_predbat) == [3.5, 3.5], "kwh {}".format(_kwh(my_predbat)))
+
+        # Every car is decided in the one call, including one whose slots have gone this cycle
+        print("Test 11a: a cancelled car with no slots this cycle is cleared")
+        _reset(my_predbat)
+        _sensor(my_predbat, "off")
+        _cycle(my_predbat, 840)
+        _cycle(my_predbat, 845)
+        changed = _cycle(my_predbat, 850, slots=[])
+        failed |= _check("t11a cleared", changed and not my_predbat.dynamic_load_car_cancelled.get(0, False), "changed {} cancelled {}".format(changed, my_predbat.dynamic_load_car_cancelled))
 
         # car_charging_slots shorter than num_cars must not raise out of the fetch (#5229 review)
         print("Test 11b: fewer car slot lists than cars")
@@ -295,10 +303,9 @@ def _run(my_predbat):
         my_predbat.dynamic_load_car_cancelled = {1: True}
         my_predbat.car_charging_slots = [_slots()]
         try:
-            my_predbat.dynamic_load_car_check(save=False, late=True)
+            my_predbat.dynamic_load_car_check(save=False)
             my_predbat.dynamic_load_car_cancelled = {1: True}
             my_predbat.dynamic_load_car_check()
-            my_predbat.dynamic_load_car_check(late=True)
         except IndexError as exc:
             failed |= _check("t11b no IndexError", False, str(exc))
 
@@ -462,7 +469,7 @@ def _run_poll(my_predbat):
     print("Test 18: the poll agrees with the check about a slot ending between 5 minute steps")
     _reset(my_predbat)
     _sensor(my_predbat, "off")
-    odd_slots = [{"start": 840, "end": 872, "kwh": 3.5}]
+    odd_slots = [{"start": 840, "end": 872, "kwh": 3.5, "octopus": True}]
     _cycle(my_predbat, 840, slots=odd_slots)
     _cycle(my_predbat, 845, slots=odd_slots)
     my_predbat.update_pending = False
@@ -657,7 +664,7 @@ def _run_kwh_cancelled(my_predbat):
     print("Test 26: a cancelled slot records its kWh in kwh_cancelled")
     _reset(my_predbat)
     _sensor(my_predbat, "off")
-    slots = [{"start": 840, "end": 870, "kwh": 3.5}, {"start": 900, "end": 930, "kwh": 0.0}]
+    slots = [{"start": 840, "end": 870, "kwh": 3.5, "octopus": True}, {"start": 900, "end": 930, "kwh": 0.0, "octopus": True}]
     _cycle(my_predbat, 840, slots=slots)
     _cycle(my_predbat, 845, slots=slots)
     failed |= _check("t26 recorded", _kwh(my_predbat) == [0, 0] and _cancelled(my_predbat) == [3.5, None], "kwh {} cancelled {}".format(_kwh(my_predbat), _cancelled(my_predbat)))

docs/car-charging.md

@@ -627,7 +627,8 @@ e.g. you are using Intelligent Octopus or you use the car slots in Predbat to co
 - **input_number.predbat_car_charging_loss** gives the percentage amount of energy lost when charging the car (load in the home vs energy added to the battery).
 A good setting is 0.08 which is 8%.
 
-- **switch.predbat_metric_dynamic_load_adjust** (default `false`) - When On, Predbat cancels a car's charging slots, including the cheap rate of an Octopus Intelligent dispatch, while the car is inside a slot but not actually charging, and restores them as soon as it starts charging again or the slot ends.
+- **switch.predbat_metric_dynamic_load_adjust** (default `false`) - When On, Predbat cancels a car's Octopus Intelligent charging slots, including the dispatch's cheap rate, while the car is inside a slot but not actually charging, and restores them as soon as it starts charging again or the slot ends.
+Slots Predbat plans itself (Predbat-led charging) are never cancelled.
 This releases the battery hold set by **switch.predbat_car_charging_from_battery**, and stops the house battery being planned around a dispatch Octopus may bill at the full rate.
 It uses **car_charging_now** when that is a real sensor (reacting within about 2 minutes), otherwise the house load if the car is inside the CT clamp (about 10 minutes). If turned Off then Predbat won't export during times the car is planned to charge even if the car is not charging.
 

docs/customisation.md

@@ -189,8 +189,9 @@ This setting will not impact the real calculated costs and is only used for plan
 **switch.predbat_metric_dynamic_load_adjust** (default False) is a toggle that when enabled allows Predbat to take into account your energy consumption within the last 5 minutes.
 If the load is above what your battery can deliver the plan is updated to predict this load will continue during the current slot, thus preventing forced export in the plan.
 If the load remains high for two checks in a row, this prediction is extended into the following slot too, so the plan stays up to date across the slot boundary.
-If the current time is inside one of your car's charging slots but the car is not charging, Predbat cancels that slot and every later one, so the battery is no longer held for the car and the plan can include potential export again.
-For an Octopus Intelligent dispatch the slot's cheap rate is withdrawn too, as Octopus may bill a dispatch the car does not use at the full rate.
+If your car is charged by Octopus Intelligent and the current time is inside one of its charging slots but the car is not charging, Predbat cancels that slot and every later one, so the battery is no longer held for the car and the plan can include potential export again.
+The dispatch's cheap rate is withdrawn too, as Octopus may bill a dispatch the car does not use at the full rate.
+Slots Predbat plans itself (Predbat-led charging) are never cancelled, as Predbat is the one deciding when the car charges.
 Whether the car is charging is taken from **car_charging_now** when it is set to a real Home Assistant entity, after 2 minutes of it reporting not charging.
 Without that sensor, if your car is inside the CT clamp (**switch.predbat_car_energy_reported_load** On), the house load is used instead, after 10 minutes of load too low for a car to be charging.
 The slots come back as soon as the car starts charging again or the current slot ends.