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

mobius/__init__.py

@@ -28,6 +28,8 @@ from .constants import (
     SceneID, OperationState, FsciStatus,
     PumpMode, PumpOverrideMode, RampType, PumpParam, PUMP_PARAM_SIZE, PUMP_MODE_PARAMS,
     FirmwareType, FIRMWARE_TYPE_LABELS_ETM, HardwareInfo,
+    Color, COLOR_LABELS, RadioType, RADIO_TYPE_LABELS,
+    MotorType, MOTOR_TYPE_LABELS, ProductType, PRODUCT_TYPE_LABELS,
 )
 from .schedule import (
     LightPrimitive, SchedulePoint, interpolate_light_schedule,
@@ -61,7 +63,7 @@ from .discovery import (
     dedupe_by_serial, find_device_by_serial, discover_mesh_peers_via_direct_connect,
 )
 
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 
 __all__ = [
     "__version__",
@@ -83,6 +85,8 @@ __all__ = [
     "SceneID", "OperationState", "FsciStatus",
     "PumpMode", "PumpOverrideMode", "RampType", "PumpParam", "PUMP_PARAM_SIZE", "PUMP_MODE_PARAMS",
     "FirmwareType", "FIRMWARE_TYPE_LABELS_ETM", "HardwareInfo",
+    "Color", "COLOR_LABELS", "RadioType", "RADIO_TYPE_LABELS",
+    "MotorType", "MOTOR_TYPE_LABELS", "ProductType", "PRODUCT_TYPE_LABELS",
     # schedule
     "LightPrimitive", "SchedulePoint", "interpolate_light_schedule",
     "PumpPrimitiveValue", "PumpSchedulePoint", "get_active_pump_block",

mobius/constants.py

@@ -492,11 +492,12 @@ class HardwareInfo(IntEnum):
     """
     Confirmed literal values from M.HardwareInfo -- the sub-index used
     with C2Attribute.HardwareRevision, same "get all elements" pattern as
-    FirmwareVersion above. Unlike FirmwareVersion, 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 numbers) -- returned as raw bytes,
-    not formatted, until that's confirmed.
+    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
+    Color/ProductType/RadioType/MotorType below and their *_LABELS dicts.
     """
     Unknown = 0
     Color = 1
@@ -507,6 +508,172 @@ class HardwareInfo(IntEnum):
     Segments = 6
 
 
+class Color(IntEnum):
+    """Confirmed literal values and display labels from M.Color --
+    the HardwareInfo.Color sub-value's own enum."""
+    Unknown = 0
+    Black = 1
+    White = 2
+
+
+COLOR_LABELS: dict = {
+    Color.Black: "Black",
+    Color.White: "White",
+}
+
+
+class RadioType(IntEnum):
+    """Confirmed literal values and display labels from M.RadioType --
+    the HardwareInfo.RadioType sub-value's own enum."""
+    Unknown = 0
+    KW41 = 1
+    QCA4020 = 2
+    K32W = 3
+    QCA4024 = 4
+    ESP32C3 = 5
+    ESP32H2 = 6
+    ESP32S3 = 7
+    ESP32C6 = 8
+
+
+RADIO_TYPE_LABELS: dict = {
+    RadioType.KW41: "KW41",
+    RadioType.QCA4020: "QCA4020",
+    RadioType.K32W: "K32W",
+    RadioType.QCA4024: "QCA4024",
+    RadioType.ESP32C3: "ESP32C3",
+    RadioType.ESP32H2: "ESP32H2",
+    RadioType.ESP32S3: "ESP32S3",
+    RadioType.ESP32C6: "ESP32C6",
+}
+
+
+class MotorType(IntEnum):
+    """Confirmed literal values and display labels from M.MotorType --
+    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
+    discovery of unannounced product names in a simple APK string dump --
+    decoded here since it's plain base64, not encryption, and the
+    resulting strings are just as much "confirmed from source" as the
+    unobfuscated ones."""
+    Unknown = 0
+    VorTechMP10 = 1
+    VorTechMP40Legacy = 2
+    VorTechMP40G3 = 3
+    VorTechMP60 = 4
+    VectraD12 = 5
+    VectraD8 = 6
+    VectraS1 = 7
+    Wavepuck30w = 8
+    Nero5 = 9
+    Nero3 = 10
+    VectraS2 = 11
+    VectraM2 = 12
+    VectraL2 = 13
+    VersaVX1 = 14
+    Slack = 15
+    Alpaca2 = 16
+    Alpaca4 = 17
+    Turtle1 = 18
+    Turtle2 = 19
+    Turtle3 = 20
+    Turtle4 = 21
+    Coffee1 = 22
+    Coffee2 = 23
+    VectraTester = 99
+
+
+MOTOR_TYPE_LABELS: dict = {
+    MotorType.VorTechMP10: "VorTech MP10",
+    MotorType.VorTechMP40Legacy: "VorTech MP40 Legacy",
+    MotorType.VorTechMP40G3: "VorTech MP40 G3",
+    MotorType.VorTechMP60: "VorTech MP60",
+    MotorType.VectraD12: "Vectra D12",
+    MotorType.VectraD8: "Vectra D8",
+    MotorType.VectraS1: "Vectra S1",
+    MotorType.Wavepuck30w: "Wavepuck 30w",
+    MotorType.Nero5: "Nero 5",
+    MotorType.Nero3: "Nero 3",
+    MotorType.VectraS2: "Vectra S2",
+    MotorType.VectraM2: "Vectra M2",
+    MotorType.VectraL2: "Vectra L2",
+    MotorType.VersaVX1: "Versa VX1",
+    MotorType.Slack: "Nero 7",
+    MotorType.Alpaca2: "Orbit 2",
+    MotorType.Alpaca4: "Orbit 4",
+    MotorType.Turtle1: "Axis 20",
+    MotorType.Turtle2: "Axis 40",
+    MotorType.Turtle3: "Axis 90",
+    MotorType.Turtle4: "Axis 200",
+    MotorType.Coffee1: "Coffee 1",
+    MotorType.Coffee2: "Coffee 2",
+    MotorType.VectraTester: "Vectra Tester",
+}
+
+
+class ProductType(IntEnum):
+    """Confirmed literal values and display labels from M.ProductType --
+    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
+    still treated as confirmed. Note several of these labels intentionally
+    diverge from the enum member's own name (e.g. Chalupa -> "Sprout",
+    NachosBellGrande -> "Voltra", Cowboy -> "MXM") -- these are the actual
+    confirmed display strings, not typos."""
+    Unknown = 0
+    Radion = 1
+    Vectra = 2
+    VorTech = 3
+    Nero = 4
+    DosingPump = 5
+    Chalupa = 6
+    EnvironmentalSensor = 7
+    RFModule = 8
+    WiFiModule = 9
+    WiFiModuleBreakout = 10
+    ChalupaPowerSupply = 11
+    ChalupaDriver = 12
+    AIFiLight = 13
+    AIMobiusLight = 14
+    DosingPumpBase = 15
+    NachosBellGrande = 16
+    HotSauce = 17
+    Cowboy = 18
+    Alpaca = 19
+    Turtle = 20
+    Coffee = 21
+    CrunchyTaco = 22
+    SoftTaco = 23
+
+
+PRODUCT_TYPE_LABELS: dict = {
+    ProductType.Radion: "Radion",
+    ProductType.Vectra: "Vectra",
+    ProductType.VorTech: "VorTech",
+    ProductType.Nero: "Nero",
+    ProductType.DosingPump: "Dosing Pump",
+    ProductType.Chalupa: "Sprout",
+    ProductType.EnvironmentalSensor: "Sensor",
+    ProductType.RFModule: "RF Module",
+    ProductType.WiFiModule: "Wi-Fi Module",
+    ProductType.WiFiModuleBreakout: "Breakout",
+    ProductType.ChalupaPowerSupply: "Power Supply",
+    ProductType.ChalupaDriver: "Driver",
+    ProductType.AIFiLight: "AI-Fi Light",
+    ProductType.AIMobiusLight: "AI Light",
+    ProductType.DosingPumpBase: "Base Station",
+    ProductType.NachosBellGrande: "Voltra",
+    ProductType.HotSauce: "Sensor",
+    ProductType.Cowboy: "MXM",
+    ProductType.Alpaca: "Orbit",
+    ProductType.Turtle: "Axis",
+    ProductType.Coffee: "Quantum",
+    ProductType.CrunchyTaco: "Hera",
+    ProductType.SoftTaco: "Hera Backplane",
+}
+
+
 class PumpOverrideMode(IntEnum):
     """
     Confirmed literal values from M.PumpOverrideMode. Confirmed only as a

mobius/device.py

@@ -31,6 +31,8 @@ from .constants import (
     C2Attribute, PrimitiveType, Model, ErrorState, SceneID, OperationState,
     FsciStatus, PhysicalValueID, VisualID, PumpOverrideMode, manufacturer_for_model,
     FirmwareType, FIRMWARE_TYPE_LABELS_ETM, HardwareInfo,
+    Color, COLOR_LABELS, RadioType, RADIO_TYPE_LABELS,
+    MotorType, MOTOR_TYPE_LABELS, ProductType, PRODUCT_TYPE_LABELS,
     PRIMITIVE_SIZE, LIGHT_PRIMITIVES, PUMP_PRIMITIVES_VERIFIED, PUMP_PRIMITIVES_EXPERIMENTAL,
 )
 from .schedule import (
@@ -105,6 +107,18 @@ class LightIntensityResult(dict):
         self.diagnostics = diagnostics or {}
 
 
+# Used by get_hardware_info() -- which HardwareInfo sub-fields are
+# themselves confirmed enums with confirmed display labels, vs. plain
+# integers with no confirmed meaning (Revision/Segments, deliberately not
+# in this map).
+_HARDWARE_SUB_ENUM_LABELS = {
+    HardwareInfo.Color: (Color, COLOR_LABELS),
+    HardwareInfo.ProductType: (ProductType, PRODUCT_TYPE_LABELS),
+    HardwareInfo.RadioType: (RadioType, RADIO_TYPE_LABELS),
+    HardwareInfo.MotorType: (MotorType, MOTOR_TYPE_LABELS),
+}
+
+
 class MobiusDevice:
     """
     High-level async client for a single Mobius-protocol BLE device.
@@ -363,16 +377,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 +405,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 +788,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,54 +811,76 @@ 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
-        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
-        numbers) -- returns {HardwareInfo_name: raw_bytes}, not formatted,
-        until that's confirmed against real hardware.
+        -- 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).
+
+        `Color`/`ProductType`/`RadioType`/`MotorType` are each themselves
+        confirmed enums with confirmed display labels (M.Color/
+        M.ProductType/M.RadioType/M.MotorType in the decompile -- see
+        mobius.constants) -- decoded into those label strings here, e.g.
+        {"Color": "White", "MotorType": "VorTech MP40 G3"}. An
+        unrecognized value (firmware newer than this library's confirmed
+        enum coverage) falls back to "Unknown (N)" rather than raising.
+
+        `Revision`/`Segments` have no confirmed enum meaning -- returned
+        as plain integers, not formatted, since unlike the four fields
+        above there's nothing confirmed to decode them into.
         """
         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
+                if not value_bytes:
+                    continue
+                raw_int = int.from_bytes(value_bytes, byteorder="little", signed=False)
+                if hw_info in _HARDWARE_SUB_ENUM_LABELS:
+                    enum_cls, labels = _HARDWARE_SUB_ENUM_LABELS[hw_info]
+                    try:
+                        result[hw_info.name] = labels.get(enum_cls(raw_int), f"Unknown ({raw_int})")
+                    except ValueError:
+                        result[hw_info.name] = f"Unknown ({raw_int})"
+                else:
+                    result[hw_info.name] = raw_int
         return result
 
     async def get_device_summary(self) -> dict:
@@ -823,11 +904,12 @@ class MobiusDevice:
         Pump devices additionally include "flow_range", "pump_override_mode",
         "battery_backup", "boosted_battery" (see get_pump_flow_range() etc.
         for details/confidence notes on each). Every device (regardless of
-        support tier) additionally includes "group", "calibration", and
-        "maintenance" (see get_group_info()/get_calibration_info()/
-        get_maintenance_info() -- calibration in particular is expected to
-        only actually populate on lights, not pumps; see
-        documentation/11-device-status-attributes.md).
+        support tier) additionally includes "group", "calibration",
+        "maintenance", and "hardware_info" (see get_group_info()/
+        get_calibration_info()/get_maintenance_info()/get_hardware_info()
+        -- calibration in particular is expected to only actually
+        populate on lights, not pumps; see documentation/
+        11-device-status-attributes.md).
 
         BUG NOTE: for a while after get_pump_flow_range()/
         get_pump_override_mode()/get_battery_backup_info()/
@@ -909,6 +991,7 @@ class MobiusDevice:
         info["calibration"] = await self.get_calibration_info()
         info["maintenance"] = await self.get_maintenance_info()
         info["firmware_versions"] = await self.get_firmware_versions(model)
+        info["hardware_info"] = await self.get_hardware_info()
         info["device_time"] = await self.get_device_time_info()
 
         return info
@@ -1025,7 +1108,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 +1248,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 +1273,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/modifiers.py

@@ -131,14 +131,28 @@ class AcclimationInfo:
 def is_night_segment(points: list[SchedulePoint], minute_of_day: int) -> bool:
     """
     True specifically when minute_of_day falls in the segment whose START
-    point is NOT flagged NIGHT or SUNRISE and whose END point IS flagged
-    NIGHT (i.e. the dusk-transition-into-night segment), or when
-    minute_of_day exactly matches a point that is itself flagged NIGHT.
-    This is NOT simply "is it currently night" -- that's genuinely the
-    Java source's own semantics (confirmed by reading
-    PointSchedule.getIntensitiesAtTime() directly), used specifically to
-    decide whether to substitute the lunar-phase reduction in place of the
+    point IS flagged NIGHT (but not also SUNRISE) and whose END point is
+    ALSO flagged NIGHT (i.e. once actually into the night portion of the
+    schedule, up until the sunrise transition), or when minute_of_day
+    exactly matches a point that is itself flagged NIGHT. This is NOT
+    simply "is it currently night" as a general concept, but this
+    specific segment-boundary condition -- used specifically to decide
+    whether to substitute the lunar-phase reduction in place of the
     normal schedule-intensity scalar.
+
+    Confirmed directly from raw smali bytecode (JADX's decompiled Java
+    for PointSchedule.getIntensitiesAtTime() carried its own "Code
+    duplicated" warning on this exact method -- a real signal, not
+    noise: its decompilation of this specific condition had the first
+    check inverted, i.e. `!point.has(NIGHT)` instead of the actual
+    `point.has(NIGHT)`. Confirmed via real hardware testing too: a
+    23:00[NIGHT,SUNSET]->23:27[NIGHT] segment produced a value matching
+    schedule-intensity-only scaling from this library, while the real
+    app displayed a much lower, lunar-consistent value at the same
+    moment -- mathematically impossible to explain by schedule-intensity
+    alone within that segment's raw-value range, which is what led back
+    to re-examining the raw bytecode instead of trusting the decompiled
+    Java a second time.
     """
     if not points:
         return False
@@ -160,7 +174,7 @@ def is_night_segment(points: list[SchedulePoint], minute_of_day: int) -> bool:
             if t1 == t2:
                 return p1.has(SchedulePoint.FLAG_NIGHT)
             return (
-                not p1.has(SchedulePoint.FLAG_NIGHT)
+                p1.has(SchedulePoint.FLAG_NIGHT)
                 and not p1.has(SchedulePoint.FLAG_SUNRISE)
                 and p2.has(SchedulePoint.FLAG_NIGHT)
             )

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.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-mobius
-Version: 0.2.0
+Version: 0.3.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

{python_mobius-0.2.0.dist-info → python_mobius-0.3.0.dist-info}/RECORD

@@ -1,21 +1,21 @@
-mobius/__init__.py,sha256=tyvUO4ImAlcND0wQnJ0aMmC4DPB3ZRZXNVBdqz93LC4,5334
+mobius/__init__.py,sha256=m_RB_zd21HCRyOSYovJeLFLScE8Gv9dPLjwdLALGRjk,5596
 mobius/cli.py,sha256=s1zZa4P4rws-XRLLd1B_J67mjMbdImcfgNeDet44cYo,21494
 mobius/coap.py,sha256=n-_wBuSY88_c1TAjfXPZsPnpG0IcZZLFRjxTzd1c0Us,10859
-mobius/constants.py,sha256=rXaywY6WIK36HobZ1E3w-HfEWtZDCFzXqKbo4Bbe1V8,19259
+mobius/constants.py,sha256=N98whYfTAdzydP18kn0ycXQubbc6F-CJUSr-o_KlepU,24129
 mobius/crc.py,sha256=WwIfUXGN_UKdsv-_Q303-L1-L1Rc1fvJnB5176ftzqU,2669
-mobius/device.py,sha256=f-B4q0IZlQl3C78mwLJLHQL5O-LcqzVUeYZ6dUiXe0I,65558
+mobius/device.py,sha256=8iNc9fX01Cns00bGYXmSPxXb80THjBd-h47iV02b2KU,70462
 mobius/device_status.py,sha256=373a7BRGY1CoByLYkxTELAewkiSj4Wzm8yAilQrh0co,5812
 mobius/discovery.py,sha256=anJXZEwwhYwvQhFdYOwl6HGTrnMGUfb5CNg6H7Ah-iI,7737
 mobius/frame.py,sha256=zG2vh8PceJHD8R43MwZiJnm0Ge1dr8nFcKsJR9_c9LM,6135
 mobius/manufacturer.py,sha256=8-vBzckN8xmsPSMj5EWtOCXenbyQueoY5pnZHePgb_k,1937
 mobius/mesh_address.py,sha256=PNUi3VyRQZCitB1R3IbzXCg1LcP6azSg1sigHAqaP7E,4942
-mobius/modifiers.py,sha256=pFNjGYX-_bNumNEpv3jJLYPCb9ZuSKYpQ0DDd2GmicQ,6451
+mobius/modifiers.py,sha256=TQD__OvHAvUO14Z8SNp2I4lb7XYSbw_iZT2D2DXaeJ4,7315
 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.3.0.dist-info/METADATA,sha256=8Zxtj2NGCJFkLEm2yXnLs-9ioowAitxS3i3jIrJ9Xtk,5959
+python_mobius-0.3.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+python_mobius-0.3.0.dist-info/entry_points.txt,sha256=Q2hlcek-bWm70zvd12v32essflPgC2su-dKDHAqbPoE,48
+python_mobius-0.3.0.dist-info/licenses/LICENSE,sha256=7a72Msu2Q-TnoiFxemxEGkwafJGObk1W3rw9hzmyM_Y,17984
+python_mobius-0.3.0.dist-info/RECORD,,