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

mobius/__init__.py

@@ -64,6 +64,12 @@ from .mesh_address import (
     is_short_address_derived, format_mesh_address,
 )
 from .relay import RelayedMobiusDevice
+from .device import firmware_label
+from .firmware import (
+    FIRMWARE_CLOUD_HOST, ImageId, FirmwareImage, installable_images, firmware_images,
+    firmware_check_url, AvailableFirmware, FirmwareCheck, parse_firmware_check,
+    ChangelogEntry, Changelog, parse_changelog, version_tuple,
+)
 from .device import (
     MobiusDevice, MobiusPump, LightIntensityResult, LightPollResult, FullPollResult,
     schedule_capacity, min_schedule_capacity, tank_group,
@@ -87,7 +93,7 @@ from .mob import (
     MAX_PUMP_PRIMITIVE_SIZE,
 )
 
-__version__ = "0.10.2"
+__version__ = "0.11.0"
 
 __all__ = [
     "__version__",
@@ -113,6 +119,10 @@ __all__ = [
     "supported_pump_modes",
     "get_pump_reverse",
     "FirmwareType", "FIRMWARE_TYPE_LABELS_ETM", "HardwareInfo",
+    # firmware
+    "firmware_label", "FIRMWARE_CLOUD_HOST", "ImageId", "FirmwareImage", "installable_images", "firmware_images",
+    "firmware_check_url", "AvailableFirmware", "FirmwareCheck", "parse_firmware_check",
+    "ChangelogEntry", "Changelog", "parse_changelog", "version_tuple",
     "Color", "COLOR_LABELS", "RadioType", "RADIO_TYPE_LABELS",
     "MotorType", "MOTOR_TYPE_LABELS", "ProductType", "PRODUCT_TYPE_LABELS",
     # schedule

mobius/device.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 import asyncio
 import datetime
 import struct
+import logging
 import time
 from dataclasses import dataclass, field
 from typing import Optional, Callable, Any
@@ -67,6 +68,7 @@ from .mesh_address import (
 from .coap import decode_coap_response, CoapResponse, COAP_INDICATION_OPCODE
 from .discovery import find_device_by_serial
 from .timezone import encode_time_zone_field, posix_tz_string
+from .firmware import firmware_images, installable_images
 
 # --------------------------------------------------------------------------
 # GATT UUIDs (service 01ff0100-...; four characteristics under it)
@@ -79,6 +81,8 @@ CHAR_TX_DATA = "01ff0103-ba5e-f4ee-5ca1-eb1e5e4b1ce0"   # write: app -> device,
 CHAR_TX_FINAL = "01ff0104-ba5e-f4ee-5ca1-eb1e5e4b1ce0"  # write: app -> device, last fragment
 
 # count=0xFFFF requests every element of a list attribute.
+_LOGGER = logging.getLogger(__name__)
+
 ALL_ELEMENTS = 0xFFFF
 
 # Write fragment size when the ATT MTU is unknown or the minimum (23).
@@ -87,6 +91,23 @@ DEFAULT_WRITE_SIZE = 20
 MTU_WRITE_OVERHEAD = 5
 
 
+def _log_bad_frame(raw: bytes, frame, trace: list[tuple[str, int]]) -> None:
+    """Debug details of a received frame that doesn't parse or fails its
+    CRC: what was received against what its header declares, and the
+    notifications it was assembled from (D = RX_DATA, F = RX_FINAL)."""
+    if not _LOGGER.isEnabledFor(logging.DEBUG):
+        return
+    declared = struct.unpack_from("<H", raw, 7)[0] + 11 if len(raw) >= 9 else None
+    pieces = " ".join(f"{kind}{length}" for kind, length in trace)
+    _LOGGER.debug(
+        "Received a frame that %s: %d bytes, header declares %s; op_group=%s op_code=%s msg_id=%s; "
+        "%d notifications [%s]; first bytes %s; last bytes %s",
+        "doesn't parse" if frame is None else "fails its CRC", len(raw), declared,
+        f"{frame.op_group:#04x}" if frame else "?", frame.op_code if frame else "?",
+        frame.message_id if frame else "?", len(trace), pieces, raw[:24].hex(), raw[-24:].hex(),
+    )
+
+
 def write_size_for_mtu(att_mtu: Optional[int]) -> int:
     """Write fragment size for a negotiated ATT MTU: `att_mtu` minus 5, as
     the app does, or DEFAULT_WRITE_SIZE when it is unknown or not above the
@@ -482,14 +503,10 @@ def _indexed_values(blocks: list[AttributeValue]):
             yield block.index + i, value
 
 
-def decode_firmware_version_blocks(blocks: list[AttributeValue], model: Optional[Model] = None) -> dict:
-    """
-    {label: "a.b.c"} from FirmwareVersion (1) blocks. Each element's index is
-    its FirmwareType; each version is its bytes joined with dots. Labels come
-    from FIRMWARE_TYPE_LABELS_ETM for EcoTech Marine models and
-    FIRMWARE_TYPE_LABELS_NON_ETM for other known manufacturers, falling back
-    to the FirmwareType name.
-    """
+def firmware_label(firmware_type: FirmwareType, model: Optional[Model] = None) -> str:
+    """Display label of a firmware component: FIRMWARE_TYPE_LABELS_ETM for
+    EcoTech Marine models, FIRMWARE_TYPE_LABELS_NON_ETM for other known
+    manufacturers, else (or when unlabelled) the FirmwareType name."""
     manufacturer = manufacturer_for_model(model) if model is not None else None
     if manufacturer == "EcoTech Marine":
         labels = FIRMWARE_TYPE_LABELS_ETM
@@ -497,16 +514,49 @@ def decode_firmware_version_blocks(blocks: list[AttributeValue], model: Optional
         labels = FIRMWARE_TYPE_LABELS_NON_ETM
     else:
         labels = {}
+    return labels.get(firmware_type, firmware_type.name)
 
+
+def decode_firmware_versions_by_type(blocks: list[AttributeValue]) -> dict:
+    """{FirmwareType: "a.b.c"} from FirmwareVersion (1) blocks. Each
+    element's index is its FirmwareType; each version is its bytes joined
+    with dots."""
     result = {}
     for index, value_bytes in _indexed_values(blocks):
         fw_type = enum_or_none(FirmwareType, index)
-        if not value_bytes or fw_type is None:
-            continue
-        result[labels.get(fw_type, fw_type.name)] = ".".join(str(b) for b in value_bytes)
+        if value_bytes and fw_type is not None:
+            result[fw_type] = ".".join(str(b) for b in value_bytes)
     return result
 
 
+def decode_firmware_version_blocks(blocks: list[AttributeValue], model: Optional[Model] = None) -> dict:
+    """
+    {label: "a.b.c"} from FirmwareVersion (1) blocks, labelled with
+    firmware_label(). Components sharing a label keep the last one; see
+    decode_firmware_versions_by_type() for every component.
+    """
+    return {
+        firmware_label(fw_type, model): version
+        for fw_type, version in decode_firmware_versions_by_type(blocks).items()
+    }
+
+
+def decode_radio_type(blocks: list[AttributeValue]) -> Optional[RadioType]:
+    """HardwareInfo.RadioType from HardwareRevision (2) blocks, None if not
+    reported or unknown."""
+    for index, value_bytes in _indexed_values(blocks):
+        if index == HardwareInfo.RadioType and value_bytes:
+            return enum_or_none(RadioType, int.from_bytes(value_bytes, byteorder="little", signed=False))
+    return None
+
+
+def decode_firmware_images(firmware_blocks: list[AttributeValue], hardware_blocks: list[AttributeValue],
+                           model: Optional[Model]) -> list:
+    """[FirmwareImage] the cloud can be asked about (see firmware.py)."""
+    return firmware_images(model, decode_firmware_versions_by_type(firmware_blocks),
+                           decode_radio_type(hardware_blocks))
+
+
 def decode_hardware_revision_blocks(blocks: list[AttributeValue]) -> dict:
     """
     {HardwareInfo name: value} from HardwareRevision (2) blocks. Each
@@ -657,6 +707,9 @@ def decode_metadata_from_batch(by_attr_id: dict, model: Optional[Model]) -> Meta
         ),
         hardware_info=decode_hardware_revision_blocks(by_attr_id.get(C2Attribute.HardwareRevision, [])),
         firmware_versions=decode_firmware_version_blocks(by_attr_id.get(C2Attribute.FirmwareVersion, []), model),
+        firmware_images=decode_firmware_images(
+            by_attr_id.get(C2Attribute.FirmwareVersion, []), by_attr_id.get(C2Attribute.HardwareRevision, []), model,
+        ),
         supported_channels=decode_supported_channels(_values_for(by_attr_id, C2Attribute.SupportedColorChannels)),
         error_state=decode_error_state(first(C2Attribute.ErrorState)),
         epoch=_unpack(first(C2Attribute.Epoch), "<I"),
@@ -917,6 +970,9 @@ class MobiusDevice:
         self.adapter = adapter
         self._client: Optional[BleakClient] = None
         self._rx_buffer = bytearray()
+        # ("D"/"F", length) of each notification of the frame being
+        # received, logged when it fails its CRC.
+        self._rx_trace: list[tuple[str, int]] = []
         # Pending direct requests, keyed by FSCI message ID.
         self._pending: dict[int, asyncio.Future] = {}
         # Pending relayed requests, keyed by CoAP token (see mobius.relay).
@@ -1014,12 +1070,18 @@ class MobiusDevice:
 
     def _on_rx_data(self, _handle, data: bytearray):
         self._rx_buffer.extend(data)
+        self._rx_trace.append(("D", len(data)))
 
     def _on_rx_final(self, _handle, data: bytearray):
         self._rx_buffer.extend(data)
+        self._rx_trace.append(("F", len(data)))
         raw = bytes(self._rx_buffer)
+        trace = self._rx_trace
         self._rx_buffer.clear()
+        self._rx_trace = []
         frame = parse_frame(raw)
+        if frame is None or not frame.crc_ok:
+            _log_bad_frame(raw, frame, trace)
         if frame is None:
             return
         if self.on_any_frame is not None:
@@ -1729,6 +1791,7 @@ class MobiusDevice:
             calibration=await soft(self.get_calibration_info(), None),
             hardware_info=await soft(self.get_hardware_info(), {}),
             firmware_versions=await soft(self.get_firmware_versions(model=model), {}),
+            firmware_images=await soft(self.get_firmware_images(model=model), []),
             supported_channels=await soft(self.get_supported_channels(), []),
             error_state=decode_error_state(await self._try_first(C2Attribute.ErrorState)),
             epoch=await self._try_unpack(C2Attribute.Epoch, "<I"),
@@ -1979,6 +2042,18 @@ class MobiusDevice:
             return {}
         return decode_firmware_version_blocks(blocks, model)
 
+    async def get_firmware_images(self, model: Optional[Model] = None) -> list:
+        """[FirmwareImage] the cloud can be asked about for updates (see
+        firmware.py). [] on failure or for models without updates."""
+        if not installable_images(model):
+            return []
+        try:
+            firmware_blocks = await self.get_attribute_raw_all(C2Attribute.FirmwareVersion, index=0, count=ALL_ELEMENTS)
+            hardware_blocks = await self.get_attribute_raw_all(C2Attribute.HardwareRevision, index=0, count=ALL_ELEMENTS)
+        except Exception:
+            return []
+        return decode_firmware_images(firmware_blocks, hardware_blocks, model)
+
     async def get_hardware_info(self) -> dict:
         """HardwareRevision sub-fields (all elements). See
         decode_hardware_revision_blocks(). {} on failure."""

mobius/device_status.py

@@ -5,7 +5,7 @@ value has not been established.
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Optional
 
 from .constants import Model
@@ -420,6 +420,8 @@ time zone strings.
     # PosixTimeZoneString / OlsonTimeZoneLocation (205 / 206).
     posix_tz: Optional[str] = None
     olson_tz: Optional[str] = None
+    # [FirmwareImage] the cloud can be asked about for updates (firmware.py).
+    firmware_images: list = field(default_factory=list)
 
 
 @dataclass

mobius/firmware.py

@@ -0,0 +1,242 @@
+"""
+Firmware update checks against the Mobius cloud, as the app does them.
+
+The app checks each firmware part a model can install (its "image") with
+
+    GET https://cloud.mobius.app/firmware/mobius/check?version=<installed>&image=<ImageId>&format=json
+
+No login is needed. The reply always has "interval" (minutes before the
+app checks the same image and version again); when a newer firmware exists
+it also has "url", "version", "md5", "changelog" (a URL to a JSON
+changelog), "install", "reset" and "id".
+
+This module only builds the URLs and parses the replies: fetching them is
+left to the caller. Installing firmware is not supported.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import IntEnum
+from typing import Optional
+from urllib.parse import urlencode
+
+from .constants import FirmwareType, Model, RadioType
+
+
+FIRMWARE_CLOUD_HOST = "cloud.mobius.app"
+
+
+class ImageId(IntEnum):
+    """Firmware image the cloud is asked about (the app's M.ImageId)."""
+    Unknown = 0
+    RfModuleKw41 = 1
+    QuietDriveDriver = 2
+    RadionDriverKl26 = 3
+    AiPumpKw41 = 4
+    DosingPumpKw41 = 5
+    AiLightQCA4020 = 6
+    DosingPumpBaseStation = 7
+    RadionQCA4020 = 8
+    Chalupa = 9
+    RfModuleK32w = 10
+    AiLightQCA4024 = 11
+    RadionQCA4024 = 12
+    Saddle = 13
+    Cowboy = 14
+    Muffler = 15
+    Coffee = 16
+    Alfalfa = 17
+    CrunchyTaco = 18
+    SoftTaco = 19
+
+
+_KL26_RADIONS = frozenset({
+    Model.RadionXR30w, Model.RadionXR30wG2, Model.RadionXR30wPro, Model.RadionXR30wG3,
+    Model.RadionXR30wG3Pro, Model.RadionXR30wG4, Model.RadionXR30wG4Pro, Model.RadionXR30wFWPro,
+    Model.RadionXR30wPrototype, Model.RadionXR15wG3Pro, Model.RadionXR15wFW, Model.RadionXR15wG4Pro,
+    Model.RadionXR15wFWPro,
+})
+_QUIETDRIVE_PUMPS = frozenset({
+    Model.VectraS1, Model.VectraM1, Model.VectraL1, Model.VectraS2, Model.VectraM2, Model.VectraL2,
+    Model.VorTechMP10wQD, Model.VorTechMP40wQD, Model.VorTechMP60wQD, Model.VorTechMP40wG3QD,
+    Model.VorTechMP10wES,
+})
+_QCA_HYDRAS = frozenset({
+    Model.Hydra32HDFreshwater, Model.PrimeSixteenHD, Model.HydraThirtyTwoHD, Model.HydraSixtyFourHD,
+    Model.PrimeSixteenHdFuge, Model.PrimeSixteenHdFw, Model.PrimeSixteenHdSol,
+})
+_QCA_RADIONS = frozenset({
+    Model.RadionXR15wG5Blue, Model.RadionXR15wG5FW, Model.RadionXR30wG5Blue, Model.RadionXR30wG5FW,
+    Model.RadionXR30wG5Pro, Model.RadionXR15wPrototype, Model.RadionXR15G5Pro, Model.RadionXR30wG6Pro,
+    Model.RadionXR30wG6Blue, Model.RadionXR15wG6Pro, Model.RadionXR15wG6Blue,
+})
+_AI_PUMPS = frozenset({
+    Model.Nero5, Model.Nero3, Model.Nero7, Model.Axis20, Model.Axis40, Model.Axis90, Model.Axis200,
+    Model.Orbit2, Model.Orbit4,
+})
+_SINGLE_IMAGE_MODELS: dict = {
+    Model.SproutSL1: (FirmwareType.QCA4020Firmware, ImageId.Chalupa),
+    **{m: (FirmwareType.Esp32C3Firmware, ImageId.Saddle) for m in (
+        Model.Blade, Model.BladeD, Model.BladeCoralGlow, Model.BladeCoralGrow, Model.BladeFreshwater,
+        Model.BladeRefugium, Model.BladeGrowPlus, Model.BladeGloFish,
+    )},
+    Model.DoseQD: (FirmwareType.Esp32H2Firmware, ImageId.Muffler),
+    Model.Quantum160: (FirmwareType.Esp32H2Firmware, ImageId.Coffee),
+    Model.Quantum220300: (FirmwareType.Esp32H2Firmware, ImageId.Coffee),
+    **{m: (FirmwareType.Esp32C6Firmware, ImageId.Alfalfa) for m in (
+        Model.HydraEdge44HD, Model.HydraEdge68HD, Model.HydraEdge44HDFreshwater, Model.HydraEdge68HDFreshwater,
+    )},
+    Model.Hera: (FirmwareType.Esp32S3Firmware, ImageId.CrunchyTaco),
+    Model.HeraBackplane: (FirmwareType.Esp32C6Firmware, ImageId.SoftTaco),
+    **{m: (FirmwareType.OS, ImageId.AiPumpKw41) for m in _AI_PUMPS},
+    Model.MXM: (FirmwareType.OS, ImageId.Cowboy),
+}
+
+
+def installable_images(model: Optional[Model], radio_type: Optional[RadioType] = None) -> list:
+    """[(FirmwareType, ImageId)] the app can update on a model, in the
+    app's order. Some models depend on their radio (HardwareInfo
+    RadioType). [] for models the app has no updates for."""
+    if model in _KL26_RADIONS:
+        return [(FirmwareType.OS, ImageId.RfModuleKw41), (FirmwareType.MainMicroOS, ImageId.RadionDriverKl26)]
+    if model in _QUIETDRIVE_PUMPS:
+        radio = ImageId.RfModuleK32w if radio_type == RadioType.K32W else ImageId.RfModuleKw41
+        return [(FirmwareType.OS, radio), (FirmwareType.MainMicroOS, ImageId.QuietDriveDriver)]
+    if model in _QCA_HYDRAS:
+        image = ImageId.AiLightQCA4024 if radio_type == RadioType.QCA4024 else ImageId.AiLightQCA4020
+        return [(FirmwareType.QCA4020Firmware, image)]
+    if model in _QCA_RADIONS:
+        image = ImageId.RadionQCA4024 if radio_type == RadioType.QCA4024 else ImageId.RadionQCA4020
+        return [(FirmwareType.QCA4020Firmware, image)]
+    if model == Model.VersaVX1:
+        return [(FirmwareType.OS, ImageId.DosingPumpKw41),
+                (FirmwareType.XMC1402Firmware, ImageId.DosingPumpBaseStation)]
+    single = _SINGLE_IMAGE_MODELS.get(model)
+    return [single] if single else []
+
+
+@dataclass(frozen=True)
+class FirmwareImage:
+    """One updatable firmware part of a device and its installed version."""
+    firmware_type: FirmwareType
+    image_id: ImageId
+    version: str
+
+
+def firmware_images(model: Optional[Model], versions_by_type: dict,
+                    radio_type: Optional[RadioType] = None) -> list:
+    """[FirmwareImage] for the parts of installable_images() the device
+    reports a version for ({FirmwareType: "a.b.c"}, see
+    decode_firmware_versions_by_type())."""
+    return [
+        FirmwareImage(firmware_type, image_id, versions_by_type[firmware_type])
+        for firmware_type, image_id in installable_images(model, radio_type)
+        if versions_by_type.get(firmware_type)
+    ]
+
+
+def firmware_check_url(image_id: ImageId, version: str, host: str = FIRMWARE_CLOUD_HOST) -> str:
+    """URL the app checks for a newer firmware of `image_id`."""
+    query = urlencode({"version": version, "image": int(image_id), "format": "json"})
+    return f"https://{host}/firmware/mobius/check?{query}"
+
+
+@dataclass(frozen=True)
+class AvailableFirmware:
+    """A newer firmware offered by the cloud."""
+    version: str
+    url: str
+    changelog_url: Optional[str] = None
+    md5: Optional[str] = None
+    install: bool = False
+    reset: bool = False
+    id: Optional[int] = None
+
+
+@dataclass(frozen=True)
+class FirmwareCheck:
+    """A parsed check reply: `update` is None when the installed version is
+    the latest. `interval` is how long (seconds) the app waits before
+    checking the same image and version again, None if not given."""
+    update: Optional[AvailableFirmware]
+    interval: Optional[int]
+
+
+def parse_firmware_check(data: dict) -> FirmwareCheck:
+    """Parses a check reply (the JSON object). Raises ValueError if it isn't
+    a JSON object."""
+    if not isinstance(data, dict):
+        raise ValueError(f"firmware check reply is not an object: {data!r}")
+    interval = data.get("interval")
+    interval = int(interval) * 60 if isinstance(interval, (int, float)) else None
+    url, version = data.get("url"), data.get("version")
+    if not url or not version:
+        return FirmwareCheck(None, interval)
+    firmware_id = data.get("id")
+    return FirmwareCheck(AvailableFirmware(
+        version=str(version),
+        url=str(url),
+        changelog_url=data.get("changelog") or None,
+        md5=data.get("md5") or None,
+        install=bool(data.get("install")),
+        reset=bool(data.get("reset")),
+        id=firmware_id if isinstance(firmware_id, int) else None,
+    ), interval)
+
+
+@dataclass(frozen=True)
+class ChangelogEntry:
+    """One version of a firmware changelog."""
+    version: str
+    changes: list = field(default_factory=list)  # list[str]
+    alerts: list = field(default_factory=list)   # list[str]
+
+
+@dataclass(frozen=True)
+class Changelog:
+    """A firmware changelog (the reply's "changelog" URL), newest first as
+    published."""
+    current_version: Optional[str]
+    entries: list  # list[ChangelogEntry]
+    alerts: list = field(default_factory=list)  # list[str]
+
+    def newer_than(self, version: str) -> list:
+        """Entries for versions newer than `version`. All entries if either
+        version can't be compared."""
+        installed = version_tuple(version)
+        if installed is None:
+            return list(self.entries)
+        newer = []
+        for entry in self.entries:
+            entry_version = version_tuple(entry.version)
+            if entry_version is None or entry_version > installed:
+                newer.append(entry)
+        return newer
+
+
+def _texts(items) -> list:
+    return [str(item["text"]) for item in items or [] if isinstance(item, dict) and item.get("text")]
+
+
+def parse_changelog(data: dict) -> Changelog:
+    """Parses a changelog JSON object ({"current_version", "change_list":
+    [{"version", "changes": [{"text"}], "alerts": [{"text"}]}], "alerts"}).
+    Raises ValueError if it isn't a JSON object."""
+    if not isinstance(data, dict):
+        raise ValueError(f"changelog is not an object: {data!r}")
+    entries = [
+        ChangelogEntry(str(item.get("version", "")), _texts(item.get("changes")), _texts(item.get("alerts")))
+        for item in data.get("change_list") or [] if isinstance(item, dict)
+    ]
+    current = data.get("current_version")
+    return Changelog(str(current) if current else None, entries, _texts(data.get("alerts")))
+
+
+def version_tuple(version: str) -> Optional[tuple]:
+    """(3, 0, 35) from "3.0.35" (the app also accepts "-" as a separator).
+    None if a part isn't a number."""
+    try:
+        return tuple(int(part) for part in str(version).replace("-", ".").split("."))
+    except ValueError:
+        return None

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-mobius
-Version: 0.10.2
+Version: 0.11.0
 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
@@ -65,6 +65,8 @@ implement it in another language.
 - **Batched polling**: everything a poll needs in one request.
 - **Diagnostics**: attribute dumps, firmware and hardware information,
   Thread and clock diagnostics.
+- **Firmware update checks**: which firmware images to ask the Mobius cloud
+  about and parsing its replies and changelogs (installing is not supported).
 - **`mobius-scan`** command line tool.
 
 ## Supported devices

{python_mobius-0.10.2.dist-info → python_mobius-0.11.0.dist-info}/RECORD

@@ -1,13 +1,14 @@
-mobius/__init__.py,sha256=ownwnGpQ6cybzgLY8bzjmBG4D7JOQ1bw_m9hMPMdvA8,8555
+mobius/__init__.py,sha256=HxhUUJCjvLh_q8Sz6RwOBI8_DXY8F6EZXlbM1Rlmaco,9133
 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=1awCx8TIzSFHHEnkGMbuItbpQtAt1DINdmSnLJqENWI,133014
-mobius/device_status.py,sha256=XclYijAknrgT8SdSW4XvyBemWHUQqw6UPE4tmwq6Yug,15658
+mobius/device.py,sha256=3UmGI4txfp_gOCM3nonahXcYNwBLzicOzqFBtksumis,136823
+mobius/device_status.py,sha256=JhJQreluRAP6Ow2M187RDrPyATEsQAAETpL_d-dLhQQ,15799
 mobius/discovery.py,sha256=poNeXGekB44cpHOFbGyps9d4mwW_hJptmJODwSMTUSg,7176
 mobius/dump.py,sha256=eQBYoi8J6CxRd2ojgWK5QoB8z416oywLRTBnnh0pLwo,9253
+mobius/firmware.py,sha256=TuUcJxv2A6Lrpz5qfZvXDVC_-06GRPNCjG0MG1_UH-M,9693
 mobius/frame.py,sha256=hO7nc1Rn0HqsIIZP6KZXj0n91J7LA5SfBoQcu_PNKvQ,7852
 mobius/manufacturer.py,sha256=WNpU1f69rrroJQdWhEw-ROw1dtPH7Rbn7IBEtGKLxqE,2382
 mobius/mesh_address.py,sha256=hNpijfuzJFmfpmndjeSAqefr6mY4oZ4hQEXNvYjy4mY,3435
@@ -19,8 +20,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.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,,
+python_mobius-0.11.0.dist-info/METADATA,sha256=pruuXYoAVOF91RncSpReYkt_zTGXwf0-q2h_00McBvM,5983
+python_mobius-0.11.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+python_mobius-0.11.0.dist-info/entry_points.txt,sha256=Q2hlcek-bWm70zvd12v32essflPgC2su-dKDHAqbPoE,48
+python_mobius-0.11.0.dist-info/licenses/LICENSE,sha256=7a72Msu2Q-TnoiFxemxEGkwafJGObk1W3rw9hzmyM_Y,17984
+python_mobius-0.11.0.dist-info/RECORD,,

{python_mobius-0.10.2.dist-info → python_mobius-0.11.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.32.4
+Generator: hatchling 1.33.0
 Root-Is-Purelib: true
 Tag: py3-none-any