fix(charger-control): judge each car on its own dispatch sensor under an Ohme claim

Since #5443 the Octopus component keeps wiring its whole dispatch-sensor list
into octopus_intelligent_slot while Ohme holds car_slot_owner (the claim now
covers only the ready time and charge limit). The car_slot_owner shortcut in
charger_control_octopus_drives_charger()/_drives_car() predates that and
applied to every car, so with an Ohme on car 0 and a second car whose
Intelligent device is the car itself, a Zappi or GE EVC on car 1 was left to
Octopus: follows_car ignored, and a held charger handed over stopped.

The sensor's own is_charger now decides; the claim only stands in when the
sensor does not say (the Ohme's own slot sensor). drives_car no longer reads
an "unknown" is_charger as "the car". Regression test fails on the merge
without this change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: chalfontchubby

apps/predbat/car_charger_control.py

@@ -190,16 +190,28 @@ def charger_control_octopus_drives_charger(self, car_n):
         if not slot:
             # Not wired for this car - but the Octopus component may simply not have got there yet
             return None if self.charger_control_octopus_discovering() else False
-        owner = getattr(self.base, "car_slot_owner", None)
-        if owner and owner != "octopus":
-            # Another charger component (Ohme) supplies the Intelligent slots from the charger itself
-            return True
+        is_charger = self.charger_control_dispatch_is_charger(slot)
+        if is_charger is None:
+            owner = getattr(self.base, "car_slot_owner", None)
+            if owner and owner != "octopus":
+                # Another charger component (Ohme) wired its own sensor as the Intelligent slots, which
+                # does not say - but it only does so for the charger Octopus drives. Asked only once the
+                # sensor is silent: since #5443 Octopus's own dispatch sensors stay wired under the
+                # claim, and those say per car, so a second car's device may well not be the charger
+                return True
+        return is_charger
+
+    def charger_control_dispatch_is_charger(self, slot):
+        """What a dispatch sensor says about whether its Intelligent device is the charger: True, False or None.
+
+        None for a sensor that does not say - not published yet, one that never does (the Octopus
+        Energy HA integration, an Ohme slot sensor), or one that has lost its value, which is not
+        the same as "not the charger".
+        """
         is_charger = self.get_state_wrapper(slot, attribute="is_charger")
         if is_charger is None:
-            # Not published yet, or a sensor that does not say (the Octopus Energy HA integration)
             return None
         if isinstance(is_charger, str) and is_charger.strip().lower() in ("unknown", "unavailable", "none", ""):
-            # A sensor that has lost its value does not say, which is not the same as "not the charger"
             return None
         return parse_control_setting(is_charger)
 
@@ -214,10 +226,9 @@ def charger_control_octopus_drives_car(self, car_n):
         slot = self.charger_control_dispatch_sensor(car_n)
         if not slot:
             return False
-        owner = getattr(self.base, "car_slot_owner", None)
-        if owner and owner != "octopus":
-            return False
-        return parse_control_setting(self.get_state_wrapper(slot, attribute="is_charger")) is False
+        # Not short-cut on car_slot_owner: since #5443 Octopus's dispatch sensors stay wired while Ohme
+        # holds the claim, so a second car's sensor can say its device is the car itself
+        return self.charger_control_dispatch_is_charger(slot) is False
 
     def charger_control_octopus_discovering(self):
         """Is the Octopus or Kraken component still to wire its Intelligent devices into the car slots?

apps/predbat/tests/test_car_charger_control.py

@@ -771,6 +771,37 @@ def test_octopus_rule_per_car():
     assert component.commands == [("b", "off", 1)], component.commands
 
 
+def test_octopus_rule_other_slot_owner_second_car():
+    """Since #5443 Octopus's own dispatch sensors stay wired while Ohme holds the car slot claim, so
+    a second car is judged on what its own sensor says rather than handed to Octopus with the Ohme."""
+    component = FakeComponent([FakeCharger("a"), FakeCharger("b")])
+    component.base.num_cars = 2
+    component.base.components = FakeComponents(None)
+    component.base.car_slot_owner = "ohme"
+    dispatch_b = "binary_sensor.predbat_octopus_intelligent_dispatch_b"
+    component.args["octopus_intelligent_slot"] = [DISPATCH, dispatch_b]
+    component.sensors = {DISPATCH: {"is_charger": True}, dispatch_b: {"is_charger": False}}
+    assert component.charger_control_octopus_drives_charger(0) is True
+    assert component.charger_control_octopus_drives_charger(1) is False
+    assert component.charger_control_octopus_drives_car(0) is False
+    assert component.charger_control_octopus_drives_car(1) is True
+
+    # The Ohme's own slot sensor does not say, and the claim still means Octopus drives that charger
+    component.sensors = {DISPATCH: {}, dispatch_b: {"is_charger": "unknown"}}
+    assert component.charger_control_octopus_drives_charger(0) is True
+    assert component.charger_control_octopus_drives_car(0) is False
+    # A sensor that has lost its value is not the car either
+    assert component.charger_control_octopus_drives_car(1) is False
+
+    # Following the car, Predbat drives the second car's charger to its dispatches and leaves the Ohme's alone
+    component.sensors = {DISPATCH: {"is_charger": True}, dispatch_b: {"is_charger": False}}
+    component.args["octopus_intelligent_charger_follows_car"] = True
+    _plan(component, 0, [])
+    _plan(component, 1, [])
+    run_async(component.charger_control_tick(_now()))
+    assert component.commands == [("b", "off", 1)], component.commands
+
+
 def test_unpublished_plan_dispatch_charge_stops_when_the_dispatch_ends():
     """A dispatch starts a car whose plan is not published yet; when the dispatch ends the charger
     Predbat now holds is stopped, not left running with nobody in control."""
@@ -931,6 +962,7 @@ def run_car_charger_control_tests(my_predbat=None):
     test_octopus_rule_unmatched_regex_is_not_a_sensor()
     test_octopus_rule_other_slot_owner_hands_off()
     test_octopus_rule_per_car()
+    test_octopus_rule_other_slot_owner_second_car()
     test_unpublished_plan_dispatch_charge_stops_when_the_dispatch_ends()
     test_plan_that_goes_missing_keeps_its_last_windows()
     test_guest_charging_releases_and_resumes()

docs/car-charging.md

@@ -591,7 +591,7 @@ The GivEnergy Gateway's `gateway_evc_control` (above) is unchanged and stays opt
 
 On Octopus Intelligent (or E.ON/EDF SmartFlex through the Kraken component), what Predbat does depends on which device Octopus drives for that car. Predbat reads this from the car's own dispatch sensor in `octopus_intelligent_slot`:
 
-- **Octopus drives the charger** - your charger is the Intelligent device, or the Intelligent slots come from the Ohme. Predbat leaves the charger alone, and hands it back if it was holding it, so the two do not fight. Handing back never starts a charge: a charger Predbat had stopped is left for Octopus to start, an Ohme has max charge turned off, and a Zappi goes back to its own mode (Eco+ in place of Fast).
+- **Octopus drives the charger** - your charger is the Intelligent device, or that car's Intelligent slots come from the Ohme. Predbat leaves the charger alone, and hands it back if it was holding it, so the two do not fight. Handing back never starts a charge: a charger Predbat had stopped is left for Octopus to start, an Ohme has max charge turned off, and a Zappi goes back to its own mode (Eco+ in place of Fast).
 - **Octopus drives the car** - the car itself is the Intelligent device, so the car starts and stops its own charge. By default Predbat leaves the charger alone, and hands back a charger it was holding as usual, so one it had stopped is started again rather than left stopped. Turn on **switch.predbat_octopus_intelligent_charger_follows_car** (*expert mode*) to have Predbat drive the charger instead: on while a dispatch is running, off otherwise, so the car cannot charge outside the dispatches on its own timers. It follows both its plan and the dispatch times on the car's dispatch sensor, so a new dispatch starts the charger within a few minutes of Octopus announcing it rather than waiting for the next plan, and the charger stops when the dispatch ends.
 - **Predbat cannot tell** - for example the dispatch sensor comes from the Octopus Energy integration, which does not say, or Predbat's Octopus component has not discovered your devices yet. Predbat leaves the charger alone unless you have set its control setting to `true`, which tells Predbat your charger is not the Octopus device. A charger Predbat was holding is handed back as usual, so a charger it had stopped is started again rather than left stopped with nobody in charge. When the dispatch sensor does not say, Predbat logs a warning naming the setting to change; while it is only waiting for its Octopus or Kraken component to find your devices, it just notes that it is waiting and leaves the charger as it is. If that component has still not found your devices after 15 minutes, Predbat warns and treats it as not being able to tell.