python-mobius 0.4.2__tar.gz → 0.4.3__tar.gz

{python_mobius-0.4.2 → python_mobius-0.4.3}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.4.3
+
+- Fixed relayed devices (anything reached through a gateway over the
+  Thread mesh, not directly over BLE) occasionally losing a read for
+  no apparent reason, even though the official app kept working fine.
+  A single relay round-trip crosses both BLE and the Thread mesh, and
+  one dropped or delayed packet somewhere in that longer path turned
+  out to be common enough that the app always retries once before
+  giving up -- this library now does the same.
+
 ## 0.4.2
 
 - Fixed `MeshPeer.age` being parsed as a signed number instead of

{python_mobius-0.4.2 → python_mobius-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-mobius
-Version: 0.4.2
+Version: 0.4.3
 Summary: Reverse-engineered Python client for the Mobius BLE protocol (EcoTech Marine VorTech/Radion, AquaIllumination, Neptune Systems, NYOS)
 Project-URL: Homepage, https://code.r3pek.org/r3pek/python-mobius
 Project-URL: Documentation, https://code.r3pek.org/r3pek/python-mobius/src/branch/main/documentation

{python_mobius-0.4.2 → python_mobius-0.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "python-mobius"
-version = "0.4.2"
+version = "0.4.3"
 description = "Reverse-engineered Python client for the Mobius BLE protocol (EcoTech Marine VorTech/Radion, AquaIllumination, Neptune Systems, NYOS)"
 readme = "README.md"
 license = { text = "GPL-2.0-only" }

{python_mobius-0.4.2 → python_mobius-0.4.3}/src/mobius/__init__.py

@@ -65,7 +65,7 @@ from .discovery import (
     discover_tank,
 )
 
-__version__ = "0.4.2"
+__version__ = "0.4.3"
 
 __all__ = [
     "__version__",

{python_mobius-0.4.2 → python_mobius-0.4.3}/src/mobius/relay.py

@@ -177,12 +177,52 @@ class RelayedMobiusDevice(MobiusDevice):
         embedded in its payload (confirmed via reverse engineering:
         coapRequest.getToken() == coapResponse.getToken()) -- never by
         this outer frame's own message ID.
+
+        Retries exactly once on a timeout before actually raising --
+        confirmed via reverse engineering the app's own request-timeout
+        handling: it never treats a single timed-out relay round-trip as
+        a real failure, always transparently retrying (fresh send, same
+        request) once first, only surfacing a failure if the retry ALSO
+        times out. A relayed round-trip crosses BLE (to the gateway) and
+        then the Thread mesh itself (gateway to target and back) -- a
+        single dropped/delayed packet somewhere in that longer path is
+        evidently common enough that the app was built assuming it will
+        happen regularly, not as an edge case. Each attempt gets its own
+        fresh CoAP token (this library generates one per call already,
+        not tied to a single request object the way the app's own retry
+        reuses one) -- deliberately, so a late, delayed response to the
+        first, abandoned attempt can never be mismatched against the
+        retry's own, separate wait.
         """
         if not self.gateway.is_connected:
             raise IOError(
                 f"gateway device is not connected -- cannot relay to {self.peer.serial!r} through it"
             )
 
+        last_timeout_token: Optional[int] = None
+        for attempt in (1, 2):
+            try:
+                return await self._relay_attempt(inner_request_frame, is_retry=(attempt == 2))
+            except asyncio.TimeoutError as err:
+                last_timeout_token = err.args[0] if err.args else None
+                if attempt == 1 and self.debug:
+                    print(f"    [relay debug] timed out waiting {self.timeout}s for "
+                          f"{self.peer.serial!r} -- retrying once before giving up")
+                continue
+
+        raise IOError(
+            f"timed out waiting {self.timeout}s for a relayed response from target "
+            f"{self.peer.serial!r} (no CoAP indication received for token {last_timeout_token}, "
+            f"even after one retry)"
+        )
+
+    async def _relay_attempt(self, inner_request_frame: bytes, is_retry: bool) -> ParsedFrame:
+        """One full send-and-await cycle for _relay() -- split out so
+        _relay() itself can retry it once on a timeout without
+        duplicating this whole body. Raises asyncio.TimeoutError itself
+        (not wrapped in IOError) specifically so _relay() can catch just
+        that case to decide whether to retry; every other exception here
+        propagates as-is, unwrapped, straight out of _relay() too."""
         token = next_coap_token()
         # Confirmed always GET regardless of the inner operation -- see
         # this module's docstring for why.
@@ -193,7 +233,8 @@ class RelayedMobiusDevice(MobiusDevice):
         outer_frame = build_frame(OPGROUP_C2CI_REQUEST, COAP_OPCODE, coap_payload, outer_message_id)
 
         if self.debug:
-            print(f"    [relay debug] inner request frame ({len(inner_request_frame)}B): "
+            retry_note = " (retry)" if is_retry else ""
+            print(f"    [relay debug] inner request frame{retry_note} ({len(inner_request_frame)}B): "
                   f"{inner_request_frame.hex()}")
             print(f"    [relay debug] target address: {self.peer.address.hex()}  token: {token}")
             print(f"    [relay debug] outer request frame ({len(outer_frame)}B): {outer_frame.hex()}")
@@ -220,10 +261,7 @@ class RelayedMobiusDevice(MobiusDevice):
             coap_response = await asyncio.wait_for(coap_future, timeout=self.timeout)
         except asyncio.TimeoutError:
             self.gateway._pending_coap_tokens.pop(token, None)
-            raise IOError(
-                f"timed out waiting {self.timeout}s for a relayed response from target "
-                f"{self.peer.serial!r} (no CoAP indication received for token {token})"
-            )
+            raise asyncio.TimeoutError(token) from None
         finally:
             if self.debug:
                 self.gateway.on_any_frame = previous_hook

{python_mobius-0.4.2 → python_mobius-0.4.3}/tests/test_relay.py

@@ -133,6 +133,92 @@ class TestRelayedGetAttribute:
         with pytest.raises(IOError, match="timed out"):
             await relayed.get_attribute(C2Attribute.Epoch)
 
+    @pytest.mark.asyncio
+    async def test_retries_once_on_timeout_then_succeeds(self, connected_gateway):
+        """A real, confirmed production issue this addresses directly: a
+        relayed round-trip crosses BLE AND the Thread mesh, and a single
+        dropped/delayed packet somewhere in that longer path turned out
+        to be common enough that two lights lost data within seconds of
+        each other from single, transient relay timeouts -- confirmed
+        via reverse engineering that the real app never treats one timed-
+        out relay attempt as an actual failure, always retrying once
+        first. Simulates exactly that: the first attempt's own token
+        never gets a response, the retry's own (different) token does."""
+        relayed = RelayedMobiusDevice(connected_gateway, PEER, timeout=0.2)
+        inner_frame = _build_inner_get_response(C2Attribute.Epoch, index=0, value=struct.pack("<I", 1700000000))
+
+        call_count = 0
+
+        async def fake_send_frame(frame, message_id, wait_response=True, timeout=5.0):
+            nonlocal call_count
+            call_count += 1
+            assert wait_response is False
+            if call_count == 1:
+                return None  # first attempt: nothing ever arrives for its token
+            # second attempt (the retry): deliver the real response for
+            # ITS OWN token -- confirms each attempt truly gets a fresh
+            # one, not a reused/stale one from the first, abandoned try.
+            token = _extract_sent_token(frame)
+            indication_bytes = _build_indication_frame_bytes(inner_frame, token)
+            connected_gateway._on_rx_final(None, bytearray(indication_bytes))
+            return None
+
+        connected_gateway._send_frame = fake_send_frame
+
+        result = await relayed.get_attribute(C2Attribute.Epoch)
+
+        assert result == [struct.pack("<I", 1700000000)]
+        assert call_count == 2  # confirms a retry genuinely happened, not just luck
+
+    @pytest.mark.asyncio
+    async def test_raises_only_after_both_attempts_time_out(self, connected_gateway):
+        """The other half of the retry behavior: it's a single retry,
+        not unlimited -- if the retry ALSO times out, this must still
+        raise (not hang or retry forever), and the error message should
+        reflect that a retry was already attempted."""
+        relayed = RelayedMobiusDevice(connected_gateway, PEER, timeout=0.2)
+
+        call_count = 0
+
+        async def fake_send_frame(frame, message_id, wait_response=True, timeout=5.0):
+            nonlocal call_count
+            call_count += 1
+            return None  # never arrives, on either attempt
+
+        connected_gateway._send_frame = fake_send_frame
+
+        with pytest.raises(IOError, match="even after one retry"):
+            await relayed.get_attribute(C2Attribute.Epoch)
+
+        assert call_count == 2  # confirms exactly one retry happened, not zero or unlimited
+
+    @pytest.mark.asyncio
+    async def test_does_not_retry_a_malformed_response(self, connected_gateway):
+        """Only a TIMEOUT gets retried -- a response that actually
+        arrived, just malformed, is a different failure mode a retry
+        wouldn't help with (the same bad data would just arrive again),
+        so this should raise immediately, not after a second attempt."""
+        relayed = RelayedMobiusDevice(connected_gateway, PEER, timeout=0.2)
+
+        call_count = 0
+
+        async def fake_send_frame(frame, message_id, wait_response=True, timeout=5.0):
+            nonlocal call_count
+            call_count += 1
+            token = _extract_sent_token(frame)
+            # A real indication frame, but with garbage as the inner
+            # FSCI payload -- parse_frame() will reject this (bad CRC).
+            indication_bytes = _build_indication_frame_bytes(b"\x00\x00\x00\x00", token)
+            connected_gateway._on_rx_final(None, bytearray(indication_bytes))
+            return None
+
+        connected_gateway._send_frame = fake_send_frame
+
+        with pytest.raises(IOError, match="malformed"):
+            await relayed.get_attribute(C2Attribute.Epoch)
+
+        assert call_count == 1  # confirms no retry was attempted for this failure mode
+
     @pytest.mark.asyncio
     async def test_ignores_the_meaningless_opcode_25_confirm(self, connected_gateway):
         """Confirms a bare opcode-25 confirm (matching the real, confirmed