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

{python_mobius-0.4.0 → python_mobius-0.4.2}/.forgejo/workflows/release.yml

@@ -88,25 +88,30 @@ jobs:
         if: github.event_name == 'push'
         run: python3 .forgejo/scripts/extract_changelog_section.py "${{ github.ref_name }}"
 
-      # Both of the action's own README examples always set release-dir
-      # explicitly, even though it's documented as optional with a
-      # default -- confirmed via a real failure on this exact step
-      # ("tag v0.3.1 exists" / "curl: (26) Failed to open/read local
-      # data from file/application") that omitting it entirely doesn't
-      # work, the same bug already found and fixed the same way for
-      # ha-mobius's own release workflow. dist/ has the actual built
-      # wheel/sdist in it (from the Build package step above), but
-      # those are deliberately NOT what goes here -- PyPI stays the
-      # source of truth for the built artifacts, this step only creates
-      # the release entry with the extracted changelog section as its
-      # notes -- hence a separate, empty dist/release/ rather than
-      # pointing release-dir at dist/ itself.
-      - name: Ensure release-dir exists (empty -- no files attached)
-        if: github.event_name == 'push'
-        run: mkdir -p dist/release
-
-      # Same event-gating reason as the two steps above -- nothing to
-      # release against on a manual, non-tag run.
+      # Confirmed via direct comparison against ha-mobius's own release
+      # workflow (which has never hit this failure) exactly why an
+      # earlier version of this step kept failing on a real run ("tag
+      # vX.Y.Z exists" / "curl: (26) Failed to open/read local data from
+      # file/application") even after release-dir was set explicitly:
+      # the YAML here and in ha-mobius's version are structurally
+      # identical (same action, same inputs), but ha-mobius's
+      # release-dir always has at least one real file in it (a zip it
+      # builds beforehand for manual installers), while this repo's own
+      # release-dir was a directory that existed but was ALWAYS
+      # completely empty (deliberately, since PyPI is meant to be the
+      # source of truth here, not a Forgejo release asset). That's
+      # consistent with the action's own upload logic looping over
+      # release-dir's contents with an unquoted/unguarded shell glob:
+      # with zero matching files and no nullglob set, such a glob
+      # doesn't expand to nothing, it stays as the literal, unexpanded
+      # string -- and curl trying to read a file literally named
+      # "dist/release/*" produces exactly this error. Rather than an
+      # artificially empty directory, this points release-dir at dist/
+      # itself, which already has the actual built wheel/sdist in it
+      # from the Build package step above and is therefore never empty
+      # -- also means those get attached to the Forgejo release as a
+      # side effect, which is a reasonable thing to have anyway, not
+      # just a workaround.
       - name: Create Forgejo release
         if: github.event_name == 'push'
         uses: https://code.forgejo.org/actions/forgejo-release@v2
@@ -116,5 +121,5 @@ jobs:
           repo: r3pek/python-mobius
           token: ${{ secrets.GITHUB_TOKEN }}
           tag: ${{ github.ref_name }}
-          release-dir: dist/release
+          release-dir: dist
           release-notes-file: release_notes.md

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

@@ -1,5 +1,24 @@
 # Changelog
 
+## 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
+  twice in a tank's peer list.
+
 ## 0.4.0
 
 - **`mobius-scan`'s default now also connects to ONE device and dumps
@@ -629,8 +648,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.0 → python_mobius-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: python-mobius
-Version: 0.4.0
+Version: 0.4.2
 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.0 → python_mobius-0.4.2}/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.0 → python_mobius-0.4.2}/pyproject.toml

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

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

{python_mobius-0.4.0 → python_mobius-0.4.2}/src/mobius/device.py

@@ -709,12 +709,22 @@ class MobiusDevice:
         ShortAddressArray/SerialNumberArray/DeviceModelArray
         (3700/3701/3702, the same "get all elements" pattern used
         elsewhere in this library) from THIS connected device, acting as
-        a Thread mesh gateway, and returns every OTHER device it knows
-        about over the mesh -- not devices we necessarily have (or even
-        can have) a direct BLE connection to. See documentation/
+        a Thread mesh gateway, and returns what it reports about devices
+        over the mesh -- not devices we necessarily have (or even can
+        have) a direct BLE connection to. See documentation/
         09-thread-coap-relay.md for the full protocol trace this is
         based on.
 
+        Whether this includes the connected device's own entry
+        alongside others isn't confirmed either way -- unlike
+        discover_networked_thread_devices() (whose sibling docstring
+        this once matched, until a real capture disproved it there),
+        real hardware evidence specific to THIS older mechanism was
+        never gathered. Callers that also separately add the connected
+        device's own entry (e.g. mobius.discovery.discover_tank()) treat
+        this as a real possibility and deduplicate by serial regardless,
+        rather than assuming either way.
+
         **Confirmed via real hardware testing to be Cowboy-hub-specific.**
         These three arrays were originally found being fetched as part of
         the app's own network-setup logic for a dedicated Cowboy hub device,
@@ -789,9 +799,19 @@ class MobiusDevice:
         """
         Fetches MLPrefix (2128) plus NetworkedThreadDevices (1001, the
         same "get all elements" pattern used elsewhere in this library)
-        from THIS connected device, and returns every OTHER device it
-        knows about over the Thread mesh -- not devices we necessarily
-        have (or even can have) a direct BLE connection to.
+        from THIS connected device, and returns every device it knows
+        about over the Thread mesh -- not devices we necessarily have
+        (or even can have) a direct BLE connection to.
+
+        **Includes the connected device's own entry, not just others.**
+        An earlier version of this docstring claimed "every OTHER
+        device," an untested assumption rather than a confirmed one --
+        disproven by a real 4-device tank capture where a single
+        connected device's own NetworkedThreadDevices read returned all
+        4 real devices, necessarily including itself. Callers building
+        a peer list that also separately adds the connected device's own
+        entry (e.g. mobius.discovery.discover_tank()) need to
+        deduplicate by serial, or that device ends up listed twice.
 
         A second, better mesh-peer-discovery mechanism than
         discover_mesh_peers() -- confirmed via reverse engineering the
@@ -823,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
@@ -868,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.0 → python_mobius-0.4.2}/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.0 → python_mobius-0.4.2}/src/mobius/discovery.py

@@ -193,12 +193,28 @@ async def discover_tank(mdevice) -> "Tank":
     (not just serial/model, the way advertisement-only grouping like
     group_by_pan_id() can offer).
 
-    Calls mdevice.discover_mesh_peers_auto() (which only ever reports
-    OTHER devices) plus get_own_mesh_address()/get_device_info() (to
-    include the connected device itself in the result -- otherwise a
-    single-device tank would come back with zero peers, which would look
-    identical to "this device supports none of the discovery mechanisms"
-    rather than "this device IS the whole tank").
+    Calls mdevice.discover_mesh_peers_auto() plus
+    get_own_mesh_address()/get_device_info() to build the connected
+    device's own entry directly. These are deliberately DEDUPLICATED by
+    serial before returning, keeping the directly-built own entry over
+    whatever discover_mesh_peers_auto() reported for the same serial --
+    confirmed via a real 4-device tank capture that
+    discover_networked_thread_devices() (the mechanism
+    discover_mesh_peers_auto() tries first) is self-INCLUSIVE, not
+    self-exclusive as an earlier version of this docstring claimed
+    (based on an untested assumption, not a confirmed one): all 4 real
+    devices came back from a single connected device's own
+    NetworkedThreadDevices read, necessarily including whichever one was
+    actually connected to. Without deduplication, that connected
+    device's own peer would appear twice in the result -- once from this
+    function's own direct build, once from discover_mesh_peers_auto()'s
+    own report of it as "just another peer" on its own network. Not
+    confirmed whether the OLDER discover_mesh_peers() mechanism
+    (discover_mesh_peers_auto()'s own fallback) shares this same
+    self-inclusive behavior or not -- the deduplication here is
+    unconditional specifically so it's correct either way, rather than
+    depending on getting that confirmation for every code path that
+    could produce peers.
 
     tank.prefix is None if this device didn't report a valid mesh
     address at all (unsupported, or not currently part of an active
@@ -240,5 +256,13 @@ async def discover_tank(mdevice) -> "Tank":
     other_peers = await mdevice.discover_mesh_peers_auto()
     prefix = mesh_local_prefix_from_own_address(own_address)
 
-    return Tank(prefix=prefix, peers=[own_peer] + other_peers)
+    # own_peer always wins over whatever discover_mesh_peers_auto()
+    # separately reported for the same serial -- see this function's
+    # own docstring for why that duplicate is a real, confirmed
+    # possibility, not just a defensive guard against a hypothetical.
+    deduplicated = [own_peer] + [
+        peer for peer in other_peers if peer.serial != own_peer.serial
+    ]
+
+    return Tank(prefix=prefix, peers=deduplicated)
 

{python_mobius-0.4.0 → python_mobius-0.4.2}/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.0 → python_mobius-0.4.2}/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.0 → python_mobius-0.4.2}/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.0 → python_mobius-0.4.2}/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.0 → python_mobius-0.4.2}/tests/test_mesh_discovery.py

@@ -13,7 +13,7 @@ from bleak.backends.device import BLEDevice
 
 from mobius import C2Attribute, Model, MeshPeer
 from mobius.device import MobiusDevice
-from mobius.mesh_address import build_rloc_address
+from mobius.mesh_address import build_rloc_address, extract_short_address
 
 
 def _fake_ble_device():
@@ -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,12 +289,83 @@ 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
 
 
+@pytest.mark.asyncio
+async def test_discover_tank_deduplicates_self_from_discover_mesh_peers_auto():
+    """
+    The actual real-hardware bug this guards against: a real 4-device
+    tank capture showed discover_networked_thread_devices() (the
+    mechanism discover_mesh_peers_auto() tries first) returning ALL 4
+    real devices from a single connected device's own read, including
+    itself -- disproving an earlier assumption that it only ever
+    reports OTHER devices (see device.py's own docstring for the full
+    correction). Without deduplication, discover_tank() would list the
+    connected device twice: once from its own direct
+    get_own_mesh_address()/get_device_info() build, once again from
+    whatever discover_mesh_peers_auto() separately reported for that
+    same serial. Confirms the fix: the connected device appears exactly
+    once, its own directly-built entry wins over the (here, identical)
+    one discover_mesh_peers_auto() reported for the same serial, and
+    genuinely different peers are unaffected.
+    """
+    device = MobiusDevice(_fake_ble_device())
+    own_serial = "00000000000002"
+    own_address = PREFIX + bytes.fromhex("000000fffe005786")
+
+    # What discover_mesh_peers_auto() reports for the connected device's
+    # OWN serial -- same identity, but constructed independently (a
+    # DIFFERENT MeshPeer object, not literally the same instance the
+    # real own_peer build produces), matching how two separate discovery
+    # paths reporting the same physical device would actually look.
+    self_reported_by_auto = MeshPeer(
+        serial=own_serial, model_raw=Model.VorTechMP40wG3QD.value,
+        model=Model.VorTechMP40wG3QD, short_address=extract_short_address(own_address),
+        address=own_address, age=14519,
+    )
+    genuinely_other_peer = MeshPeer(
+        serial="00000000000001", model_raw=Model.VorTechMP40wG3QD.value,
+        model=Model.VorTechMP40wG3QD, short_address=0x0200,
+        address=PREFIX + bytes.fromhex("000000fffe009a0b"), age=373,
+    )
+
+    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, own_serial)
+        if attr_id in info_attrs:
+            return info_attrs[attr_id]
+        raise Exception("FsciStatus.UnsupportedAttribute")
+
+    device.get_attribute = fake_get_attribute
+    device.discover_mesh_peers_auto = AsyncMock(
+        return_value=[self_reported_by_auto, genuinely_other_peer]
+    )
+
+    tank = await discover_tank(device)
+
+    # The actual point: 2 real devices total, not 3 -- the connected
+    # device isn't double-counted.
+    assert len(tank.peers) == 2
+    serials = [p.serial for p in tank.peers]
+    assert serials.count(own_serial) == 1
+    assert own_serial 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),
+    # not the one discover_mesh_peers_auto() separately reported.
+    own_in_result = next(p for p in tank.peers if p.serial == own_serial)
+    assert own_in_result is not self_reported_by_auto
+    assert own_in_result.age is None
+    # The genuinely different peer is untouched.
+    assert genuinely_other_peer in tank.peers
+
+
 @pytest.mark.asyncio
 async def test_discover_tank_no_own_address_returns_empty_tank():
     """No own address means no valid connection to this Thread network --
@@ -328,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")
@@ -339,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.0 → python_mobius-0.4.2}/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.0 → python_mobius-0.4.2}/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.0 → python_mobius-0.4.2}/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.0 → python_mobius-0.4.2}/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)
 
 

python_mobius-0.4.2/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.0/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()