RetryUnit_deps

Author: kellerza

pyproject.toml

@@ -27,6 +27,7 @@ classifiers = [
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
   "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3.15",
 ]
 dependencies = [
   "cattrs>=25,<27",

src/ha_addon_sunsynk_multi/a_inverter.py

@@ -153,11 +153,7 @@ async def lifecycle_attempt_recovery(self) -> None:
 
     async def read_identity(self) -> Identity:
         """Read device type, protocol, and serial via the Identity Component."""
-        # Read through Sunsynk, not self.inv.unit: same read_holding_registers
-        # signature, but with READ_ATTEMPTS retries and the serial flush.
-        # ponytail: only holds while Identity reads holding registers only. A field
-        # in another space would need the unit's read_coils/read_input_registers.
-        identity = Identity(self.inv)  # type: ignore[arg-type]
+        identity = Identity(self.inv.retrying_unit)  # type: ignore[arg-type]
         await identity.async_update()
         self.identity = identity
         return identity

src/sunsynk/sunsynk.py

@@ -49,6 +49,23 @@ async def write_registers(self, /, address: int, values: list[int]) -> None:
         ...
 
 
+@dataclass(frozen=True, slots=True)
+class _RetryingUnit:
+    """``HoldingUnit`` facade: FC03/FC16 through ``Sunsynk`` retry policy."""
+
+    ss: Sunsynk
+
+    @property
+    def connected(self) -> bool:
+        return self.ss.unit.connected
+
+    async def read_holding_registers(self, address: int, count: int) -> list[int]:
+        return list(await self.ss.read_holding_registers(address, count))
+
+    async def write_registers(self, address: int, values: list[int]) -> None:
+        await self.ss.unit.write_registers(address, values)
+
+
 @dataclass(kw_only=True)
 class Sunsynk:
     """Sunsync inverter reached through a holding-register unit."""
@@ -66,6 +83,11 @@ class Sunsynk:
     allow_gap: int = 2
     timeouts: int = 0
 
+    @property
+    def retrying_unit(self) -> HoldingUnit:
+        """Unit handle for ``modbus_connection`` Components (retries + serial flush)."""
+        return _RetryingUnit(self)
+
     @classmethod
     def from_url(
         cls,

src/tests/sunsynk/test_sunsynk.py

@@ -3,7 +3,7 @@
 import asyncio
 import logging
 from collections.abc import Sequence
-from unittest.mock import MagicMock, call, patch
+from unittest.mock import AsyncMock, MagicMock, call, patch
 
 import pytest
 from modbus_connection import ModbusProtocolError
@@ -24,6 +24,20 @@ def _ss(**kwargs: object) -> Sunsynk:
     return Sunsynk(unit=MagicMock(), **kwargs)  # type: ignore[arg-type]
 
 
+async def test_retrying_unit_routes_fc03_through_sunsynk() -> None:
+    """retrying_unit uses Sunsynk.read_holding_registers, not the raw unit."""
+    unit = MagicMock()
+    unit.connected = True
+    ss = Sunsynk(unit=unit)
+    ss.read_holding_registers = AsyncMock(return_value=[0, 1, 2])  # type: ignore[method-assign]
+
+    got = await ss.retrying_unit.read_holding_registers(0, 3)
+
+    assert got == [0, 1, 2]
+    ss.read_holding_registers.assert_awaited_once_with(0, 3)  # type: ignore[attr-defined]
+    unit.read_holding_registers.assert_not_called()
+
+
 @patch("sunsynk.Sunsynk.read_holding_registers")
 @patch("sunsynk.Sunsynk.write_register")
 async def test_ss_write_sensor(