python-mobius 0.10.0__py3-none-any.whl → 0.10.2__py3-none-any.whl

mobius/__init__.py

@@ -87,7 +87,7 @@ from .mob import (
     MAX_PUMP_PRIMITIVE_SIZE,
 )
 
-__version__ = "0.10.0"
+__version__ = "0.10.2"
 
 __all__ = [
     "__version__",

mobius/device.py

@@ -169,26 +169,18 @@ def _schedule_checksum_attr(which: int) -> C2Attribute:
     return C2Attribute.Schedule1Checksum if which == 1 else C2Attribute.Schedule2Checksum
 
 
-def _configuration_requests(
+def _configuration_checksum_requests(
     configuration: tuple, cache: Optional[ConfigurationCache], supported_attribute_ids: set,
-) -> tuple[list, set]:
-    """
-    Poll requests for each (data attribute, checksum attribute) of
-    `configuration`: the checksum alone when `cache` holds the data, else
-    the data (plus the checksum, to store with it). Returns (requests,
-    data attributes requested).
-    """
-    requests, data_read = [], set()
-    for data_attr, checksum_attr in configuration:
-        checksum_usable = cache is not None and checksum_attr in supported_attribute_ids
-        if checksum_usable and data_attr in cache.entries:
-            requests.append((checksum_attr, 0, 1))
-            continue
-        requests.append((data_attr, 0, ALL_ELEMENTS))
-        data_read.add(data_attr)
-        if checksum_usable:
-            requests.append((checksum_attr, 0, 1))
-    return requests, data_read
+) -> list:
+    """The checksum request of each (data attribute, checksum attribute) of
+    `configuration` that the cache can use. The data itself is never part
+    of the poll batch (see _read_configuration())."""
+    if cache is None:
+        return []
+    return [
+        (checksum_attr, 0, 1) for _data_attr, checksum_attr in configuration
+        if checksum_attr in supported_attribute_ids
+    ]
 
 
 def _apply_static_cache(cache: ConfigurationCache, by_attr_id: dict, static_read: bool) -> None:
@@ -1850,7 +1842,7 @@ class MobiusDevice:
             return None
         return raw
 
-    async def discover_mesh_peers(self) -> list[MeshPeer]:
+    async def discover_mesh_peers(self, raise_errors: bool = False) -> list[MeshPeer]:
         """
         Mesh peers from the ShortAddressArray/SerialNumberArray/
         DeviceModelArray (3700/3701/3702) parallel arrays, with addresses
@@ -1860,10 +1852,12 @@ class MobiusDevice:
         UnsupportedAttribute and this returns []. Whether the connected
         device lists itself is not known. Empty slots (serial
         "00000000000000") and short entries are skipped. Returns [] on any
-        failure.
+        failure, or raises it with raise_errors=True.
         """
         own_address = await self.get_own_mesh_address()
         if own_address is None:
+            if raise_errors:
+                raise IOError("own mesh address (MeshLocalAddresses) not readable")
             return []
         prefix = mesh_local_prefix_from_own_address(own_address)
 
@@ -1872,6 +1866,8 @@ class MobiusDevice:
             models_raw = await self.get_attribute(C2Attribute.DeviceModelArray, index=0, count=ALL_ELEMENTS)
             shorts_raw = await self.get_attribute(C2Attribute.ShortAddressArray, index=0, count=ALL_ELEMENTS)
         except Exception:
+            if raise_errors:
+                raise
             return []
 
         peers: list[MeshPeer] = []
@@ -1890,7 +1886,7 @@ class MobiusDevice:
             ))
         return peers
 
-    async def discover_networked_thread_devices(self) -> list[MeshPeer]:
+    async def discover_networked_thread_devices(self, raise_errors: bool = False) -> list[MeshPeer]:
         """
         Every device on this device's Thread mesh, including itself, from
         MLPrefix (2128) and NetworkedThreadDevices (1001). Supported more
@@ -1904,7 +1900,8 @@ class MobiusDevice:
           12-13  model id, i16 LE
           14-27  serial, ASCII
         Empty slots are all zeros and are skipped, as are entries of any
-        other length. Returns [] on any failure.
+        other length. Returns [] on any failure, or raises it with
+        raise_errors=True.
         """
         try:
             mlprefix_raw = await self.get_attribute(C2Attribute.MLPrefix)
@@ -1912,8 +1909,15 @@ class MobiusDevice:
                 C2Attribute.NetworkedThreadDevices, index=0, count=ALL_ELEMENTS,
             )
         except Exception:
+            if raise_errors:
+                raise
             return []
         if not mlprefix_raw or len(mlprefix_raw[0]) != 24:
+            if raise_errors:
+                raise IOError(
+                    f"unexpected MLPrefix: {mlprefix_raw[0].hex() if mlprefix_raw else 'empty'} "
+                    f"(expected 24 bytes)"
+                )
             return []
         prefix = mesh_local_prefix_from_mlprefix(mlprefix_raw[0])
 
@@ -1936,18 +1940,35 @@ class MobiusDevice:
             ))
         return peers
 
-    async def discover_mesh_peers_auto(self) -> list[MeshPeer]:
+    async def discover_mesh_peers_auto(self, raise_errors: bool = False) -> list[MeshPeer]:
         """
         discover_networked_thread_devices(), falling back to
         discover_mesh_peers() when it finds nothing. The recommended entry
         point. mobius.discovery.discover_mesh_peers_via_direct_connect() is
         the remaining fallback, but it needs scan results and has to be
         called explicitly.
+
+        raise_errors=True: a failure raises instead of looking like an
+        empty mesh. The fallback is then only tried when
+        NetworkedThreadDevices can't be read (an MXM hub), and the error
+        raised names both attempts.
         """
-        peers = await self.discover_networked_thread_devices()
-        if peers:
-            return peers
-        return await self.discover_mesh_peers()
+        if not raise_errors:
+            peers = await self.discover_networked_thread_devices()
+            if peers:
+                return peers
+            return await self.discover_mesh_peers()
+
+        try:
+            return await self.discover_networked_thread_devices(raise_errors=True)
+        except Exception as networked_error:
+            try:
+                return await self.discover_mesh_peers(raise_errors=True)
+            except Exception as arrays_error:
+                raise IOError(
+                    f"NetworkedThreadDevices: {networked_error or type(networked_error).__name__}; "
+                    f"peer arrays: {arrays_error or type(arrays_error).__name__}"
+                ) from networked_error
 
     async def get_firmware_versions(self, model: Optional[Model] = None) -> dict:
         """{label: version} for every firmware component (FirmwareVersion,
@@ -2506,10 +2527,12 @@ class MobiusDevice:
         get_device_info(), get_metadata_batch() and
         get_light_poll_batch() or get_pump_schedule()/get_pump_telemetry().
 
-        `cache` (one per device, kept by the caller): ConfiguredScenes and
-        the schedule are then read only when their checksum changed since
-        the previous poll (see ConfigurationCache); a changed checksum
-        costs a second, smaller request. With its static_refresh_interval
+        The schedule and ConfiguredScenes are read in requests of their
+        own after the batch, as the app does: combined with the rest, a
+        light's reply is too large to be relayed. `cache` (one per device,
+        kept by the caller): they are then read only when their checksum,
+        part of the batch, changed since the previous poll (see
+        ConfigurationCache). With its static_refresh_interval
         set, the STATIC_POLL_ATTRIBUTES are also read only that often.
         Used by the batched path only.
         """
@@ -2537,7 +2560,7 @@ class MobiusDevice:
             (schedule_attr, _schedule_checksum_attr(which)),
             (C2Attribute.ConfiguredScenes, C2Attribute.ConfiguredScenesChecksum),
         )
-        configuration_requests, data_read = _configuration_requests(configuration, cache, supported_attribute_ids)
+        configuration_requests = _configuration_checksum_requests(configuration, cache, supported_attribute_ids)
         if cache is not None:
             configuration_requests.append((C2Attribute.SupportedAttributesCRC, 0, 1))
         requests = _DEVICE_INFO_REQUESTS + _METADATA_REQUESTS + configuration_requests + [
@@ -2558,9 +2581,7 @@ class MobiusDevice:
             )
             if attribute_table_changed:
                 cache.invalidate_static()
-            data_read |= await self._apply_configuration_cache(
-                by_attr_id, cache, configuration, data_read, supported_attribute_ids,
-            )
+        data_read = await self._read_configuration(by_attr_id, cache, configuration, supported_attribute_ids)
 
         def first(attr_id, index=0):
             return _first_value(by_attr_id, attr_id, index)
@@ -2621,38 +2642,44 @@ class MobiusDevice:
             static_read=static_read,
         )
 
-    async def _apply_configuration_cache(
-        self, by_attr_id: dict, cache: ConfigurationCache,
-        configuration: tuple, data_read: set, supported_attribute_ids: set,
+    async def _read_configuration(
+        self, by_attr_id: dict, cache: Optional[ConfigurationCache],
+        configuration: tuple, supported_attribute_ids: set,
     ) -> set:
         """
-        After the poll batch: stores data read with its checksum, fills in
-        cached data whose checksum is unchanged, and reads the rest in a
-        second batch. Returns the attributes read by that second batch.
+        Fills each data attribute of `configuration` (the schedule, the
+        scenes) into `by_attr_id`: from `cache` when the checksum in the
+        poll batch matches the cached one, else with a request of its own
+        (plus its checksum, stored in the cache with it). Returns the
+        attributes read.
+
+        Each gets its own request, as in the app: a light's schedule or
+        scenes alone are close to the largest reply a relay carries, and
+        together with the rest of the poll a relayed reply is too large
+        and never arrives.
         """
-        stale = []
+        read = set()
         for data_attr, checksum_attr in configuration:
-            if data_attr not in supported_attribute_ids or checksum_attr not in supported_attribute_ids:
+            if data_attr not in supported_attribute_ids:
                 continue
-            reported = _unpack(_first_value(by_attr_id, checksum_attr), "<H")
-            if data_attr in data_read:
-                _store_configuration(cache, data_attr, reported, by_attr_id)
-                continue
-            cached = cache.entries.get(data_attr)
-            if cached is not None and reported is not None and reported == cached[0]:
-                by_attr_id[data_attr] = cached[1]
-            else:
-                stale.append((data_attr, checksum_attr))
-        if not stale:
-            return set()
-        second = await self._read_supported_batch(
-            [r for data_attr, checksum_attr in stale for r in ((data_attr, 0, ALL_ELEMENTS), (checksum_attr, 0, 1))],
-            supported_attribute_ids,
-        )
-        for data_attr, checksum_attr in stale:
-            by_attr_id[data_attr] = second.get(data_attr, [])
-            _store_configuration(cache, data_attr, _unpack(_first_value(second, checksum_attr), "<H"), second)
-        return {data_attr for data_attr, _checksum_attr in stale}
+            checksum_usable = cache is not None and checksum_attr in supported_attribute_ids
+            if checksum_usable:
+                reported = _unpack(_first_value(by_attr_id, checksum_attr), "<H")
+                cached = cache.entries.get(data_attr)
+                if cached is not None and reported is not None and reported == cached[0]:
+                    by_attr_id[data_attr] = cached[1]
+                    continue
+            requests = [(data_attr, 0, ALL_ELEMENTS)]
+            if checksum_usable:
+                requests.append((checksum_attr, 0, 1))
+            response = await self._read_supported_batch(requests, supported_attribute_ids)
+            by_attr_id[data_attr] = response.get(int(data_attr), [])
+            if checksum_usable:
+                _store_configuration(
+                    cache, data_attr, _unpack(_first_value(response, checksum_attr), "<H"), response,
+                )
+            read.add(data_attr)
+        return read
 
     async def _get_full_poll_via_individual_reads(
         self, primitive: PrimitiveType, model: Optional[Model],

{python_mobius-0.10.0.dist-info → python_mobius-0.10.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-mobius
-Version: 0.10.0
+Version: 0.10.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.10.0.dist-info → python_mobius-0.10.2.dist-info}/RECORD

@@ -1,10 +1,10 @@
-mobius/__init__.py,sha256=4KhKL5RgHdYk77_OmINsr2YiWa1N1fTpDL4EI6J_3EY,8555
+mobius/__init__.py,sha256=ownwnGpQ6cybzgLY8bzjmBG4D7JOQ1bw_m9hMPMdvA8,8555
 mobius/checksums.py,sha256=PB9RqvaZu9AqfT6tU6NI2qbbZXrqaHUnow3Qi_6UFHs,5191
 mobius/cli.py,sha256=tyft0SzbuLgbmzps-Ym1hCzcr6A9D5MsALkg6o4ynBs,57876
 mobius/coap.py,sha256=-XV3kI4q-JoL8r0oLFNnHAdZAc_yUP-aICagKh-qbf4,4862
 mobius/constants.py,sha256=pcG9Su_b81pmMA_GxR41lZz9UM9BjtV0T6nuslMICko,41138
 mobius/crc.py,sha256=LOCHZe3a1UnR5thdpZ4S4SFP8BdmoMEnhDNiNMd0iJI,2508
-mobius/device.py,sha256=2WPsm-aJJdIDeypo_MQ6rpgI1NTljcOUC4lt04eISbQ,131678
+mobius/device.py,sha256=1awCx8TIzSFHHEnkGMbuItbpQtAt1DINdmSnLJqENWI,133014
 mobius/device_status.py,sha256=XclYijAknrgT8SdSW4XvyBemWHUQqw6UPE4tmwq6Yug,15658
 mobius/discovery.py,sha256=poNeXGekB44cpHOFbGyps9d4mwW_hJptmJODwSMTUSg,7176
 mobius/dump.py,sha256=eQBYoi8J6CxRd2ojgWK5QoB8z416oywLRTBnnh0pLwo,9253
@@ -19,8 +19,8 @@ mobius/relay.py,sha256=trGkWQSarwURF05gXHeb5jTJ9UvWbQGu8NarEP6sRqE,10107
 mobius/scenes.py,sha256=VLfDdTKSv3qTsBt2bJGg8iPtUkfNEmNgu0TTtYT6jJE,4274
 mobius/schedule.py,sha256=si9uJdYOj5vh6owuxxMyMyZRY0-tAmCPt3s6ROAeRww,13243
 mobius/timezone.py,sha256=Q7oPKtCdEYcEHXLx4lt-VPq6KH-MNgQwVnDtIXJV-kQ,2267
-python_mobius-0.10.0.dist-info/METADATA,sha256=fGt7VhAS5SQAA7lmw5E90nBAnbQMscCgT5WHOB6fLtg,5829
-python_mobius-0.10.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-python_mobius-0.10.0.dist-info/entry_points.txt,sha256=Q2hlcek-bWm70zvd12v32essflPgC2su-dKDHAqbPoE,48
-python_mobius-0.10.0.dist-info/licenses/LICENSE,sha256=7a72Msu2Q-TnoiFxemxEGkwafJGObk1W3rw9hzmyM_Y,17984
-python_mobius-0.10.0.dist-info/RECORD,,
+python_mobius-0.10.2.dist-info/METADATA,sha256=O31L0MYu8ryhtqYYdQoXfTE9B23dqI4H2OJrWVH5EZI,5829
+python_mobius-0.10.2.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+python_mobius-0.10.2.dist-info/entry_points.txt,sha256=Q2hlcek-bWm70zvd12v32essflPgC2su-dKDHAqbPoE,48
+python_mobius-0.10.2.dist-info/licenses/LICENSE,sha256=7a72Msu2Q-TnoiFxemxEGkwafJGObk1W3rw9hzmyM_Y,17984
+python_mobius-0.10.2.dist-info/RECORD,,