refactor(wallbox): read the saved control state once when nothing is stored

An empty answer from Storage is taken as nothing saved, as myenergi,
GivEnergy EVC and Sunsynk do. A read that raises is still retried.

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

Author: CI

apps/predbat/tests/test_wallbox.py

@@ -1649,43 +1649,23 @@ async def flaky_save(module, filename, data, **kwargs):
     print("  ✓ A failed control state save is retried")
 
 
-def test_control_state_load_returning_nothing_is_retried_then_given_up():
-    """Storage returns None for a failed read as well as a missing file, so a None is retried a few times."""
-    storage = _storage_with_paused("101")
-    real_load = storage.load
-    answers = [None]
+def test_control_state_with_nothing_saved_is_read_once():
+    """An empty answer from Storage means nothing is saved: it is read once, as the other components do."""
+    storage = _Storage()
     calls = []
 
-    async def flaky_load(module, filename):
-        """Return None once, as a failed read does, then the real data."""
-        calls.append(filename)
-        if answers:
-            return answers.pop()
-        return await real_load(module, filename)
-
-    storage.load = flaky_load
-    component = _make_component({101: _status(status_id=178, power=0)}, wallbox_control=False)
-    component.base.components = _Components(storage)
-    run_async(component.run(0, True))
-    assert component.transport.count("resume") == 0
-    run_async(component.run(120, False))
-    assert component.transport.count("resume") == 1, "The saved charger was released once the read worked"
-
-    empty = _Storage()
-    empty_calls = []
-
     async def counting_load(module, filename):
         """Always empty, counting the reads."""
-        empty_calls.append(filename)
+        calls.append(filename)
         return None
 
-    empty.load = counting_load
+    storage.load = counting_load
     component = _make_component()
-    component.base.components = _Components(empty)
-    for cycle in range(12):
+    component.base.components = _Components(storage)
+    for cycle in range(6):
         run_async(component.run(cycle * 60, cycle == 0))
-    assert 1 < len(empty_calls) <= 5, "A file that is simply absent is not read forever: {}".format(len(empty_calls))
-    print("  ✓ An empty control state read is retried a few times, then left")
+    assert len(calls) == 1, "Read once, not on every cycle: {}".format(len(calls))
+    print("  ✓ With nothing saved, the control state is read once")
 
 
 def test_schedule_restoration_is_retried_after_a_failure():
@@ -1798,7 +1778,7 @@ def test_wallbox(my_predbat=None):
     test_account_wide_errors_still_stop_the_control_loop()
     test_pause_is_persisted_before_it_is_sent()
     test_failed_control_state_save_is_retried()
-    test_control_state_load_returning_nothing_is_retried_then_given_up()
+    test_control_state_with_nothing_saved_is_read_once()
     test_schedule_restoration_is_retried_after_a_failure()
     print("=" * 70)
     return False

apps/predbat/wallbox.py

@@ -74,8 +74,6 @@
 
 WALLBOX_STORAGE_MODULE = "wallbox"
 WALLBOX_CONTROL_STATE = "control_state"
-# How many cycles an empty answer from Storage is retried before the saved state is taken to be absent
-CONTROL_STATE_LOAD_ATTEMPTS = 5
 
 # Status id to (text, car connected). The text is the Home Assistant wallbox integration's
 # wording, so states match what existing users already see. A None status id means the
@@ -493,7 +491,6 @@ def initialize(self, username, password, automatic=True, wallbox_control=False,
         self.lock_warned = set()
         self.ocpp_warned = set()
         self.control_state_loaded = False
-        self.control_state_load_attempts = 0
         self.control_state_dirty = False
         # Chargers Predbat has resumed on release but not yet handed back to their own schedule
         self.schedule_pending = set()
@@ -840,23 +837,21 @@ async def load_control_state(self):
         """Restore the control switch and the chargers Predbat still owes a release.
 
         The saved lists are what let a restart with control turned off still release a
-        charger an earlier session left paused. Storage answers None for a failed read as
-        well as for a file that is not there, so a None is tried again on the next few
-        cycles rather than taken as "nothing saved"; after that the file is taken to be
-        absent. What is read is merged into what this session already knows, never
+        charger an earlier session left paused. A read that raises is tried again on the
+        next cycle, as Sunsynk's cache restore does; an empty answer is taken as nothing
+        saved. What is read is merged into what this session already knows, never
         replacing it. Fails soft with no Storage component.
         """
-        if self.control_state_loaded or self.storage is None or self.control_state_load_attempts >= CONTROL_STATE_LOAD_ATTEMPTS:
+        if self.control_state_loaded or self.storage is None:
             return
-        self.control_state_load_attempts += 1
         try:
             saved = await self.storage.load(WALLBOX_STORAGE_MODULE, WALLBOX_CONTROL_STATE)
         except Exception as exc:
             self.log("Warn: wallbox: could not read the saved charge control state: {}".format(exc))
             return
+        self.control_state_loaded = True
         if not isinstance(saved, dict):
             return
-        self.control_state_loaded = True
         if "control_enabled" in saved:
             self.control_enabled = bool(saved["control_enabled"])
         for key, target in (("paused", self.paused_by_predbat), ("schedule", self.schedule_pending)):