fix(solax): use each inverter's last known yield instead of holding the plant

get_plant_pv_yield() held the whole plant whenever any inverter was missing,
which treated three different cases alike. An inverter that failed a read
after being read before now contributes its last known totalYield, a
lifetime counter does not go backwards so the sum cannot dip. An inverter
that reads fine but has no totalYield counts as 0 rather than holding the
plant for ever. The value is held only when an inverter that onlineStatus
says should be answering failed its read and has never given a yield.

The last known yield is seeded from the inverter's own total yield sensor,
so an inverter that no longer answers stays in the sum across a restart.

The plant pv_power and grid_power follow the same narrowing: an offline
inverter counts as 0W rather than holding them.

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

Author: CI

apps/predbat/solax.py

@@ -390,6 +390,9 @@ def initialize(self, client_id, client_secret, region="eu", plant_id=None, autom
         # Plants whose PV energy has been built from their inverters, these never drop back to the plant total
         self.plant_pv_from_devices = set()
 
+        # Last known lifetime yield of each inverter, so that a failed read does not drop it from the plant sum
+        self.inverter_last_yield = {}
+
         # When the plant and device info was last read successfully, seeded from the storage cache on
         # startup so that a restart does not re-read data that is still current, plus when it was last
         # attempted so that a failing read is retried at a sensible rate rather than every cycle
@@ -613,19 +616,49 @@ async def write_setting_from_event(self, entity_id, value):
         await self.publish_controls()
         return True
 
+    def inverter_expected(self, device_sn):
+        """
+        True unless the device info says the inverter is offline, an offline inverter is not expected to answer
+        """
+        return self.device_info.get(device_sn, {}).get("onlineStatus", 1) != 0
+
+    def get_inverter_last_yield(self, plant_id, device_sn):
+        """
+        Last known lifetime yield of an inverter in kWh, or None if it has never given one
+
+        Updated only when a read returns a number. With nothing known yet it is seeded from the inverter's
+        own total yield sensor, which survives a restart, so that an inverter which no longer answers
+        stays in the plant sum rather than stepping it down
+        """
+        device_yield = None
+        if device_sn not in self.realtime_device_failed:
+            device_yield = self.realtime_device_data.get(device_sn, {}).get("totalYield")
+        elif device_sn not in self.inverter_last_yield:
+            device_yield = self.get_state_wrapper(f"sensor.{self.prefix}_solax_{plant_id}_{device_sn}_total_yield", default=None)
+        try:
+            self.inverter_last_yield[device_sn] = float(device_yield)
+        except (ValueError, TypeError):
+            pass
+        return self.inverter_last_yield.get(device_sn)
+
     def get_plant_pv_yield(self, plant_id, plant_yield):
         """
         Lifetime PV energy for a plant in kWh, summed from its inverters rather than taken from the plant total
 
         The plant level totalYield includes the AC output of an AC-coupled battery inverter, so battery
-        discharge reads as generation (GH#5356). Returns None when the value should be held: a sum with an
-        inverter missing dips and then recovers, which reads as a burst of generation on a cumulative counter
+        discharge reads as generation (GH#5356). Each inverter contributes its last known yield, a lifetime
+        counter does not go backwards so a failed read cannot make the sum dip. An inverter with no yield of
+        its own counts as 0. Returns None when the value should be held, which is only when an inverter that
+        should be answering failed its read and has never given a yield
         """
         pv_yield = 0.0
         for device_sn in self.plant_inverters.get(plant_id, []):
-            device_yield = self.realtime_device_data.get(device_sn, {}).get("totalYield")
-            if device_sn in self.realtime_device_failed or device_yield is None:
-                return None
+            device_yield = self.get_inverter_last_yield(plant_id, device_sn)
+            if device_yield is None:
+                read_ok = device_sn in self.realtime_device_data and device_sn not in self.realtime_device_failed
+                if not read_ok and self.inverter_expected(device_sn):
+                    return None
+                device_yield = 0.0
             pv_yield += device_yield
         if pv_yield > 0:
             self.plant_pv_from_devices.add(plant_id)
@@ -2520,9 +2553,9 @@ async def publish_device_realtime_data(self):
             battery = saved["battery"] if saved["battery"] is not None else 0
             load_power = pv - battery - grid
 
-            # Plant PV and grid power, held when an inverter in the plant was not read on this cycle as a
-            # sum with one inverter missing would under-read
-            if not any(inverter_sn in self.realtime_device_failed or inverter_sn not in self.realtime_device_data for inverter_sn in self.plant_inverters.get(plant_id, [])):
+            # Plant PV and grid power, held when an inverter that should be answering was not read on this
+            # cycle as a sum with it missing would under-read. An offline inverter counts as 0W
+            if not any((inverter_sn in self.realtime_device_failed or inverter_sn not in self.realtime_device_data) and self.inverter_expected(inverter_sn) for inverter_sn in self.plant_inverters.get(plant_id, [])):
                 plant_name = next((plant.get("plantName", plant_id) for plant in self.plant_info if plant.get("plantId", "unknown").lower().replace(" ", "_") == plant_id), plant_id)
                 self.dashboard_item(
                     f"sensor.{self.prefix}_solax_{plant_id}_pv_power",

apps/predbat/tests/test_solax.py

@@ -41,6 +41,7 @@ def __init__(self, prefix="predbat"):
         self.realtime_plant_failed = set()  # Plants whose last realtime read failed
         self.realtime_device_failed = set()  # Devices whose last realtime read failed
         self.plant_pv_from_devices = set()  # Plants whose PV energy has been built from their inverters
+        self.inverter_last_yield = {}  # Last known lifetime yield of each inverter
         self._storage = None  # No storage cache by default in tests
         self.log_messages = []
         self.dashboard_items = {}
@@ -1462,46 +1463,52 @@ def state_of(api, entity_id):
     else:
         print("✓ PV yield and load built from the inverters, plant total yield unchanged")
 
-    # Test 2: A failed inverter read holds the PV yield and load, a sum with one inverter missing would dip
-    print("Test 2: Failed inverter read holds PV yield and load")
-    api.realtime_device_data[pv_sn]["totalYield"] = 10270.0
-    api.realtime_device_failed.add(hybrid_sn)
+    # Test 2: A failed inverter read uses that inverter's last known yield, a lifetime counter does not go
+    # backwards so the sum cannot dip, and the load keeps following the plant counters
+    print("Test 2: Failed inverter read uses its last known yield")
+    api.realtime_data[test_plant_id]["totalImported"] = 8001.0
+    api.realtime_device_failed.add(pv_sn)
     await api.publish_plant_info()
 
     if state_of(api, pv_entity) != 10269.0:
-        print(f"**** ERROR: PV yield should be held at 10269.0 while an inverter read failed, got {state_of(api, pv_entity)} ****")
+        print(f"**** ERROR: PV yield should stay at the last known 10269.0 while an inverter read failed, got {state_of(api, pv_entity)} ****")
         failed = True
-    elif abs(state_of(api, load_entity) - expected_load) > 0.01:
-        print(f"**** ERROR: Total load should be held at {expected_load} while an inverter read failed, got {state_of(api, load_entity)} ****")
+    elif abs(state_of(api, load_entity) - (expected_load + 1.0)) > 0.01:
+        print(f"**** ERROR: Total load should still be published while an inverter read failed, expected {expected_load + 1.0}, got {state_of(api, load_entity)} ****")
         failed = True
     else:
-        print("✓ PV yield and load held on a failed inverter read")
+        print("✓ Last known yield used on a failed inverter read, load still published")
 
-    # Test 3: The next good read publishes again
-    print("Test 3: A good read publishes again")
-    api.realtime_device_failed.discard(hybrid_sn)
+    # Test 3: The next good read moves on from the last known value
+    print("Test 3: A good read publishes the new yield")
+    api.realtime_device_data[pv_sn]["totalYield"] = 10270.0
+    api.realtime_device_failed.discard(pv_sn)
     await api.publish_plant_info()
 
     if state_of(api, pv_entity) != 10270.0:
-        print(f"**** ERROR: PV yield should be 10270.0 once every inverter is read, got {state_of(api, pv_entity)} ****")
+        print(f"**** ERROR: PV yield should be 10270.0 once the inverter is read again, got {state_of(api, pv_entity)} ****")
         failed = True
     else:
-        print("✓ PV yield published once every inverter is read")
+        print("✓ PV yield follows the inverter once it is read again")
 
-    # Test 4: An inverter that has not been read yet, or has no yield in its data, also holds
-    print("Test 4: An unread inverter holds")
-    api = build_api()
-    del api.realtime_device_data[pv_sn]
-    await api.publish_plant_info()
+    # Test 4: An inverter that should be answering but has never given a yield holds, this is the startup case
+    print("Test 4: An unread inverter with no known yield holds")
+    for online_status in [None, 1]:
+        api = build_api()
+        del api.realtime_device_data[pv_sn]
+        api.realtime_device_failed.add(pv_sn)
+        if online_status is not None:
+            api.device_info[pv_sn]["onlineStatus"] = online_status
+        await api.publish_plant_info()
 
-    if pv_entity in api.dashboard_items or load_entity in api.dashboard_items:
-        print("**** ERROR: PV yield and load should not be published before every inverter is read ****")
-        failed = True
-    elif yield_entity not in api.dashboard_items:
-        print("**** ERROR: The plant totals do not depend on the inverters and should still be published ****")
-        failed = True
-    else:
-        print("✓ PV yield and load not published before every inverter is read")
+        if pv_entity in api.dashboard_items or load_entity in api.dashboard_items:
+            print(f"**** ERROR: PV yield and load should not be published before an online inverter is read (onlineStatus {online_status}) ****")
+            failed = True
+        elif yield_entity not in api.dashboard_items:
+            print("**** ERROR: The plant totals do not depend on the inverters and should still be published ****")
+            failed = True
+        else:
+            print(f"✓ PV yield and load not published before an online inverter is read (onlineStatus {online_status})")
 
     # Test 5: No inverter reports a yield of its own, so the plant figure is used as before
     print("Test 5: Falls back to the plant yield when no inverter reports one")
@@ -1528,6 +1535,72 @@ def state_of(api, entity_id):
     else:
         print("✓ PV yield held rather than switching to the plant figure")
 
+    # Test 7: An inverter that reads fine but has no totalYield counts as 0, alone in a plant that leaves the
+    # plant figure as the only PV figure there is
+    print("Test 7: An inverter with no totalYield of its own counts as 0")
+    api = build_api()
+    api.plant_inverters[test_plant_id] = [hybrid_sn]
+    del api.realtime_device_data[hybrid_sn]["totalYield"]
+    await api.publish_plant_info()
+    alone_yield = state_of(api, pv_entity)
+
+    api = build_api()
+    del api.realtime_device_data[hybrid_sn]["totalYield"]
+    await api.publish_plant_info()
+
+    if alone_yield != 19569.5:
+        print(f"**** ERROR: PV yield should fall back to the plant figure 19569.5 when the only inverter has no totalYield, got {alone_yield} ****")
+        failed = True
+    elif state_of(api, pv_entity) != 10269.0:
+        print(f"**** ERROR: PV yield should be 10269.0 from the other inverter when one has no totalYield, got {state_of(api, pv_entity)} ****")
+        failed = True
+    else:
+        print("✓ An inverter with no totalYield counts as 0 rather than holding the plant")
+
+    # Test 8: An offline inverter that has never reported contributes 0 rather than holding the plant
+    print("Test 8: An offline inverter that never reported contributes 0")
+    api = build_api()
+    del api.realtime_device_data[hybrid_sn]
+    api.realtime_device_failed.add(hybrid_sn)
+    api.device_info[hybrid_sn]["onlineStatus"] = 0
+    await api.publish_plant_info()
+
+    if state_of(api, pv_entity) != 10269.0:
+        print(f"**** ERROR: PV yield should be 10269.0 with an offline inverter counted as 0, got {state_of(api, pv_entity)} ****")
+        failed = True
+    else:
+        print("✓ Offline inverter with no known yield counted as 0")
+
+    # Test 9: After a restart the last known yield is seeded from the inverter's own sensor, so a dead
+    # inverter stays in the sum rather than stepping the total down
+    print("Test 9: Last known yield is seeded from the inverter sensor after a restart")
+    api = build_api()
+    api.realtime_device_data[hybrid_sn] = {}
+    api.realtime_device_failed.add(hybrid_sn)
+    api.device_info[hybrid_sn]["onlineStatus"] = 0
+    api.dashboard_items[f"sensor.predbat_solax_{test_plant_id}_{hybrid_sn}_total_yield"] = {"state": 459.1, "attributes": {}}
+    await api.publish_plant_info()
+
+    if state_of(api, pv_entity) is None or abs(state_of(api, pv_entity) - 10728.1) > 0.01:
+        print(f"**** ERROR: PV yield should be 10728.1 with the dead inverter seeded from its sensor, got {state_of(api, pv_entity)} ****")
+        failed = True
+    else:
+        print("✓ Dead inverter's yield seeded from its sensor")
+
+    # Test 10: A sensor state that is not a number is not used as a seed
+    print("Test 10: A non-numeric sensor state is not a seed")
+    api = build_api()
+    del api.realtime_device_data[pv_sn]
+    api.realtime_device_failed.add(pv_sn)
+    api.dashboard_items[f"sensor.predbat_solax_{test_plant_id}_{pv_sn}_total_yield"] = {"state": "unknown", "attributes": {}}
+    await api.publish_plant_info()
+
+    if pv_entity in api.dashboard_items:
+        print(f"**** ERROR: PV yield should be held when the only seed is not a number, got {state_of(api, pv_entity)} ****")
+        failed = True
+    else:
+        print("✓ Non-numeric sensor state ignored")
+
     return failed
 
 
@@ -6230,6 +6303,16 @@ async def test_publish_device_realtime_data_main():
         print("✓ Plant pv_power and grid_power held when an inverter failed its read")
 
     # Republished on the next good read
+    # An offline inverter is not expected to answer, so it counts as 0W rather than holding the plant
+    api10.device_info["INV_B"]["onlineStatus"] = 0
+    await api10.publish_device_realtime_data()
+    if api10.dashboard_items[plant_pv_sensor10]["state"] != 900 or api10.dashboard_items[plant_grid_sensor10]["state"] != -200:
+        print(f"**** ERROR: Plant pv_power/grid_power should be 900/-200 with the offline inverter counted as 0, got {api10.dashboard_items[plant_pv_sensor10]['state']}/{api10.dashboard_items[plant_grid_sensor10]['state']} ****")
+        failed = True
+    else:
+        print("✓ Offline inverter counted as 0W in the plant pv_power and grid_power")
+    api10.device_info["INV_B"]["onlineStatus"] = 1
+
     api10.realtime_device_failed.discard("INV_B")
     await api10.publish_device_realtime_data()
     if api10.dashboard_items[plant_pv_sensor10]["state"] != 1400: