python-mobius 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

mobius/__init__.py

@@ -61,7 +61,7 @@ from .discovery import (
     dedupe_by_serial, find_device_by_serial, discover_mesh_peers_via_direct_connect,
 )
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"
 
 __all__ = [
     "__version__",

mobius/device.py

@@ -363,16 +363,23 @@ class MobiusDevice:
         finally:
             self._pending.pop(message_id, None)
 
-    async def get_attribute_raw(self, attr_id: int, index: int = 0, count: int = 1) -> Optional[AttributeValue]:
+    async def get_attribute_raw_all(self, attr_id: int, index: int = 0, count: int = 1) -> list[AttributeValue]:
         """
-        Like get_attribute(), but returns the full AttributeValue
-        (attr_id, index, values) instead of just the values list --
-        preserving the device-reported starting index. Needed for
-        attributes like MaxPower/NormalPower where the index itself is
-        meaningful (index = VisualID byte value the value belongs to), not
-        just a positional offset from the requested index. get_attribute()
-        is a thin wrapper around this for the common case where you don't
-        need the index.
+        Like get_attribute_raw(), but returns EVERY matching AttributeValue
+        block in the response, not just the first.
+
+        Confirmed necessary via real hardware testing: at least some
+        "get all elements" responses (FirmwareVersion on a real Radion
+        light) split their elements across MULTIPLE separate
+        (attrId, index, count, values) blocks within a single response,
+        rather than one block covering every element -- a light showing
+        8 firmware components in the official app came back as only 5
+        via get_attribute_raw(), because it silently returned just the
+        first block and discarded the rest. Each block has its OWN
+        starting index; callers that use the device-reported index to
+        interpret which sub-type each value belongs to (FirmwareType,
+        HardwareInfo, VisualID, etc.) need to apply it per-block, not
+        assume one single starting index covers every returned value.
         """
         message_id = next_message_id()
         payload = encode_get_attribute(attr_id, index, count, extended=False)
@@ -384,12 +391,46 @@ class MobiusDevice:
         if status != FsciStatus.Success:
             raise IOError(f"device returned FSCI status {status!r} for attribute {attr_id}")
         attrs = decode_attribute_response(resp.data, extended=False)
-        for a in attrs:
-            if a.attr_id == attr_id:
-                return a
-        return None
+        return [a for a in attrs if a.attr_id == attr_id]
+
+    async def get_attribute_raw(self, attr_id: int, index: int = 0, count: int = 1) -> Optional[AttributeValue]:
+        """
+        Like get_attribute(), but returns the full AttributeValue
+        (attr_id, index, values) instead of just the values list --
+        preserving the device-reported starting index. Needed for
+        attributes like MaxPower/NormalPower where the index itself is
+        meaningful (index = VisualID byte value the value belongs to), not
+        just a positional offset from the requested index. get_attribute()
+        is a thin wrapper around this for the common case where you don't
+        need the index.
+
+        Returns only the FIRST matching block -- if the response might be
+        split across multiple blocks (confirmed to happen for some "get
+        all elements" attributes; see get_attribute_raw_all()'s
+        docstring), use that instead and iterate over every block.
+        """
+        all_matches = await self.get_attribute_raw_all(attr_id, index, count)
+        return all_matches[0] if all_matches else None
+
+    async def get_attribute_all(self, attr_id: int, index: int = 0, count: int = 1) -> list[bytes]:
+        """
+        Like get_attribute(), but merges values from EVERY matching block
+        in the response (see get_attribute_raw_all()'s docstring for why
+        this matters), for callers that don't need per-block index
+        tracking -- e.g. get_supported_channels(), where each value
+        encodes its own identity directly rather than relying on
+        positional/index information from the response envelope.
+        """
+        blocks = await self.get_attribute_raw_all(attr_id, index, count)
+        values: list[bytes] = []
+        for block in blocks:
+            values.extend(block.values)
+        return values
 
     async def get_attribute(self, attr_id: int, index: int = 0, count: int = 1) -> list[bytes]:
+        """Returns only the FIRST matching block's values -- if the
+        response might be split across multiple blocks, use
+        get_attribute_all() instead."""
         raw = await self.get_attribute_raw(attr_id, index, count)
         return raw.values if raw else []
 
@@ -733,8 +774,12 @@ class MobiusDevice:
         the same "get all elements" pattern as MaxPower/NormalPower/
         SupportedColorChannels. Each returned element's device-reported
         index is the FirmwareType byte value it belongs to (uses
-        get_attribute_raw() for the same reason get_channel_power_info()
-        does -- the index is meaningful, not just positional).
+        get_attribute_raw_all() for the same reason get_channel_power_info()
+        does -- the index is meaningful, not just positional -- and to
+        avoid missing elements from a second block; see that function's
+        docstring for why a single response can legitimately split across
+        more than one block, confirmed via a real Radion light whose
+        FirmwareVersion response came back in two separate blocks).
 
         Each version is formatted as a dot-joined string from the raw
         response bytes (e.g. "4.0.21") -- confirmed via
@@ -752,34 +797,38 @@ class MobiusDevice:
         (non-EcoTech) label scheme.
         """
         try:
-            raw = await self.get_attribute_raw(C2Attribute.FirmwareVersion, index=0, count=0xFFFF)
+            blocks = await self.get_attribute_raw_all(C2Attribute.FirmwareVersion, index=0, count=0xFFFF)
         except Exception:
             return {}
-        if not raw:
+        if not blocks:
             return {}
 
         use_etm_labels = model is not None and manufacturer_for_model(model) == "EcoTech Marine"
 
         result = {}
-        for i, value_bytes in enumerate(raw.values):
-            if not value_bytes:
-                continue
-            try:
-                fw_type = FirmwareType(raw.index + i)
-            except ValueError:
-                continue
-            if use_etm_labels and fw_type in FIRMWARE_TYPE_LABELS_ETM:
-                label = FIRMWARE_TYPE_LABELS_ETM[fw_type]
-            else:
-                label = fw_type.name
-            version = ".".join(str(b) for b in value_bytes)
-            result[label] = version
+        for raw in blocks:
+            for i, value_bytes in enumerate(raw.values):
+                if not value_bytes:
+                    continue
+                try:
+                    fw_type = FirmwareType(raw.index + i)
+                except ValueError:
+                    continue
+                if use_etm_labels and fw_type in FIRMWARE_TYPE_LABELS_ETM:
+                    label = FIRMWARE_TYPE_LABELS_ETM[fw_type]
+                else:
+                    label = fw_type.name
+                version = ".".join(str(b) for b in value_bytes)
+                result[label] = version
         return result
 
     async def get_hardware_info(self) -> dict:
         """
         Fetches HardwareRevision (attribute 2) with index=0, count=0xFFFF
-        -- same pattern as get_firmware_versions(). Unlike firmware
+        -- same pattern as get_firmware_versions(), including using
+        get_attribute_raw_all() rather than get_attribute_raw() to avoid
+        missing elements if the response splits across more than one
+        block (see get_attribute_raw_all()'s docstring). Unlike firmware
         versions, no dot-joined-string display convention is confirmed for
         these fields (Color/Revision/ProductType/RadioType/MotorType/
         Segments read more like small integer/enum codes than version
@@ -787,19 +836,20 @@ class MobiusDevice:
         until that's confirmed against real hardware.
         """
         try:
-            raw = await self.get_attribute_raw(C2Attribute.HardwareRevision, index=0, count=0xFFFF)
+            blocks = await self.get_attribute_raw_all(C2Attribute.HardwareRevision, index=0, count=0xFFFF)
         except Exception:
             return {}
-        if not raw:
+        if not blocks:
             return {}
 
         result = {}
-        for i, value_bytes in enumerate(raw.values):
-            try:
-                hw_info = HardwareInfo(raw.index + i)
-            except ValueError:
-                continue
-            result[hw_info.name] = value_bytes
+        for raw in blocks:
+            for i, value_bytes in enumerate(raw.values):
+                try:
+                    hw_info = HardwareInfo(raw.index + i)
+                except ValueError:
+                    continue
+                result[hw_info.name] = value_bytes
         return result
 
     async def get_device_summary(self) -> dict:
@@ -1025,7 +1075,7 @@ class MobiusDevice:
 
     async def get_supported_channels(self) -> list[VisualID]:
         """Confirmed via Visuals.java: the static list of channels this light has."""
-        raw = await self.get_attribute(C2Attribute.SupportedColorChannels, index=0, count=0xFFFF)
+        raw = await self.get_attribute_all(C2Attribute.SupportedColorChannels, index=0, count=0xFFFF)
         out = []
         for v in raw:
             if v:
@@ -1165,15 +1215,17 @@ class MobiusDevice:
         Ported from MaxPower.java/NormalPower.java's parseRequest(): each
         returned element's device-reported index is the VisualID byte
         value it belongs to (NOT simply its position in the response) --
-        uses get_attribute_raw() rather than get_attribute() specifically
-        because of this.
+        uses get_attribute_raw_all() rather than get_attribute() for this
+        reason, and to avoid missing elements if the response splits
+        across more than one block (see get_attribute_raw_all()'s
+        docstring).
         """
         max_power: dict = {}
         try:
-            raw = await self.get_attribute_raw(C2Attribute.MaxPower, index=0, count=0xFFFF)
+            max_blocks = await self.get_attribute_raw_all(C2Attribute.MaxPower, index=0, count=0xFFFF)
         except Exception:
-            raw = None
-        if raw:
+            max_blocks = []
+        for raw in max_blocks:
             for i, value_bytes in enumerate(raw.values):
                 if len(value_bytes) < 4:
                     continue
@@ -1188,22 +1240,23 @@ class MobiusDevice:
 
         normal_power: Optional[dict] = None
         try:
-            raw2 = await self.get_attribute_raw(C2Attribute.NormalPower, index=0, count=0xFFFF)
+            normal_blocks = await self.get_attribute_raw_all(C2Attribute.NormalPower, index=0, count=0xFFFF)
         except Exception:
-            raw2 = None
-        if raw2:
+            normal_blocks = []
+        if normal_blocks:
             normal_power = {}
-            for i, value_bytes in enumerate(raw2.values):
-                if len(value_bytes) < 4:
-                    continue
-                watts = struct.unpack("<i", value_bytes)[0]
-                if watts <= 0:
-                    continue
-                try:
-                    vid = VisualID(raw2.index + i)
-                except ValueError:
-                    continue
-                normal_power[vid] = watts
+            for raw2 in normal_blocks:
+                for i, value_bytes in enumerate(raw2.values):
+                    if len(value_bytes) < 4:
+                        continue
+                    watts = struct.unpack("<i", value_bytes)[0]
+                    if watts <= 0:
+                        continue
+                    try:
+                        vid = VisualID(raw2.index + i)
+                    except ValueError:
+                        continue
+                    normal_power[vid] = watts
 
         return ChannelPowerInfo(max_power, normal_power)
 

mobius/relay.py

@@ -250,14 +250,30 @@ class RelayedMobiusDevice(MobiusDevice):
                   f"data ({len(inner.data)}B): {inner.data.hex()}")
         return inner
 
-    async def get_attribute_raw(self, attr_id: int, index: int = 0, count: int = 1) -> Optional[AttributeValue]:
+    async def get_attribute_raw_all(self, attr_id: int, index: int = 0, count: int = 1) -> list[AttributeValue]:
+        """
+        Like get_attribute_raw(), but returns EVERY matching
+        AttributeValue block in the relayed response, not just the
+        first -- matches MobiusDevice.get_attribute_raw_all()'s reasoning
+        exactly (see its docstring): a device's response to a single Get
+        request can legitimately split across more than one block, and
+        that's just as true when reached via relay as directly, since
+        it's the same underlying FSCI response either way, only tunneled
+        through CoAP. Confirmed necessary via real hardware testing
+        (a Radion light's FirmwareVersion response splitting across two
+        blocks) -- the same fix that motivated adding this to
+        MobiusDevice applies here for exactly the same reason; without a
+        matching override here, callers built on top of this method
+        (get_firmware_versions(), get_hardware_info(),
+        get_channel_power_info(), get_supported_channels()) would
+        silently fall through to MobiusDevice's own implementation when
+        called on a relayed device, which tries to use this instance's
+        (nonexistent) direct connection instead of relaying at all.
+        """
         payload = encode_get_attribute(attr_id, index, count, extended=False)
         inner_request_frame = build_frame(OPGROUP_C2CI_REQUEST, OPCODE_GET_ATTR, payload)
         inner = await self._relay(inner_request_frame)
 
-        # Matches get_attribute_raw()'s exact status-checking behavior on
-        # MobiusDevice -- relay doesn't change what counts as a valid
-        # response, only how the bytes got here.
         status = inner.data[0] if inner.data else FsciStatus.Failed
         if self.debug:
             print(f"    [relay debug] attr {attr_id}: status={status!r} "
@@ -271,10 +287,24 @@ class RelayedMobiusDevice(MobiusDevice):
         if self.debug:
             print(f"    [relay debug] attr {attr_id}: decoded {len(attrs)} attribute(s): "
                   f"{[(a.attr_id, a.index, [v.hex() for v in a.values]) for a in attrs]}")
-        for a in attrs:
-            if a.attr_id == attr_id:
-                return a
-        return None
+        return [a for a in attrs if a.attr_id == attr_id]
+
+    async def get_attribute_raw(self, attr_id: int, index: int = 0, count: int = 1) -> Optional[AttributeValue]:
+        """Returns only the FIRST matching block -- see
+        get_attribute_raw_all()'s docstring for why a relayed response
+        can have more than one, and use that instead if you need all of
+        them."""
+        all_matches = await self.get_attribute_raw_all(attr_id, index, count)
+        return all_matches[0] if all_matches else None
+
+    async def get_attribute_all(self, attr_id: int, index: int = 0, count: int = 1) -> list[bytes]:
+        """Merges values from every matching block -- see
+        get_attribute_raw_all()'s docstring."""
+        blocks = await self.get_attribute_raw_all(attr_id, index, count)
+        values: list[bytes] = []
+        for block in blocks:
+            values.extend(block.values)
+        return values
 
     async def get_attribute(self, attr_id: int, index: int = 0, count: int = 1) -> list[bytes]:
         raw = await self.get_attribute_raw(attr_id, index, count)

{python_mobius-0.2.0.dist-info → python_mobius-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-mobius
-Version: 0.2.0
+Version: 0.2.1
 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.2.0.dist-info → python_mobius-0.2.1.dist-info}/RECORD

@@ -1,9 +1,9 @@
-mobius/__init__.py,sha256=tyvUO4ImAlcND0wQnJ0aMmC4DPB3ZRZXNVBdqz93LC4,5334
+mobius/__init__.py,sha256=LxDxIbucDGqf1DhloOxCxeC8Ta2rYM0Sy3T2UGYkXKI,5334
 mobius/cli.py,sha256=s1zZa4P4rws-XRLLd1B_J67mjMbdImcfgNeDet44cYo,21494
 mobius/coap.py,sha256=n-_wBuSY88_c1TAjfXPZsPnpG0IcZZLFRjxTzd1c0Us,10859
 mobius/constants.py,sha256=rXaywY6WIK36HobZ1E3w-HfEWtZDCFzXqKbo4Bbe1V8,19259
 mobius/crc.py,sha256=WwIfUXGN_UKdsv-_Q303-L1-L1Rc1fvJnB5176ftzqU,2669
-mobius/device.py,sha256=f-B4q0IZlQl3C78mwLJLHQL5O-LcqzVUeYZ6dUiXe0I,65558
+mobius/device.py,sha256=GZ-Ucqt7lE_teOjXdHBf7DbgiTGtry88KwMr7a3NmHk,68859
 mobius/device_status.py,sha256=373a7BRGY1CoByLYkxTELAewkiSj4Wzm8yAilQrh0co,5812
 mobius/discovery.py,sha256=anJXZEwwhYwvQhFdYOwl6HGTrnMGUfb5CNg6H7Ah-iI,7737
 mobius/frame.py,sha256=zG2vh8PceJHD8R43MwZiJnm0Ge1dr8nFcKsJR9_c9LM,6135
@@ -12,10 +12,10 @@ mobius/mesh_address.py,sha256=PNUi3VyRQZCitB1R3IbzXCg1LcP6azSg1sigHAqaP7E,4942
 mobius/modifiers.py,sha256=pFNjGYX-_bNumNEpv3jJLYPCb9ZuSKYpQ0DDd2GmicQ,6451
 mobius/power.py,sha256=cZBpfYh2yg4xhmOQ0ILpACYdJSd7jMvSrhxat0yaH-g,3851
 mobius/pump_status.py,sha256=vqJXFAb16S-4oyzAzZIcwR5if7lXoTj67qwBJdbH1gI,1604
-mobius/relay.py,sha256=6fBNGUa43JBWY-ZVGKVXR45OgnR7qcFPGjURd0_tvB4,14683
+mobius/relay.py,sha256=YnIAtX0vHPPSazgRT_g8ocP2WJNyvW02JQOafabmsbM,16497
 mobius/schedule.py,sha256=kHr684TIKPZ2BplIySoeD-Yn1Xa_2bE6rfGUs-waWMQ,7483
-python_mobius-0.2.0.dist-info/METADATA,sha256=GOOfNmYXMp0wC-wbm6_L3MctCVQYhyPiasSSXPF4ddA,5959
-python_mobius-0.2.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-python_mobius-0.2.0.dist-info/entry_points.txt,sha256=Q2hlcek-bWm70zvd12v32essflPgC2su-dKDHAqbPoE,48
-python_mobius-0.2.0.dist-info/licenses/LICENSE,sha256=7a72Msu2Q-TnoiFxemxEGkwafJGObk1W3rw9hzmyM_Y,17984
-python_mobius-0.2.0.dist-info/RECORD,,
+python_mobius-0.2.1.dist-info/METADATA,sha256=EHtIqy5HkJRrHGzPnbgdpM4PoAPyTnqgJU3lKpTt56U,5959
+python_mobius-0.2.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+python_mobius-0.2.1.dist-info/entry_points.txt,sha256=Q2hlcek-bWm70zvd12v32essflPgC2su-dKDHAqbPoE,48
+python_mobius-0.2.1.dist-info/licenses/LICENSE,sha256=7a72Msu2Q-TnoiFxemxEGkwafJGObk1W3rw9hzmyM_Y,17984
+python_mobius-0.2.1.dist-info/RECORD,,