python-mobius 0.4.4__py3-none-any.whl → 0.5.0__py3-none-any.whl

mobius/__init__.py

@@ -35,7 +35,7 @@ from .schedule import (
     LightPrimitive, SchedulePoint, interpolate_light_schedule,
     PumpPrimitiveValue, PumpSchedulePoint, get_active_pump_block,
 )
-from .manufacturer import MOBIUS_COMPANY_ID, MobiusAdvertisement, parse_manufacturer_data
+from .manufacturer import MOBIUS_COMPANY_ID_ECOTECH, MOBIUS_COMPANY_ID_AQUAILLUMINATION, MOBIUS_COMPANY_IDS, MobiusAdvertisement, parse_manufacturer_data
 from .modifiers import (
     AcclimationInfo, is_night_segment,
     julian_day_from_date, lunar_days_into_phase, lunar_percent_reduction,
@@ -43,7 +43,7 @@ from .modifiers import (
 )
 from .power import ChannelPowerInfo, channel_percent_value
 from .pump_status import PumpFlowRange, BatteryBackupInfo, BoostedBatteryInfo
-from .device_status import GroupInfo, CalibrationInfo, MaintenanceInfo, DeviceTimeInfo, MeshPeer, Tank
+from .device_status import GroupInfo, CalibrationInfo, AdvancedFeatures, VectraInfo, CoffeeInfo, MaintenanceInfo, DeviceTimeInfo, MeshPeer, Tank, LunarPhaseInfo
 from .coap import (
     CoapRequestType, CoapMethod, CoapResponseCode, CoapResponse,
     encode_coap_request, decode_coap_response, COAP_OPCODE, COAP_INDICATION_OPCODE,
@@ -65,7 +65,7 @@ from .discovery import (
     discover_tank,
 )
 
-__version__ = "0.4.4"
+__version__ = "0.5.0"
 
 __all__ = [
     "__version__",
@@ -93,7 +93,7 @@ __all__ = [
     "LightPrimitive", "SchedulePoint", "interpolate_light_schedule",
     "PumpPrimitiveValue", "PumpSchedulePoint", "get_active_pump_block",
     # manufacturer
-    "MOBIUS_COMPANY_ID", "MobiusAdvertisement", "parse_manufacturer_data",
+    "MOBIUS_COMPANY_ID_ECOTECH", "MOBIUS_COMPANY_ID_AQUAILLUMINATION", "MOBIUS_COMPANY_IDS", "MobiusAdvertisement", "parse_manufacturer_data",
     # modifiers
     "AcclimationInfo", "is_night_segment",
     "julian_day_from_date", "lunar_days_into_phase", "lunar_percent_reduction",
@@ -103,7 +103,7 @@ __all__ = [
     # pump_status
     "PumpFlowRange", "BatteryBackupInfo", "BoostedBatteryInfo",
     # device_status
-    "GroupInfo", "CalibrationInfo", "MaintenanceInfo", "DeviceTimeInfo", "MeshPeer", "Tank",
+    "GroupInfo", "CalibrationInfo", "AdvancedFeatures", "VectraInfo", "CoffeeInfo", "MaintenanceInfo", "DeviceTimeInfo", "MeshPeer", "Tank", "LunarPhaseInfo",
     "CoapRequestType", "CoapMethod", "CoapResponseCode", "CoapResponse",
     "encode_coap_request", "decode_coap_response", "COAP_OPCODE", "COAP_INDICATION_OPCODE",
     "next_coap_token",

mobius/cli.py

@@ -60,10 +60,27 @@ async def _dump_schedule(device: MobiusDevice, support: str) -> None:
             print(f"    {_format_time(point.time_minutes)}{_format_flags(point)}: {channels}")
 
         lunar_enabled = await device.get_lunar_enabled()
+        print(f"  lunar_enabled: {lunar_enabled}")
+
+        # The device's own firmware-computed lunar state -- see
+        # LunarPhaseInfo's own docstring in device_status.py for the
+        # confirmation and what this is useful for. Compare against
+        # "current_intensities"/"light_diagnostics" in the summary
+        # output above (NOT re-fetched here -- get_device_summary()
+        # already called get_current_light_intensities() once; a
+        # second call here would just be a redundant device read of
+        # the exact same thing). A real failure is shown directly
+        # (get_lunar_phase_info() no longer swallows it) rather than
+        # printing an indistinguishable "None".
+        try:
+            lunar_phase_info = await device.get_lunar_phase_info()
+            print(f"  lunar_phase_info: {lunar_phase_info}")
+        except Exception as e:
+            print(f"  lunar_phase_info: read failed: {e}")
+
         insolation_active = await device.get_insolation_enabled()
         schedule_intensity = await device.get_schedule_intensity()
         acclimation = await device.get_acclimation_info()
-        print(f"  lunar_enabled: {lunar_enabled}")
         print(f"  insolation_active: {insolation_active}")
         print(f"  schedule_intensity: {schedule_intensity}")
         print(f"  acclimation: {acclimation}")
@@ -241,7 +258,14 @@ async def _run(args) -> None:
         device, info = found
         print(f"  currently at {device.address}  model={info.model.name if info.model else info.model_raw}")
         try:
-            async with MobiusDevice(serial=args.by_serial, adapter=args.adapter,
+            # device= is the exact BLEDevice found_device_by_serial() just
+            # located above -- passing it avoids a second, independent scan
+            # inside connect() (see MobiusDevice.__init__()'s own docstring:
+            # re-scanning per device can cause BlueZ to drop it between
+            # "found" and "connect", the exact failure this fixes). serial=
+            # is still passed alongside it, for this same instance's own
+            # reconnect logic if the connection drops later in this run.
+            async with MobiusDevice(device=device, serial=args.by_serial, adapter=args.adapter,
                                      connect_timeout=args.connect_timeout) as mdevice:
                 summary = await mdevice.get_device_summary()
                 for k, v in summary.items():
@@ -249,6 +273,7 @@ async def _run(args) -> None:
                 if args.dump_schedule:
                     await _dump_schedule(mdevice, summary.get("support", ""))
 
+                relayed = None  # set below only if --relay-target resolves successfully
                 if args.dump_mesh_peers or args.relay_target:
                     print("\n=== Thread mesh peer discovery ===")
                     peers = await _debug_mesh_discovery(mdevice)
@@ -314,6 +339,47 @@ async def _run(args) -> None:
                                   f"`--by-serial {args.relay_target}` run to confirm they match.")
                         except Exception as e:
                             print(f"  relay failed: {e}")
+
+                if args.reboot:
+                    # If --relay-target was also given, reboot THAT device
+                    # via relay through the connected one, instead of the
+                    # directly-connected device itself -- lets both the
+                    # direct and relayed write paths get tested with the
+                    # same flag, without a separate one. If relay resolution
+                    # above failed, this deliberately does NOT fall back to
+                    # rebooting the directly-connected device instead --
+                    # that would silently reboot a device the user didn't
+                    # actually ask to reboot.
+                    if args.relay_target:
+                        if relayed is None:
+                            print(f"\n=== reboot() on {args.relay_target!r} (via relay) -- "
+                                  f"SKIPPED: relay target could not be resolved above ===")
+                            reboot_target = None
+                        else:
+                            reboot_target_label = f"{args.relay_target!r} (via relay through {args.by_serial!r})"
+                            reboot_target = relayed
+                    else:
+                        reboot_target_label = f"{args.by_serial!r} (direct)"
+                        reboot_target = mdevice
+
+                    if reboot_target is not None:
+                        print(f"\n=== reboot() on {reboot_target_label} (WRITE -- Reset, soft) ===")
+                        try:
+                            await reboot_target.reboot()
+                            print(f"  reboot() on {reboot_target_label} succeeded (device "
+                                  f"acknowledged the request -- it may take a few seconds to "
+                                  f"actually finish rebooting and reconnect).")
+                        except Exception as e:
+                            print(f"  reboot() FAILED: {e}")
+
+                if args.set_time_to_now:
+                    print(f"\n=== set_time_to_now() on {args.by_serial!r} (WRITE -- Epoch) ===")
+                    try:
+                        await mdevice.set_time_to_now()
+                        print(f"  set_time_to_now() on {args.by_serial!r} succeeded.")
+                    except Exception as e:
+                        print(f"  set_time_to_now() FAILED: {e}")
+
         except Exception as e:
             print("  failed to connect/read:", e)
         return
@@ -365,7 +431,10 @@ async def _run(args) -> None:
         device, info = connectable[0]
         print(f"\n=== Network addresses (connecting to {info.serial} to ask) ===")
         try:
-            async with MobiusDevice(serial=info.serial, adapter=args.adapter,
+            # device= already found above via the scan feeding `connectable`
+            # -- see the --by-serial path's own comment for why this avoids
+            # a redundant, race-prone second scan inside connect().
+            async with MobiusDevice(device=device, serial=info.serial, adapter=args.adapter,
                                      connect_timeout=args.connect_timeout) as mdevice:
                 peers = await _debug_mesh_discovery(mdevice)
         except Exception as e:
@@ -398,7 +467,10 @@ async def _run(args) -> None:
             device, info = connectable[0]
             print(f"  pan_id {label} (connecting through {info.serial})...")
             try:
-                async with MobiusDevice(serial=info.serial, adapter=args.adapter,
+                # device= already found above -- see the --by-serial path's
+                # own comment for why this avoids a redundant, race-prone
+                # second scan inside connect().
+                async with MobiusDevice(device=device, serial=info.serial, adapter=args.adapter,
                                          connect_timeout=args.connect_timeout) as mdevice:
                     tank = await discover_tank(mdevice)
             except Exception as e:
@@ -508,8 +580,11 @@ def main() -> None:
                               "(every point's time, flags, and per-channel/mode values) -- not "
                               "just the interpolated 'current' value get_device_summary() shows. "
                               "For lights, also prints lunar/insolation/schedule-intensity/"
-                              "acclimation state. Useful for diagnosing a mismatch against the "
-                              "app's own displayed value.")
+                              "acclimation state, PLUS the device's own firmware-computed lunar "
+                              "state (LunarPhasesCurrentDay/CurrentScalar, confirmed against real "
+                              "hardware -- see LunarPhaseInfo's own docstring) -- compare against "
+                              "\"current_intensities\"/\"light_diagnostics\" in the summary output "
+                              "above for this library's own calculated value.")
     parser.add_argument("--dump-mesh-peers", action="store_true",
                          help="Only usable with --by-serial. After connecting, calls "
                               "discover_mesh_peers_auto() on it and prints every other device "
@@ -542,6 +617,23 @@ def main() -> None:
                               "confirmed-meaningless opcode-25 ack and the real opcode-26 "
                               "indication, if it arrives). Useful for diagnosing a relay that "
                               "times out or returns unexpected data.")
+    parser.add_argument("--set-time-to-now", action="store_true",
+                         help="Only usable with --by-serial. A WRITE -- use on hardware you're "
+                              "prepared to have its clock changed on. Calls set_time_to_now() "
+                              "on the directly-connected device (Epoch, reserved-byte group=1 "
+                              "-- required for the write to be accepted at all, confirmed "
+                              "against real hardware). See that method's own docstring, and "
+                              "documentation/09-thread-coap-relay.md, for what's confirmed "
+                              "about this vs the rest of the mesh.")
+    parser.add_argument("--reboot", action="store_true",
+                         help="Only usable with --by-serial. A WRITE -- use on hardware you're "
+                              "prepared to have reboot. Soft-reboots the directly-connected "
+                              "device (Reset, ResetType.Soft) -- confirmed via the app's own "
+                              "source to be exactly its own \"Restart\" button. If "
+                              "--relay-target is also given, reboots THAT device via relay "
+                              "through the connected one instead, to test the relayed write "
+                              "path specifically -- see reboot()'s own docstring for what's "
+                              "confirmed about this vs a direct connection.")
     parser.add_argument("--build-peer-map", action="store_true",
                          help="Instead of full device summaries, scan for devices then "
                               "briefly connect to EACH one in turn to build a mesh peer map "

mobius/constants.py

@@ -20,7 +20,7 @@ from typing import Optional
 
 class PrimitiveType(IntEnum):
     """What kind of device this is, at the protocol level. Confirmed literal
-    values from M.PrimitiveType."""
+    values."""
     Undefined = 0
     VisualV1 = 1       # Radion / light-class devices (e.g. XR15, XR30, Prime, Hydra)
     PumpV1 = 2         # legacy Nero pumps
@@ -33,7 +33,7 @@ class PrimitiveType(IntEnum):
     CoffeeV1 = 9       # NYOS Quantum skimmers/dosers
 
 
-# Confirmed from M.PrimitiveType.size() -- the fixed byte-length (or, for
+# Confirmed from the app's own per-primitive size lookup -- the fixed byte-length (or, for
 # VisualV1, the per-channel-triplet unit) of that primitive type's schedule
 # point payload.
 PRIMITIVE_SIZE: dict[PrimitiveType, int] = {
@@ -177,11 +177,9 @@ class Model(IntEnum):
     Passthrough = 61445  # "Devel Board"
 
 
-# Confirmed directly against the app's own decompiled getManufacturer()/
-# isEtm() logic for every single entry above -- not a curated subset,
-# and not re-derived by name pattern (an earlier version of this
-# comment described it that way; that approach turned out to have at
-# least one confirmed mistake -- see the CHANGELOG for this release).
+# Confirmed directly against the app's own decompiled manufacturer-lookup
+# logic for every single entry above -- not a curated subset, and not
+# re-derived by name pattern.
 MODEL_MANUFACTURER: dict[Model, str] = {
     Model.Unknown: "Unknown",
 
@@ -300,8 +298,9 @@ def manufacturer_for_model(model: Optional[Model]) -> Optional[str]:
 
 
 class ErrorState(IntEnum):
-    """Confirmed literal values from M.ErrorState (subset covering common
-    pump/light fault codes -- the full enum also has dosing-pump-specific codes)."""
+    """Confirmed literal values for device error states (subset covering
+    common pump/light fault codes -- the full set also has dosing-pump-
+    specific codes)."""
     NoError = 0
     Disconnect = 1
     Temperature = 2
@@ -347,13 +346,19 @@ class C2Attribute(IntEnum):
     integer -- see documentation/03-attributes-and-opcodes.md), EXCEPT
     Schedule1 which required tracing through an extra hop via an unrelated
     library constant to resolve (also fully confirmed, just
-    via that extra hop)."""
+    via that extra hop). PowerOnDelay (800) and CoffeeStatusIntensity
+    (4100) are a similar case, resolved from third-party Android library/
+    SDK constants this project couldn't confirm via web search on its
+    own -- confirmed directly instead. Both fit the surrounding
+    sequential numbering exactly (717/800/801/802, 4100/4101/4102),
+    consistent with, though not proof of, that direct confirmation."""
     AttributeTableVersion = 0
     FirmwareVersion = 1
     HardwareRevision = 2
     SerialNumber = 3
     Model = 4
     Name = 5
+    Reset = 6
     PrimitiveType = 8
     PhysicalValues = 101
     MACAddress = 103
@@ -404,11 +409,49 @@ class C2Attribute(IntEnum):
     AcclimationStartIntensity = 904
     AcclimationStartTime = 905
     LunarPhasesEnabled = 907
+    # Confirmed attribute IDs and wire format, both against real
+    # hardware -- see LunarPhaseInfo's own docstring in
+    # device_status.py. Notably, the app itself never requests or
+    # parses either of these anywhere (confirmed by a full-source
+    # search): its own equivalent setup/parse logic only ever touches
+    # LunarPhasesEnabled, computing the actual reduction value entirely
+    # client-side instead of reading it from the device. The device's
+    # own firmware computes and reports these independently regardless
+    # -- get_lunar_phase_info() in device.py reads them directly.
+    LunarPhasesCurrentDay = 908
+    LunarPhasesCurrentScalar = 909
     Epoch = 201
     RTCTime = 219
     LocalTime = 207  # already device-timezone-adjusted -- see
                       # get_device_local_date()'s own docstring in
                       # device.py for why this exists at all
+    # "Advanced Features" -- the app's own settings screen covering
+    # both VorTech (LocalControlEnabled/AutoDimTimeout) and Radion
+    # (MaxFanSpeed/FanShutdownEnabled) devices under one umbrella,
+    # gated purely per-attribute (not hardcoded per-device-type
+    # branching) -- see get_advanced_features()'s own docstring in
+    # device.py for why this library mirrors that same per-attribute
+    # approach.
+    LocalControlEnabled = 300
+    AutoDimTimeout = 301
+    MaxFanSpeed = 910
+    FanShutdownEnabled = 1203
+    # Vectra-specific settings. PowerOnDelay's own literal in the decompile
+    # resolves through a third-party Android animation library's own
+    # constant, not confirmable via web search or from the app's own
+    # decompile alone -- confirmed directly (not from this project's own
+    # sources) to be 800.
+    PowerOnDelay = 800
+    ClosedLoop = 801
+    FeedModeReturnDelay = 802
+    # NYOS Quantum-specific settings -- confirmed. CoffeeStatusIntensity's
+    # own literal resolves through an AndroidX SDK constant with the same
+    # confirmation gap as PowerOnDelay above -- also confirmed directly to
+    # be 4100.
+    CoffeeStatusIntensity = 4100
+    CoffeeLedOn = 717
+    CoffeeFeedModeReturnDelay = 4101
+    CoffeePowerOnDelay = 4102
     # Thread mesh peer discovery -- see documentation/09-thread-coap-relay.md
     # for the full protocol trace. MeshLocalAddresses confirmed via
     # reverse engineering the app's own connection-setup logic; the three
@@ -444,7 +487,7 @@ class C2Attribute(IntEnum):
 
 class PhysicalValueID(IntEnum):
     """Sub-index used with C2Attribute.PhysicalValues. Confirmed literal
-    values from M.PhysicalValues."""
+    values."""
     Unknown = 0
     DriverTemperature = 1
     MotorTemperature = 2
@@ -514,7 +557,7 @@ class VisualID(IntEnum):
 
 
 class SceneID(IntEnum):
-    """Confirmed literal values from M.SceneID."""
+    """Confirmed literal values."""
     EmptyScene = 0
     FeedMode = 1
     BatteryBackup = 2
@@ -528,13 +571,27 @@ class SceneID(IntEnum):
 
 
 class OperationState(IntEnum):
-    """Confirmed literal values from M.OperationState."""
+    """Confirmed literal values."""
     OOB = 0
     LiveDemo = 1
     Scene = 2
     Schedule = 3
 
 
+class ResetType(IntEnum):
+    """Confirmed literal values -- the single byte written to
+    C2Attribute.Reset (6). Only Soft is actually exposed by this
+    library's own reboot() (see that method's own docstring for why
+    the rest are deliberately not wired up to anything yet) -- kept
+    here in full since every value is a directly-confirmed literal in
+    the decompile, same as everywhere else in this file."""
+    Soft = 0
+    Factory = 1
+    PowerLoss = 2
+    PowerRecovery = 3
+    Calibration = 4
+
+
 class FsciStatus(IntEnum):
     """Confirmed status/error codes returned in the first byte of a
     Get/Set-attribute confirm response."""
@@ -558,7 +615,7 @@ class FsciStatus(IntEnum):
 # --------------------------------------------------------------------------
 
 class PumpMode(IntEnum):
-    """Confirmed literal values from M.PumpMode."""
+    """Confirmed literal values."""
     Undefined = 0
     ConstantSpeed = 1
     Lagoon = 2
@@ -578,7 +635,7 @@ class PumpMode(IntEnum):
 
 
 class RampType(IntEnum):
-    """Confirmed literal values from M.RampType."""
+    """Confirmed literal values."""
     Sinusoidal = 1
     Logarithmic = 2
     Linear = 3
@@ -586,7 +643,7 @@ class RampType(IntEnum):
 
 class FirmwareType(IntEnum):
     """
-    Confirmed literal values from M.FirmwareType -- the sub-index used
+    Confirmed literal values -- the sub-index used
     with C2Attribute.FirmwareVersion (a Get with index=0, count=0xFFFF
     returns one entry per firmware component the device has, same "get
     all elements" pattern as MaxPower/NormalPower/SupportedColorChannels).
@@ -610,7 +667,7 @@ class FirmwareType(IntEnum):
     Esp32C6Firmware = 16
 
 
-# Ported directly from M.FirmwareType.name(Model) -- the EcoTech Marine
+# Ported directly from the app's own firmware-label lookup -- the EcoTech Marine
 # (isEtm()) branch specifically, confirmed via real hardware to exactly
 # match the app's own displayed labels (a VorTech pump showed Radio/Radio
 # Bootloader/Product OS/Product Bootloader; a Radion light showed Product
@@ -636,16 +693,46 @@ FIRMWARE_TYPE_LABELS_ETM: dict = {
     FirmwareType.QCA4020WLAN: "WLAN",
 }
 
+# The app's own non-ETM label branch (covers AquaIllumination -- Orbit/
+# Axis pumps, Prime/Hydra lights -- plus any other non-EcoTech-Marine
+# manufacturer) confirmed via the same name(Model) logic FIRMWARE_TYPE_
+# LABELS_ETM above is ported from, just its other branch. Every label
+# here is one of the SAME shared resource strings used somewhere in the
+# ETM dict above (just mapped to different FirmwareType values), so each
+# one is cross-referenced against an already hardware-confirmed value,
+# not independently guessed. XMC1402Firmware/CoffeeMotorDriverFirmware
+# are deliberately NOT included: their own labels ("driver"/
+# "base_station") aren't shared with any ETM-confirmed entry, so there's
+# no confirmed value available for them here -- they fall back to the
+# raw FirmwareType name instead, same as any other unmapped entry.
+FIRMWARE_TYPE_LABELS_NON_ETM: dict = {
+    FirmwareType.Unknown: "Radio Firmware",
+    FirmwareType.LEDClusterMicro: "Radio Firmware",
+    FirmwareType.Esp32C3Firmware: "Radio Firmware",
+    FirmwareType.Esp32H2Firmware: "Radio Firmware",
+    FirmwareType.Esp32S3Firmware: "Radio Firmware",
+    FirmwareType.Esp32C6Firmware: "Radio Firmware",
+    FirmwareType.OS: "Product OS",
+    FirmwareType.MainMicroOS: "Product OS",
+    FirmwareType.QCA4020M4F: "Product OS",
+    FirmwareType.Bootloader: "Product Bootloader",
+    FirmwareType.MainMicroBootloader: "Product Bootloader",
+    FirmwareType.QCA4020Firmware: "Firmware",
+    FirmwareType.QCA4020FileSystem: "Filesystem",
+    FirmwareType.QCA4020M0: "Radio",
+    FirmwareType.QCA4020WLAN: "WLAN",
+}
+
 
 class HardwareInfo(IntEnum):
     """
-    Confirmed literal values from M.HardwareInfo -- the sub-index used
+    Confirmed literal values -- the sub-index used
     with C2Attribute.HardwareRevision, same "get all elements" pattern as
     FirmwareVersion above. `Revision` and `Segments` have no confirmed
     display convention (read as plain small integers, not version
     numbers or enum codes) -- but `Color`/`ProductType`/`RadioType`/
-    `MotorType` are each themselves confirmed enums (M.Color/M.ProductType/
-    M.RadioType/M.MotorType) with confirmed display labels -- see
+    `MotorType` are each themselves confirmed enums with confirmed
+    display labels -- see
     Color/ProductType/RadioType/MotorType below and their *_LABELS dicts.
     """
     Unknown = 0
@@ -658,7 +745,7 @@ class HardwareInfo(IntEnum):
 
 
 class Color(IntEnum):
-    """Confirmed literal values and display labels from M.Color --
+    """Confirmed literal values and display labels --
     the HardwareInfo.Color sub-value's own enum."""
     Unknown = 0
     Black = 1
@@ -672,7 +759,7 @@ COLOR_LABELS: dict = {
 
 
 class RadioType(IntEnum):
-    """Confirmed literal values and display labels from M.RadioType --
+    """Confirmed literal values and display labels --
     the HardwareInfo.RadioType sub-value's own enum."""
     Unknown = 0
     KW41 = 1
@@ -698,7 +785,7 @@ RADIO_TYPE_LABELS: dict = {
 
 
 class MotorType(IntEnum):
-    """Confirmed literal values and display labels from M.MotorType --
+    """Confirmed literal values and display labels --
     the HardwareInfo.MotorType sub-value's own enum. Several labels
     (Slack/Alpaca2/Alpaca4/Turtle1-4) are base64-string-obfuscated in the
     decompile rather than plain literals, apparently to avoid casual
@@ -762,7 +849,7 @@ MOTOR_TYPE_LABELS: dict = {
 
 
 class ProductType(IntEnum):
-    """Confirmed literal values and display labels from M.ProductType --
+    """Confirmed literal values and display labels --
     the HardwareInfo.ProductType sub-value's own enum. Several labels
     are base64-string-obfuscated in the decompile the same way some
     MotorType labels are -- see MotorType's docstring for why that's
@@ -825,7 +912,7 @@ PRODUCT_TYPE_LABELS: dict = {
 
 class PumpOverrideMode(IntEnum):
     """
-    Confirmed literal values from M.PumpOverrideMode. Confirmed only as a
+    Confirmed literal values. Confirmed only as a
     SET target in the decompile (writing None to exit override mode after
     the pump-side calibration flow) -- never actually read anywhere in the
     app. The wire format for reading it (plain byte enum) is a reasonable
@@ -863,7 +950,7 @@ PUMP_PARAM_SIZE: dict[PumpParam, int] = {
     PumpParam.PhaseShift: 2, PumpParam.OnTime: 4, PumpParam.OffTime: 4,
 }
 
-# Ported directly from M.PumpMode.parameters() -- which params are present
+# Ported directly from the app's own pump-mode parameter logic -- which params are present
 # for each mode, and in what order (byte offset is cumulative from data[1:]).
 PUMP_MODE_PARAMS: dict[PumpMode, list[PumpParam]] = {
     PumpMode.Undefined: [],