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

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

@@ -1,5 +1,29 @@
 # 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
+  unsigned -- could have shown as negative for a peer that had been
+  unreachable a very long time. Also confirmed what this value
+  actually means: milliseconds since that peer was last heard from on
+  the mesh, not since it was first found. It resets whenever the mesh
+  hears from that device again, so seeing it go down between two
+  checks is expected, not a bug.
+- Fixed `mobius-scan --dump-schedule` crashing for pumps specifically
+  (`'PumpSchedulePoint' object has no attribute 'has'`) -- that class
+  was missing a method `SchedulePoint` (the light-schedule equivalent)
+  already had, despite sharing the exact same flag bits.
+
 ## 0.4.1
 
 - Fixed `discover_tank()` sometimes reporting the connected device
@@ -634,8 +658,8 @@ branch has been merged into main as part of this release.
   Added while building a Home Assistant integration on top of this library,
   which needs a manufacturer string for its device registry.
 - `get_device_info()`'s `"serial"` field is now decoded as ASCII text
-  instead of hex-encoded raw bytes (e.g. `"7V4Z00F143RBED"` instead of
-  `"3756345a30304631343352424544"`). Confirmed printable ASCII on every
+  instead of hex-encoded raw bytes (e.g. `"FAKESERIAL0001"` instead of
+  `"46414b4553455249414c30303031"`). Confirmed printable ASCII on every
   device tested, via cross-validation against the same serial parsed from
   BLE advertisement manufacturer data. Falls back to hex for any
   non-printable-ASCII edge case not yet observed. Found while building the

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: python-mobius
-Version: 0.4.1
+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.1 → python_mobius-0.4.3}/documentation/09-thread-coap-relay.md

@@ -173,9 +173,12 @@ logic to be checked via a generic support check, **not gated to a
 Cowboy hub** the way the older three-parallel-arrays mechanism is.
 `MLPrefix` returns 24 bytes, of which only the first 8 are the real
 prefix; each `NetworkedThreadDevices` element is 28 bytes: an 8-byte
-interface-identifier suffix, a 4-byte "age" value (present in the wire
-format, but its exact meaning isn't confirmed against real hardware --
-see `MeshPeer`'s own docstring), a 2-byte model ID, and a 14-byte ASCII
+interface-identifier suffix, a 4-byte unsigned "age" value in
+milliseconds -- confirmed via reverse engineering the app's own network-
+troubleshooting screen to mean time since that specific peer was last
+heard from over the mesh (a resetting value, not time since first
+discovered -- see `MeshPeer`'s own docstring for the full detail), a
+2-byte model ID, and a 14-byte ASCII
 serial -- the same serial format used by `SerialNumberArray`. Every peer
 returned shares the connected device's own `MLPrefix`, which in
 practice is "every device in the same aquarium" -- the closest local

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "python-mobius"
-version = "0.4.1"
+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.1 → python_mobius-0.4.3}/src/mobius/__init__.py

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

{python_mobius-0.4.1 → python_mobius-0.4.3}/src/mobius/device.py

@@ -843,9 +843,11 @@ class MobiusDevice:
         build_rloc_address(), which is for the different case of only
         having a 2-byte short address to encode into the prefix's last 2
         bytes -- here the full 8-byte suffix is already present in the
-        entry, so it's used as-is); bytes 8-11 are a 4-byte "age" value
-        (see MeshPeer's own docstring for the important caveat that its
-        exact meaning isn't confirmed); bytes 12-13 are the 2-byte model
+        entry, so it's used as-is); bytes 8-11 are a 4-byte unsigned
+        "age" value in milliseconds -- confirmed to mean time since this
+        peer was last heard from over the mesh, a resetting value, not
+        time since first discovered (see MeshPeer's own docstring for
+        the full detail); bytes 12-13 are the 2-byte model
         ID; bytes 14-27 are the 14-byte ASCII serial number, matching the
         SerialNumberArray format used elsewhere in this library. All
         multi-byte numeric fields are read little-endian -- confirmed
@@ -888,7 +890,13 @@ class MobiusDevice:
             if len(entry) != 28:
                 continue
             address = prefix + entry[0:8]
-            age = struct.unpack("<i", entry[8:12])[0]
+            # Unsigned -- confirmed via reverse engineering the app's own
+            # network-troubleshooting screen, which explicitly treats this
+            # same 4-byte field as an unsigned value before ever using it
+            # for anything else. See MeshPeer's own docstring for the full,
+            # now-confirmed meaning (milliseconds since this peer was last
+            # heard from over the mesh).
+            age = struct.unpack("<I", entry[8:12])[0]
             model_raw = struct.unpack("<h", entry[12:14])[0]
             try:
                 serial = entry[14:28].decode("ascii").rstrip("\x00")

{python_mobius-0.4.1 → python_mobius-0.4.3}/src/mobius/device_status.py

@@ -130,18 +130,27 @@ class MeshPeer:
     `age` is only ever set by discover_networked_thread_devices() --
     None from every other source of MeshPeer, including
     discover_mesh_peers() and discover_mesh_peers_via_direct_connect().
-    Confirmed present as a raw 4-byte field in the wire format, but its
-    exact unit/meaning (freshness of the gateway's own knowledge of this
-    peer, most likely, given the name -- but not confirmed against real
-    hardware) is not confirmed; treat it as an opaque, larger-is-probably-
-    less-fresh value rather than a specific unit of time unless verified.
+    Confirmed via reverse engineering the app's own network-
+    troubleshooting screen: milliseconds since this specific peer was
+    last heard from over the Thread mesh, as far as the connected
+    gateway currently knows -- NOT time since it was first discovered
+    or added to the tank. A RESETTING value, not a monotonic one: it
+    legitimately drops back toward zero whenever the mesh genuinely
+    receives fresh activity from that peer, which happens on its own
+    schedule, independent of whenever this is read. Two checks in
+    quick succession can validly show a SMALLER age the second time --
+    that's expected, not a parsing error. The app's own troubleshooting
+    screen treats anything over roughly 5 minutes (300000) as long
+    enough to flag that peer as currently unreachable/failed, which is
+    a reasonable rule of thumb for interpreting this value generally,
+    though not enforced by this library itself.
     """
     serial: str
     model_raw: int
     model: Optional[Model]  # None if model_raw doesn't match a known Model value
     short_address: int
     address: bytes  # 16-byte Thread mesh-local IPv6, ready to pass to encode_coap_request()
-    age: Optional[int] = None  # see docstring -- only set by discover_networked_thread_devices()
+    age: Optional[int] = None  # milliseconds since last heard from on the mesh -- see docstring above
 
 
 @dataclass

{python_mobius-0.4.1 → 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.1 → python_mobius-0.4.3}/src/mobius/schedule.py

@@ -235,6 +235,16 @@ class PumpSchedulePoint:
             return None
         return cls(time_minutes, flags, PumpPrimitiveValue.parse(data[3:]))
 
+    def has(self, flag: int) -> bool:
+        # Same flags field, same bit meanings as SchedulePoint's own
+        # has() (see this class's own docstring: identical wire format,
+        # just different primitiveData) -- an earlier version of this
+        # class omitted this entirely, which crashed mobius.cli's own
+        # --dump-schedule for pumps specifically (its own _format_flags()
+        # helper is shared between the light and pump branches, calling
+        # point.has() either way).
+        return (self.flags & flag) == flag
+
 
 def get_active_pump_block(points: list[PumpSchedulePoint], minute_of_day: int) -> Optional[PumpSchedulePoint]:
     """

{python_mobius-0.4.1 → python_mobius-0.4.3}/tests/test_device_summary.py

@@ -120,7 +120,7 @@ async def test_get_device_summary_includes_generic_fields_for_lights_too():
     responses = {
         C2Attribute.Model: [(179).to_bytes(2, "little", signed=True)],
         C2Attribute.Name: [b""],
-        C2Attribute.SerialNumber: [b"7V4Z00F143RBED"],
+        C2Attribute.SerialNumber: [b"FAKESERIAL0001"],
         C2Attribute.PrimitiveType: [bytes([1])],  # VisualV1
         C2Attribute.ErrorState: [(0).to_bytes(2, "little", signed=True)],
         C2Attribute.MACAddress: [],

{python_mobius-0.4.1 → python_mobius-0.4.3}/tests/test_light_schedule.py

@@ -25,6 +25,16 @@ def test_schedule_point_parses_time_flags_and_primitive():
     assert sp.light.get(VisualID.RoyalBlue) == 500
 
 
+def test_has_reads_individual_flag_bits():
+    # FLAG_ACTIVE=1 | FLAG_NIGHT=2 = 3
+    night_point = SchedulePoint(600, 3, LightPrimitive({}))
+    assert night_point.has(SchedulePoint.FLAG_NIGHT) is True
+    assert night_point.has(SchedulePoint.FLAG_SUNRISE) is False
+
+    day_point = SchedulePoint(600, 1, LightPrimitive({}))
+    assert day_point.has(SchedulePoint.FLAG_NIGHT) is False
+
+
 def test_inactive_point_returns_none():
     raw_channel = bytes([18]) + (500).to_bytes(2, "little")
     raw_point = (600).to_bytes(2, "little") + bytes([0]) + raw_channel  # flags=0, not ACTIVE

{python_mobius-0.4.1 → python_mobius-0.4.3}/tests/test_manufacturer.py

@@ -1,15 +1,18 @@
 """
-Manufacturer-data parsing tests, using real advertisement bytes captured
-from four devices (two VorTech pumps, two Radion XR15 lights) all sharing
-one tank -- see documentation/08-manufacturer-data.md.
+Manufacturer-data parsing tests, using payloads shaped after real
+advertisement bytes captured from four devices (two VorTech pumps, two
+Radion XR15 lights) all sharing one tank -- see documentation/
+08-manufacturer-data.md. Model/flags/pan_id bytes are the genuine,
+validated wire format; each serial has been swapped for an obviously-
+fake placeholder of the same byte length.
 """
 from mobius import parse_manufacturer_data, Model
 
 REAL_PAYLOADS = {
-    "pump_left": "2a0001000000000f3d3736343935323231303539303139",
-    "pump_right": "2a0001000000000f3d3736353137373331393532303431",
-    "light_1": "b30001000000000f3d3756345a30304631343352424544",
-    "light_2": "b30001000000000f3d3756345a30304631343952424633",
+    "pump_left": "2a0001000000000f3d3030303030303030303030303032",
+    "pump_right": "2a0001000000000f3d3030303030303030303030303031",
+    "light_1": "b30001000000000f3d46414b4553455249414c30303031",
+    "light_2": "b30001000000000f3d46414b4553455249414c30303032",
 }
 
 
@@ -17,7 +20,7 @@ def test_parses_pump_payload():
     info = parse_manufacturer_data(bytes.fromhex(REAL_PAYLOADS["pump_left"]))
     assert info is not None
     assert info.model == Model.VorTechMP40wG3QD
-    assert info.serial == "76495221059019"
+    assert info.serial == "00000000000002"
     assert info.pan_id == 0x3D0F
 
 
@@ -25,7 +28,7 @@ def test_parses_light_payload():
     info = parse_manufacturer_data(bytes.fromhex(REAL_PAYLOADS["light_1"]))
     assert info is not None
     assert info.model == Model.RadionXR15wG6Pro
-    assert info.serial == "7V4Z00F143RBED"
+    assert info.serial == "FAKESERIAL0001"
     assert info.pan_id == 0x3D0F
 
 

{python_mobius-0.4.1 → python_mobius-0.4.3}/tests/test_mesh_discovery.py

@@ -44,7 +44,7 @@ async def test_discover_mesh_peers_basic():
         if attr_id == C2Attribute.MeshLocalAddresses:
             return [OWN_ADDRESS]
         if attr_id == C2Attribute.SerialNumberArray:
-            return [_serial_bytes("76517731952041"), _serial_bytes("7V4Z00F143RBED")]
+            return [_serial_bytes("00000000000001"), _serial_bytes("FAKESERIAL0001")]
         if attr_id == C2Attribute.DeviceModelArray:
             return [_model_bytes(Model.VorTechMP40wG3QD), _model_bytes(Model.RadionXR15wG6Pro)]
         if attr_id == C2Attribute.ShortAddressArray:
@@ -56,12 +56,12 @@ async def test_discover_mesh_peers_basic():
 
     assert len(peers) == 2
 
-    assert peers[0].serial == "76517731952041"
+    assert peers[0].serial == "00000000000001"
     assert peers[0].model == Model.VorTechMP40wG3QD
     assert peers[0].short_address == 0x1234
     assert peers[0].address == build_rloc_address(PREFIX, 0x1234)
 
-    assert peers[1].serial == "7V4Z00F143RBED"
+    assert peers[1].serial == "FAKESERIAL0001"
     assert peers[1].model == Model.RadionXR15wG6Pro
     assert peers[1].short_address == 0x5678
     assert peers[1].address == build_rloc_address(PREFIX, 0x5678)
@@ -81,9 +81,9 @@ async def test_discover_mesh_peers_filters_empty_slots():
             return [OWN_ADDRESS]
         if attr_id == C2Attribute.SerialNumberArray:
             return [
-                _serial_bytes("76517731952041"),
+                _serial_bytes("00000000000001"),
                 _serial_bytes("00000000000000"),  # cleared slot
-                _serial_bytes("7V4Z00F143RBED"),
+                _serial_bytes("FAKESERIAL0001"),
             ]
         if attr_id == C2Attribute.DeviceModelArray:
             return [_model_bytes(Model.VorTechMP40wG3QD), b"\x00\x00", _model_bytes(Model.RadionXR15wG6Pro)]
@@ -95,7 +95,7 @@ async def test_discover_mesh_peers_filters_empty_slots():
     peers = await device.discover_mesh_peers()
 
     assert len(peers) == 2
-    assert {p.serial for p in peers} == {"76517731952041", "7V4Z00F143RBED"}
+    assert {p.serial for p in peers} == {"00000000000001", "FAKESERIAL0001"}
 
 
 @pytest.mark.asyncio
@@ -106,7 +106,7 @@ async def test_discover_mesh_peers_unknown_model_returns_none_not_exception():
         if attr_id == C2Attribute.MeshLocalAddresses:
             return [OWN_ADDRESS]
         if attr_id == C2Attribute.SerialNumberArray:
-            return [_serial_bytes("76517731952041")]
+            return [_serial_bytes("00000000000001")]
         if attr_id == C2Attribute.DeviceModelArray:
             return [struct.pack("<h", 9999)]  # not a recognized Model value
         if attr_id == C2Attribute.ShortAddressArray:
@@ -162,7 +162,7 @@ async def test_discover_mesh_peers_array_fetch_failure_returns_empty():
         if attr_id == C2Attribute.MeshLocalAddresses:
             return [OWN_ADDRESS]
         if attr_id == C2Attribute.SerialNumberArray:
-            return [_serial_bytes("76517731952041")]
+            return [_serial_bytes("00000000000001")]
         raise IOError("array not supported")
 
     device.get_attribute = fake_get_attribute
@@ -267,7 +267,7 @@ async def test_discover_tank_basic():
     device = MobiusDevice(_fake_ble_device())
     own_address = PREFIX + bytes.fromhex("000000fffe000001")
     other_peer = MeshPeer(
-        serial="76517731952041", model_raw=Model.VorTechMP40wG3QD.value,
+        serial="00000000000001", model_raw=Model.VorTechMP40wG3QD.value,
         model=Model.VorTechMP40wG3QD, short_address=0x1234,
         address=PREFIX + bytes.fromhex("000000fffe001234"),
     )
@@ -275,7 +275,7 @@ async def test_discover_tank_basic():
     async def fake_get_attribute(attr_id, index=0, count=1):
         if attr_id == C2Attribute.MeshLocalAddresses:
             return [own_address]
-        info_attrs = _device_info_attrs(Model.RadionXR15wG6Pro, "7V4Z00F149RBF3")
+        info_attrs = _device_info_attrs(Model.RadionXR15wG6Pro, "FAKESERIAL0002")
         if attr_id in info_attrs:
             return info_attrs[attr_id]
         raise Exception("FsciStatus.UnsupportedAttribute")  # forces discover_mesh_peers_auto()'s fallback to also fail
@@ -289,7 +289,7 @@ async def test_discover_tank_basic():
     assert tank.prefix == PREFIX
     assert len(tank.peers) == 2
     # the connected device itself comes first
-    assert tank.peers[0].serial == "7V4Z00F149RBF3"
+    assert tank.peers[0].serial == "FAKESERIAL0002"
     assert tank.peers[0].model == Model.RadionXR15wG6Pro
     assert tank.peers[0].address == own_address
     assert tank.peers[1] is other_peer
@@ -314,7 +314,7 @@ async def test_discover_tank_deduplicates_self_from_discover_mesh_peers_auto():
     genuinely different peers are unaffected.
     """
     device = MobiusDevice(_fake_ble_device())
-    own_serial = "76495221059019"
+    own_serial = "00000000000002"
     own_address = PREFIX + bytes.fromhex("000000fffe005786")
 
     # What discover_mesh_peers_auto() reports for the connected device's
@@ -328,8 +328,8 @@ async def test_discover_tank_deduplicates_self_from_discover_mesh_peers_auto():
         address=own_address, age=14519,
     )
     genuinely_other_peer = MeshPeer(
-        serial="76517731952041", model_raw=Model.VorTechMP40wG3QD.value,
-        model=Model.VorTechMP40wG3QD, short_address=0x9a0b,
+        serial="00000000000001", model_raw=Model.VorTechMP40wG3QD.value,
+        model=Model.VorTechMP40wG3QD, short_address=0x0200,
         address=PREFIX + bytes.fromhex("000000fffe009a0b"), age=373,
     )
 
@@ -354,7 +354,7 @@ async def test_discover_tank_deduplicates_self_from_discover_mesh_peers_auto():
     serials = [p.serial for p in tank.peers]
     assert serials.count(own_serial) == 1
     assert own_serial in serials
-    assert "76517731952041" in serials
+    assert "00000000000001" in serials
     # The connected device's own directly-built entry wins -- confirmed
     # by checking it's the exact instance discover_tank() constructs
     # itself (has no .age set, unlike self_reported_by_auto which does),
@@ -399,7 +399,7 @@ async def test_discover_tank_single_device_no_other_peers():
     async def fake_get_attribute(attr_id, index=0, count=1):
         if attr_id == C2Attribute.MeshLocalAddresses:
             return [own_address]
-        info_attrs = _device_info_attrs(Model.VorTechMP40wG3QD, "76517731952041")
+        info_attrs = _device_info_attrs(Model.VorTechMP40wG3QD, "00000000000001")
         if attr_id in info_attrs:
             return info_attrs[attr_id]
         raise Exception("FsciStatus.UnsupportedAttribute")
@@ -410,4 +410,4 @@ async def test_discover_tank_single_device_no_other_peers():
     tank = await discover_tank(device)
     assert tank.prefix == PREFIX
     assert len(tank.peers) == 1
-    assert tank.peers[0].serial == "76517731952041"
+    assert tank.peers[0].serial == "00000000000001"

{python_mobius-0.4.1 → python_mobius-0.4.3}/tests/test_mesh_discovery_direct_connect.py

@@ -36,13 +36,13 @@ def _info(serial: str, model: Model) -> MobiusAdvertisement:
 @pytest.mark.asyncio
 async def test_basic_discovery():
     devices = [
-        (_ble("AA:AA:AA:AA:AA:AA"), _info("76517731952041", Model.VorTechMP40wG3QD)),
-        (_ble("BB:BB:BB:BB:BB:BB"), _info("7V4Z00F143RBED", Model.RadionXR15wG6Pro)),
+        (_ble("AA:AA:AA:AA:AA:AA"), _info("00000000000001", Model.VorTechMP40wG3QD)),
+        (_ble("BB:BB:BB:BB:BB:BB"), _info("FAKESERIAL0001", Model.RadionXR15wG6Pro)),
     ]
 
     addresses = {
-        "76517731952041": build_rloc_address(PREFIX, 0x1234),
-        "7V4Z00F143RBED": build_rloc_address(PREFIX, 0x5678),
+        "00000000000001": build_rloc_address(PREFIX, 0x1234),
+        "FAKESERIAL0001": build_rloc_address(PREFIX, 0x5678),
     }
 
     async def fake_connect(self):
@@ -67,17 +67,17 @@ async def test_basic_discovery():
 
     assert len(peers) == 2
     by_serial = {p.serial: p for p in peers}
-    assert by_serial["76517731952041"].address == addresses["76517731952041"]
-    assert by_serial["76517731952041"].model == Model.VorTechMP40wG3QD
-    assert by_serial["7V4Z00F143RBED"].address == addresses["7V4Z00F143RBED"]
-    assert by_serial["7V4Z00F143RBED"].model == Model.RadionXR15wG6Pro
+    assert by_serial["00000000000001"].address == addresses["00000000000001"]
+    assert by_serial["00000000000001"].model == Model.VorTechMP40wG3QD
+    assert by_serial["FAKESERIAL0001"].address == addresses["FAKESERIAL0001"]
+    assert by_serial["FAKESERIAL0001"].model == Model.RadionXR15wG6Pro
 
 
 @pytest.mark.asyncio
 async def test_skips_devices_with_no_parsed_info():
     devices = [
         (_ble("AA:AA:AA:AA:AA:AA"), None),  # no manufacturer data parsed -- no serial to key on
-        (_ble("BB:BB:BB:BB:BB:BB"), _info("7V4Z00F143RBED", Model.RadionXR15wG6Pro)),
+        (_ble("BB:BB:BB:BB:BB:BB"), _info("FAKESERIAL0001", Model.RadionXR15wG6Pro)),
     ]
 
     async def fake_connect(self):
@@ -95,14 +95,14 @@ async def test_skips_devices_with_no_parsed_info():
         peers = await discover_mesh_peers_via_direct_connect(devices)
 
     assert len(peers) == 1
-    assert peers[0].serial == "7V4Z00F143RBED"
+    assert peers[0].serial == "FAKESERIAL0001"
 
 
 @pytest.mark.asyncio
 async def test_skips_devices_that_fail_to_connect():
     devices = [
-        (_ble("AA:AA:AA:AA:AA:AA"), _info("76517731952041", Model.VorTechMP40wG3QD)),
-        (_ble("BB:BB:BB:BB:BB:BB"), _info("7V4Z00F143RBED", Model.RadionXR15wG6Pro)),
+        (_ble("AA:AA:AA:AA:AA:AA"), _info("00000000000001", Model.VorTechMP40wG3QD)),
+        (_ble("BB:BB:BB:BB:BB:BB"), _info("FAKESERIAL0001", Model.RadionXR15wG6Pro)),
     ]
 
     async def fake_connect(self):
@@ -125,12 +125,12 @@ async def test_skips_devices_that_fail_to_connect():
     # matches this library's usual fail-soft philosophy for this kind of
     # best-effort, multi-device operation.
     assert len(peers) == 1
-    assert peers[0].serial == "7V4Z00F143RBED"
+    assert peers[0].serial == "FAKESERIAL0001"
 
 
 @pytest.mark.asyncio
 async def test_skips_devices_that_report_no_address():
-    devices = [(_ble("AA:AA:AA:AA:AA:AA"), _info("76517731952041", Model.VorTechMP40wG3QD))]
+    devices = [(_ble("AA:AA:AA:AA:AA:AA"), _info("00000000000001", Model.VorTechMP40wG3QD))]
 
     async def fake_connect(self):
         self._client = object()
@@ -160,7 +160,7 @@ async def test_disconnects_even_after_successful_read():
     """Confirms each connection is actually closed (via the async with
     block) rather than leaked, since this connects to potentially many
     devices in a loop."""
-    devices = [(_ble("AA:AA:AA:AA:AA:AA"), _info("76517731952041", Model.VorTechMP40wG3QD))]
+    devices = [(_ble("AA:AA:AA:AA:AA:AA"), _info("00000000000001", Model.VorTechMP40wG3QD))]
     disconnect_called = {"count": 0}
 
     async def fake_connect(self):

{python_mobius-0.4.1 → python_mobius-0.4.3}/tests/test_networked_thread_devices.py

@@ -31,7 +31,7 @@ MLPREFIX_RAW = PREFIX + bytes.fromhex("00" * 16)
 def _entry(suffix: bytes, age: int, model: Model, serial: str) -> bytes:
     assert len(suffix) == 8
     serial_bytes = serial.encode("ascii").ljust(14, b"\x00")
-    return suffix + struct.pack("<i", age) + struct.pack("<h", model.value) + serial_bytes
+    return suffix + struct.pack("<I", age) + struct.pack("<h", model.value) + serial_bytes
 
 
 @pytest.mark.asyncio
@@ -45,8 +45,8 @@ async def test_discover_networked_thread_devices_basic():
             return [MLPREFIX_RAW]
         if attr_id == C2Attribute.NetworkedThreadDevices:
             return [
-                _entry(suffix_a, 42, Model.VorTechMP40wG3QD, "76517731952041"),
-                _entry(suffix_b, 7, Model.RadionXR15wG6Pro, "7V4Z00F143RBED"),
+                _entry(suffix_a, 42, Model.VorTechMP40wG3QD, "00000000000001"),
+                _entry(suffix_b, 7, Model.RadionXR15wG6Pro, "FAKESERIAL0001"),
             ]
         raise AssertionError(f"unexpected attribute: {attr_id}")
 
@@ -55,19 +55,46 @@ async def test_discover_networked_thread_devices_basic():
 
     assert len(peers) == 2
 
-    assert peers[0].serial == "76517731952041"
+    assert peers[0].serial == "00000000000001"
     assert peers[0].model == Model.VorTechMP40wG3QD
     assert peers[0].address == PREFIX + suffix_a
     assert peers[0].short_address == 0x1234
     assert peers[0].age == 42
 
-    assert peers[1].serial == "7V4Z00F143RBED"
+    assert peers[1].serial == "FAKESERIAL0001"
     assert peers[1].model == Model.RadionXR15wG6Pro
     assert peers[1].address == PREFIX + suffix_b
     assert peers[1].short_address == 0x5678
     assert peers[1].age == 7
 
 
+@pytest.mark.asyncio
+async def test_discover_networked_thread_devices_age_is_unsigned():
+    """The real, confirmed bug this guards against: an earlier version
+    of this parsing read age as a SIGNED 32-bit integer. Confirmed via
+    reverse engineering the app's own network-troubleshooting screen
+    that it's actually unsigned -- a value with the top bit set (e.g.
+    0x80000001) must come back as the large positive number the app
+    itself would show, not a negative one."""
+    device = MobiusDevice(_fake_ble_device())
+    suffix = bytes.fromhex("000000fffe00") + struct.pack("<H", 0x1234)
+    high_bit_age = 0x80000001  # would decode as -2147483647 if parsed signed
+
+    async def fake_get_attribute(attr_id, index=0, count=1):
+        if attr_id == C2Attribute.MLPrefix:
+            return [MLPREFIX_RAW]
+        if attr_id == C2Attribute.NetworkedThreadDevices:
+            return [_entry(suffix, high_bit_age, Model.VorTechMP40wG3QD, "00000000000001")]
+        raise AssertionError(f"unexpected attribute: {attr_id}")
+
+    device.get_attribute = fake_get_attribute
+    peers = await device.discover_networked_thread_devices()
+
+    assert len(peers) == 1
+    assert peers[0].age == high_bit_age
+    assert peers[0].age > 0
+
+
 @pytest.mark.asyncio
 async def test_discover_networked_thread_devices_filters_empty_slots():
     device = MobiusDevice(_fake_ble_device())
@@ -126,14 +153,14 @@ async def test_discover_networked_thread_devices_skips_wrong_length_entries():
         if attr_id == C2Attribute.NetworkedThreadDevices:
             return [
                 b"\x00" * 10,  # too short -- skipped
-                _entry(suffix, 5, Model.VorTechMP40wG3QD, "76517731952041"),
+                _entry(suffix, 5, Model.VorTechMP40wG3QD, "00000000000001"),
             ]
         raise AssertionError(f"unexpected attribute: {attr_id}")
 
     device.get_attribute = fake_get_attribute
     peers = await device.discover_networked_thread_devices()
     assert len(peers) == 1
-    assert peers[0].serial == "76517731952041"
+    assert peers[0].serial == "00000000000001"
 
 
 @pytest.mark.asyncio
@@ -187,7 +214,7 @@ async def test_discover_mesh_peers_auto_prefers_networked_thread_devices():
         if attr_id == C2Attribute.MLPrefix:
             return [MLPREFIX_RAW]
         if attr_id == C2Attribute.NetworkedThreadDevices:
-            return [_entry(suffix, 1, Model.VorTechMP40wG3QD, "76517731952041")]
+            return [_entry(suffix, 1, Model.VorTechMP40wG3QD, "00000000000001")]
         raise AssertionError(
             f"discover_mesh_peers() (the fallback) should not have been "
             f"reached: attribute {attr_id}"
@@ -196,7 +223,7 @@ async def test_discover_mesh_peers_auto_prefers_networked_thread_devices():
     device.get_attribute = fake_get_attribute
     peers = await device.discover_mesh_peers_auto()
     assert len(peers) == 1
-    assert peers[0].serial == "76517731952041"
+    assert peers[0].serial == "00000000000001"
     assert peers[0].age == 1  # only set by the newer mechanism
 
 
@@ -215,7 +242,7 @@ async def test_discover_mesh_peers_auto_falls_back_to_discover_mesh_peers():
         if attr_id == C2Attribute.MeshLocalAddresses:
             return [own_address]
         if attr_id == C2Attribute.SerialNumberArray:
-            return [b"76517731952041"]
+            return [b"00000000000001"]
         if attr_id == C2Attribute.DeviceModelArray:
             return [struct.pack("<h", Model.VorTechMP40wG3QD.value)]
         if attr_id == C2Attribute.ShortAddressArray:
@@ -225,7 +252,7 @@ async def test_discover_mesh_peers_auto_falls_back_to_discover_mesh_peers():
     device.get_attribute = fake_get_attribute
     peers = await device.discover_mesh_peers_auto()
     assert len(peers) == 1
-    assert peers[0].serial == "76517731952041"
+    assert peers[0].serial == "00000000000001"
     assert peers[0].address == build_rloc_address(PREFIX, 0x1234)
     assert peers[0].age is None  # not set by the older mechanism
 
@@ -243,22 +270,26 @@ async def test_discover_mesh_peers_auto_returns_empty_if_both_fail():
 
 
 # --------------------------------------------------------------------------
-# Real hardware capture -- a live 4-device tank (2 VorTech pumps, 2 Radion
-# lights), including 26 empty slots interleaved with the real entries.
-# Confirms this method's parsing against genuine wire data, not just
-# synthetic fixtures -- every field below (suffix, age, model, serial,
-# and the derived short_address/address) was independently verified by
-# hand against this exact capture before this test was written.
+# Shaped after a real hardware capture -- a live 4-device tank (2 VorTech
+# pumps, 2 Radion lights), including 26 empty slots interleaved with the
+# real entries. Confirms this method's parsing against genuine wire
+# structure, not just synthetic fixtures -- the entry layout (suffix,
+# age, model, serial fields) and the age/model values themselves are the
+# real, independently-verified capture; each device's own suffix and
+# serial have been swapped for obviously-fake placeholders of the same
+# byte length (and short_address/address below updated to match those
+# placeholders, since both are deterministically derived from the
+# suffix bytes).
 # --------------------------------------------------------------------------
 
 REAL_MLPREFIX_RAW = bytes.fromhex(
-    "fd1c5ec780e35c01" + "00" * 16
+    "fdaaaaaaaaaaaaaa" + "00" * 16
 )
 REAL_ENTRIES_RAW = [
-    bytes.fromhex("89766dcd51eef69000000000b3003756345a30304631343952424633"),
-    bytes.fromhex("14f417a6cf370b9a750100002a003736353137373331393532303431"),
-    bytes.fromhex("bd0d4f547f328657b73800002a003736343935323231303539303139"),
-    bytes.fromhex("7c22c78c0ac88b332a210000b3003756345a30304631343352424544"),
+    bytes.fromhex("000000000000000100000000b30046414b4553455249414c30303032"),
+    bytes.fromhex("0000000000000002750100002a003030303030303030303030303031"),
+    bytes.fromhex("0000000000000003b73800002a003030303030303030303030303032"),
+    bytes.fromhex("00000000000000042a210000b30046414b4553455249414c30303031"),
 ] + [bytes.fromhex("00" * 28)] * 26  # 26 empty slots, interleaved on real hardware
 
 
@@ -280,23 +311,23 @@ async def test_discover_networked_thread_devices_real_hardware_capture():
 
     by_serial = {p.serial: p for p in peers}
 
-    p = by_serial["7V4Z00F149RBF3"]
+    p = by_serial["FAKESERIAL0002"]
     assert p.model == Model.RadionXR15wG6Pro
     assert p.age == 0
-    assert p.short_address == 0x90F6
-    assert p.address == bytes.fromhex("fd1c5ec780e35c0189766dcd51eef690")
+    assert p.short_address == 0x0100
+    assert p.address == bytes.fromhex("fdaaaaaaaaaaaaaa0000000000000001")
 
-    p = by_serial["76517731952041"]
+    p = by_serial["00000000000001"]
     assert p.model == Model.VorTechMP40wG3QD
     assert p.age == 373
-    assert p.short_address == 0x9A0B
+    assert p.short_address == 0x0200
 
-    p = by_serial["76495221059019"]
+    p = by_serial["00000000000002"]
     assert p.model == Model.VorTechMP40wG3QD
     assert p.age == 14519
-    assert p.short_address == 0x5786
+    assert p.short_address == 0x0300
 
-    p = by_serial["7V4Z00F143RBED"]
+    p = by_serial["FAKESERIAL0001"]
     assert p.model == Model.RadionXR15wG6Pro
     assert p.age == 8490
-    assert p.short_address == 0x338B
+    assert p.short_address == 0x0400

{python_mobius-0.4.1 → python_mobius-0.4.3}/tests/test_pump_schedule.py

@@ -5,7 +5,7 @@ see documentation/07-pump-schedule.md.
 """
 from mobius import (
     PumpPrimitiveValue, PumpSchedulePoint, get_active_pump_block,
-    PumpMode, PumpParam,
+    PumpMode, PumpParam, SchedulePoint,
 )
 
 
@@ -55,6 +55,21 @@ def test_schedule_point_parses_and_rejects_inactive():
     assert PumpSchedulePoint.parse(raw_inactive) is None
 
 
+def test_has_reads_the_same_flags_field_schedulepoint_does():
+    """A real, confirmed bug this covers: PumpSchedulePoint used to have
+    no has() method at all, despite sharing the exact same wire format
+    and flag bit meanings as SchedulePoint (light schedules) -- crashed
+    mobius.cli's own --dump-schedule for pumps specifically, since its
+    _format_flags() helper is shared between both branches."""
+    # FLAG_ACTIVE=1 | FLAG_NIGHT=2 = 3
+    night_point = PumpSchedulePoint(480, 3, PumpPrimitiveValue(PumpMode.ConstantSpeed, {}))
+    assert night_point.has(SchedulePoint.FLAG_NIGHT) is True
+    assert night_point.has(SchedulePoint.FLAG_SUNRISE) is False
+
+    day_point = PumpSchedulePoint(480, 1, PumpPrimitiveValue(PumpMode.ConstantSpeed, {}))
+    assert day_point.has(SchedulePoint.FLAG_NIGHT) is False
+
+
 def _make_pump_point(minute, mode, max_speed):
     return PumpSchedulePoint(minute, 1, PumpPrimitiveValue(mode, {PumpParam.MaxSpeed: max_speed}))
 

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

@@ -25,7 +25,7 @@ from mobius.frame import (
 
 
 TARGET_ADDRESS = bytes.fromhex("fd11223344556677000000fffe001234")
-PEER = MeshPeer(serial="7V4Z00F143RBED", model_raw=179, model=None,
+PEER = MeshPeer(serial="FAKESERIAL0001", model_raw=179, model=None,
                  short_address=0x1234, address=TARGET_ADDRESS)
 
 
@@ -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

python_mobius-0.4.3/tests/test_serial_decoding.py

@@ -0,0 +1,22 @@
+from mobius.device import _decode_serial
+
+
+def test_decodes_ascii_serial_in_the_real_pump_wire_format():
+    # A VorTech MP40QD pump's real 14-byte ASCII serial field format,
+    # with an obviously-fake placeholder value.
+    assert _decode_serial(bytes.fromhex("3030303030303030303030303032")) == "00000000000002"
+
+
+def test_decodes_ascii_serial_in_the_real_light_wire_format():
+    # A Radion XR15 G6 Pro's real 14-byte ASCII serial field format,
+    # with an obviously-fake placeholder value.
+    assert _decode_serial(bytes.fromhex("46414b4553455249414c30303031")) == "FAKESERIAL0001"
+
+
+def test_strips_trailing_nulls():
+    assert _decode_serial(b"ABC123\x00\x00\x00") == "ABC123"
+
+
+def test_falls_back_to_hex_for_non_ascii():
+    raw = bytes([0, 1, 2, 3])
+    assert _decode_serial(raw) == raw.hex()

python_mobius-0.4.1/tests/test_serial_decoding.py

@@ -1,20 +0,0 @@
-from mobius.device import _decode_serial
-
-
-def test_decodes_real_pump_serial_as_ascii():
-    # Real captured serial from a VorTech MP40QD pump.
-    assert _decode_serial(bytes.fromhex("3736343935323231303539303139")) == "76495221059019"
-
-
-def test_decodes_real_light_serial_as_ascii():
-    # Real captured serial from a Radion XR15 G6 Pro.
-    assert _decode_serial(bytes.fromhex("3756345a30304631343352424544")) == "7V4Z00F143RBED"
-
-
-def test_strips_trailing_nulls():
-    assert _decode_serial(b"ABC123\x00\x00\x00") == "ABC123"
-
-
-def test_falls_back_to_hex_for_non_ascii():
-    raw = bytes([0, 1, 2, 3])
-    assert _decode_serial(raw) == raw.hex()