python-mobius 0.7.0__py3-none-any.whl → 0.7.2__py3-none-any.whl

mobius/__init__.py

@@ -35,6 +35,7 @@ from .schedule import (
     LightPrimitive, SchedulePoint, interpolate_light_schedule,
     PumpPrimitiveValue, PumpSchedulePoint, get_active_pump_block,
 )
+from .scenes import Scene, ActiveScene, decode_configured_scenes, decode_active_scene
 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,
@@ -71,7 +72,7 @@ from .dump import (
     enrich_attribute_dump,
 )
 
-__version__ = "0.7.0"
+__version__ = "0.7.2"
 
 __all__ = [
     "__version__",
@@ -98,6 +99,8 @@ __all__ = [
     # schedule
     "LightPrimitive", "SchedulePoint", "interpolate_light_schedule",
     "PumpPrimitiveValue", "PumpSchedulePoint", "get_active_pump_block",
+    # scenes
+    "Scene", "ActiveScene", "decode_configured_scenes", "decode_active_scene",
     # manufacturer
     "MOBIUS_COMPANY_ID_ECOTECH", "MOBIUS_COMPANY_ID_AQUAILLUMINATION", "MOBIUS_COMPANY_IDS", "MobiusAdvertisement", "parse_manufacturer_data",
     # modifiers

mobius/cli.py

@@ -18,6 +18,7 @@ from .device import MobiusDevice
 from .relay import RelayedMobiusDevice
 from .device_status import MeshPeer
 from .mesh_address import extract_short_address
+from .constants import PrimitiveType, SceneID
 from .discovery import (
     scan_for_mobius_devices_with_info, group_by_pan_id, dedupe_by_serial,
     find_device_by_serial, discover_mesh_peers_via_direct_connect, discover_tank,
@@ -99,6 +100,37 @@ async def _dump_schedule(device: MobiusDevice, support: str) -> None:
         print(f"    (schedule dumping not supported for support={support!r})")
 
 
+async def _dump_scenes(device: MobiusDevice, primitive: PrimitiveType | None) -> None:
+    """Prints every configured scene, at whatever slot it lives in,
+    including empty/unused slots. The currently active scene is
+    already shown by the summary above (info["current_scene"])."""
+    print("  --- configured scenes ---")
+    scenes = await device.get_configured_scenes(primitive=primitive)
+    if not scenes:
+        print("    (none)")
+        return
+    for scene in scenes:
+        if scene.scene_type == SceneID.EmptyScene and not scene.name:
+            print(f"    [{scene.index}] (empty)")
+            continue
+        type_label = scene.scene_type.name if scene.scene_type else "custom"
+        if scene.light is not None:
+            payload = ", ".join(
+                f"{vid.name}={val}"
+                for vid, val in sorted(scene.light.channels.items(), key=lambda x: x[0].name)
+            )
+        elif scene.pump is not None:
+            params = ", ".join(
+                f"{p.name}={v.hex() if isinstance(v, bytes) else (v.name if hasattr(v, 'name') else v)}"
+                for p, v in scene.pump.params.items()
+            )
+            payload = f"mode={scene.pump.mode.name} {params}"
+        else:
+            payload = "(no primitive data decoded)"
+        print(f"    [{scene.index}] id={scene.id} ({type_label}) name={scene.name!r} "
+              f"timeout={scene.timeout}s: {payload}")
+
+
 async def _debug_mesh_discovery(device) -> list:
     """
     Verbose, step-by-step version of discover_mesh_peers_auto() for CLI
@@ -273,6 +305,10 @@ async def _run(args) -> None:
                     print(f"  {k}: {v}")
                 if args.dump_schedule:
                     await _dump_schedule(mdevice, summary.get("support", ""))
+                if args.dump_scenes:
+                    primitive_name = summary.get("primitive_type")
+                    primitive = PrimitiveType[primitive_name] if primitive_name else None
+                    await _dump_scenes(mdevice, primitive)
 
                 relayed = None  # set below only if --relay-target resolves successfully
                 if args.dump_mesh_peers or args.relay_target:
@@ -620,6 +656,10 @@ async def _run(args) -> None:
                     print(f"  {k}: {v}")
                 if args.dump_schedule:
                     await _dump_schedule(mdevice, summary.get("support", ""))
+                if args.dump_scenes:
+                    primitive_name = summary.get("primitive_type")
+                    primitive = PrimitiveType[primitive_name] if primitive_name else None
+                    await _dump_scenes(mdevice, primitive)
         except Exception as e:
             print("  failed to connect/read:", e)
 
@@ -667,6 +707,12 @@ def main() -> None:
                               "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-scenes", action="store_true",
+                         help="Also print every configured scene on each connected device -- "
+                              "id, name, timeout, and its own light/pump payload -- at whatever "
+                              "slot it lives in, including empty/unused slots. The currently "
+                              "active scene is already shown by the summary above "
+                              "(\"current_scene\").")
     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 "

mobius/constants.py

@@ -436,6 +436,7 @@ class C2Attribute(IntEnum):
     SceneTimeout = 402
     SceneTimer = 403
     # Scene diagnostics -- named, not yet exposed by a get_*() method.
+    LiveDemoSceneNero = 404
     LiveDemoTimeout = 405
     LiveDemoTimer = 406
     LiveDemoScene = 407

mobius/device.py

@@ -12,7 +12,7 @@ from __future__ import annotations
 import asyncio
 import struct
 import time
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Optional, Callable
 
 from bleak import BleakClient, BleakScanner
@@ -43,6 +43,7 @@ from .schedule import (
     SchedulePoint, interpolate_light_schedule,
     PumpSchedulePoint, get_active_pump_block,
 )
+from .scenes import Scene, ActiveScene, decode_configured_scenes, decode_active_scene
 from .modifiers import (
     AcclimationInfo, is_night_segment, lunar_percent_reduction,
 )
@@ -189,6 +190,11 @@ class FullPollResult:
     caller needing a separate get_pump_schedule() call just to also
     get schedule_point_count alongside everything else here.
 
+    configured_scenes/current_scene -- everything get_configured_scenes()/
+    get_current_scene() themselves cover, for whichever device types
+    support scenes at all (an empty list / None if not, matching those
+    methods' own behavior exactly).
+
     used_batch mirrors every other *Result/Snapshot's own field of the
     same name and purpose.
     """
@@ -197,6 +203,8 @@ class FullPollResult:
     light_poll: Optional[LightPollResult]
     pump_telemetry: Optional[dict]
     pump_schedule_points: Optional[list[PumpSchedulePoint]] = None
+    configured_scenes: list[Scene] = field(default_factory=list)
+    current_scene: Optional[ActiveScene] = None
     used_batch: bool = True
 
 
@@ -1276,22 +1284,53 @@ class MobiusDevice:
 
     # ---- scenes -----------------------------------------------------------
 
-    async def start_scene(self, scene_id: SceneID, duration_minutes: int = 0) -> None:
-        """duration_minutes=0 lets the device use the scene's own configured duration."""
-        value = struct.pack("<HH", int(scene_id), duration_minutes)
-        await self.set_attribute(C2Attribute.CurrentScene, value)
+    async def start_scene(self, scene_id: int, duration_seconds: int = 0, broadcast: bool = True) -> None:
+        """
+        Activates a scene by id -- one of the ten SceneID presets, or a
+        user-created scene's own device-assigned id (see get_configured_scenes()).
+        duration_seconds=0 lets the device use the scene's own configured
+        timeout instead.
+
+        broadcast=True (the default) sets the frame's own reserved-byte
+        "group" field to 1 (see make_reserved()), which propagates this
+        write to the rest of the mesh from a single write to just this
+        device -- confirmed against real hardware for set_time_to_now()'s
+        own Epoch write; the same group=1 mechanism is used here, though
+        this hasn't been independently confirmed against real hardware
+        for CurrentScene specifically. group=1 only ever reaches devices
+        on THIS SAME mesh (a Thread network is its own isolated network,
+        identified by its own pan_id) -- it cannot reach a different
+        tank's own, separate mesh, even one within physical radio range.
+        Pass broadcast=False to write to only this one device instead.
+        """
+        value = struct.pack("<HH", int(scene_id), duration_seconds)
+        reserved = make_reserved(group=1) if broadcast else b"\x00\x00"
+        await self.set_attribute(C2Attribute.CurrentScene, value, reserved=reserved)
 
-    async def start_feed_mode(self, duration_minutes: int = 0) -> None:
-        await self.start_scene(SceneID.FeedMode, duration_minutes)
+    async def start_feed_mode(self, duration_seconds: int = 0, broadcast: bool = True) -> None:
+        await self.start_scene(SceneID.FeedMode, duration_seconds, broadcast=broadcast)
 
     async def resume_schedule(self) -> None:
         """Cancel whatever scene is running and go back to the normal schedule."""
         await self.set_attribute(C2Attribute.OperationState, bytes([OperationState.Schedule]))
 
-    async def get_current_scene(self) -> tuple[SceneID, int]:
-        raw = await self.get_attribute(C2Attribute.CurrentScene)
-        scene_id, duration = struct.unpack("<HH", raw[0])
-        return SceneID(scene_id), duration
+    async def get_current_scene(self) -> Optional[ActiveScene]:
+        try:
+            raw = await self.get_attribute(C2Attribute.CurrentScene)
+        except Exception:
+            return None
+        return decode_active_scene(raw[0]) if raw else None
+
+    async def get_configured_scenes(self, primitive: Optional[PrimitiveType] = None) -> list[Scene]:
+        """
+        Every configured scene, at whatever slots this device actually
+        has one in -- including slots holding a genuinely empty/unused
+        scene. Pass primitive so each scene's own light/pump payload
+        can be decoded; omit it (or leave as None) to get every other
+        field with light/pump both left None.
+        """
+        raw = await self.get_attribute(C2Attribute.ConfiguredScenes, index=0, count=0xFFFF)
+        return decode_configured_scenes(raw, primitive)
 
     async def get_operation_state(self) -> OperationState:
         raw = await self.get_attribute(C2Attribute.OperationState)
@@ -2931,6 +2970,8 @@ class MobiusDevice:
         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()
+        current_scene = await self.get_current_scene()
+        info["current_scene"] = current_scene
 
         return info
 
@@ -3634,6 +3675,8 @@ class MobiusDevice:
             (C2Attribute.FirmwareVersion, 0, 0xFFFF),
             (C2Attribute.HardwareRevision, 0, 0xFFFF),
             (schedule_attr, 0, 0xFFFF),
+            (C2Attribute.ConfiguredScenes, 0, 0xFFFF),
+            (C2Attribute.CurrentScene, 0, 1),
         ]
         if primitive == PrimitiveType.VisualV1:
             intensity_attr = C2Attribute.Schedule1Intensity if which == 1 else C2Attribute.Schedule2Intensity
@@ -3705,10 +3748,16 @@ class MobiusDevice:
                 [motor_power_raw] if motor_power_raw else [], flow_range, model, primitive,
             )
 
+        configured_scenes = decode_configured_scenes(_values_for(C2Attribute.ConfiguredScenes), primitive)
+        current_scene_raw = _first_value(C2Attribute.CurrentScene)
+        current_scene = decode_active_scene(current_scene_raw) if current_scene_raw else None
+
         return FullPollResult(
             device_info=device_info, metadata=metadata,
             light_poll=light_poll, pump_telemetry=pump_telemetry,
-            pump_schedule_points=pump_schedule_points, used_batch=True,
+            pump_schedule_points=pump_schedule_points,
+            configured_scenes=configured_scenes, current_scene=current_scene,
+            used_batch=True,
         )
 
     async def _get_full_poll_via_individual_reads(
@@ -3731,10 +3780,17 @@ class MobiusDevice:
         else:
             pump_schedule_points = await self.get_pump_schedule(which=which)
             pump_telemetry = await self.get_pump_telemetry(model=model, primitive=primitive)
+        try:
+            configured_scenes = await self.get_configured_scenes(primitive=primitive)
+        except Exception:
+            configured_scenes = []
+        current_scene = await self.get_current_scene()
         return FullPollResult(
             device_info=device_info, metadata=metadata,
             light_poll=light_poll, pump_telemetry=pump_telemetry,
-            pump_schedule_points=pump_schedule_points, used_batch=False,
+            pump_schedule_points=pump_schedule_points,
+            configured_scenes=configured_scenes, current_scene=current_scene,
+            used_batch=False,
         )
 
     async def get_current_light_percentages(self, which: int = 1,

mobius/scenes.py

@@ -0,0 +1,97 @@
+"""
+Scenes: a device-side preset that can be activated on demand, separate
+from the normal time-based schedule (Schedule1/Schedule2). Each
+configured scene stores exactly the same kind of payload a schedule
+point would (channel intensities for a light, mode+parameters for a
+pump), plus a name and a timeout, at a fixed slot within
+ConfiguredScenes (400). Activating one writes CurrentScene (401).
+"""
+
+from __future__ import annotations
+
+import struct
+from dataclasses import dataclass
+from typing import Optional
+
+from .constants import SceneID, PrimitiveType, LIGHT_PRIMITIVES, PUMP_PRIMITIVES_VERIFIED, PUMP_PRIMITIVES_EXPERIMENTAL
+from .schedule import LightPrimitive, PumpPrimitiveValue
+
+SCENE_HEADER_SIZE = 20  # id(2) + timeout(2) + name(16), before primitiveData
+SCENE_NAME_SIZE = 16
+
+
+@dataclass
+class Scene:
+    """One configured scene, at a fixed slot (`index`) within
+    ConfiguredScenes. `scene_type` is one of the ten built-in presets
+    if `id` matches one, or None for a user-created scene (whose own
+    `id` is a device-assigned value outside that range). Exactly one
+    of `light`/`pump` is populated, matching the device's own
+    PrimitiveType -- the other stays None."""
+    index: int
+    id: int
+    scene_type: Optional[SceneID]
+    name: str
+    timeout: int
+    light: Optional[LightPrimitive]
+    pump: Optional[PumpPrimitiveValue]
+
+
+@dataclass
+class ActiveScene:
+    """The currently active scene (CurrentScene, 401) and how many
+    seconds it has left. `scene_type` is None if `id` doesn't match
+    one of the ten built-in presets (i.e. a user-created scene is
+    active) -- id itself is always present either way."""
+    id: int
+    scene_type: Optional[SceneID]
+    duration_seconds: int
+
+
+def decode_configured_scenes(values: list[bytes], primitive: Optional[PrimitiveType]) -> list[Scene]:
+    """
+    Pure decode for ConfiguredScenes (400) -- one call's worth of
+    values from a "get all elements" read (index=0, count=0xFFFF),
+    one element per slot, in index order. A slot with fewer than
+    SCENE_HEADER_SIZE bytes is skipped rather than raising.
+    """
+    scenes = []
+    for index, raw in enumerate(values):
+        if len(raw) < SCENE_HEADER_SIZE:
+            continue
+        scene_id = struct.unpack_from("<H", raw, 0)[0]
+        timeout = struct.unpack_from("<H", raw, 2)[0]
+        name_bytes = raw[4:4 + SCENE_NAME_SIZE]
+        name = name_bytes.split(b"\x00", 1)[0].decode("utf-8", errors="replace")
+        primitive_data = raw[SCENE_HEADER_SIZE:]
+
+        try:
+            scene_type = SceneID(scene_id)
+        except ValueError:
+            scene_type = None
+
+        light = None
+        pump = None
+        if primitive in LIGHT_PRIMITIVES:
+            light = LightPrimitive.parse(primitive_data)
+        elif primitive in PUMP_PRIMITIVES_VERIFIED or primitive in PUMP_PRIMITIVES_EXPERIMENTAL:
+            pump = PumpPrimitiveValue.parse(primitive_data)
+
+        scenes.append(Scene(
+            index=index, id=scene_id, scene_type=scene_type, name=name,
+            timeout=timeout, light=light, pump=pump,
+        ))
+    return scenes
+
+
+def decode_active_scene(raw: bytes) -> Optional[ActiveScene]:
+    """Pure decode for CurrentScene (401): id(u16 LE) + duration
+    seconds(u16 LE). None if raw is too short to contain both fields."""
+    if len(raw) < 4:
+        return None
+    scene_id, duration = struct.unpack_from("<HH", raw, 0)
+    try:
+        scene_type = SceneID(scene_id)
+    except ValueError:
+        scene_type = None
+    return ActiveScene(id=scene_id, scene_type=scene_type, duration_seconds=duration)

{python_mobius-0.7.0.dist-info → python_mobius-0.7.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-mobius
-Version: 0.7.0
+Version: 0.7.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
@@ -108,14 +108,25 @@ mobius-scan --adapter hci0
 - **Read light schedules**: per-channel intensity at any given time,
   replicating the app's own client-side interpolation (there's no "current
   intensity" attribute — lights only expose the programmed curve).
+- **Read every configured scene** (`get_configured_scenes()`) — name,
+  timeout, and its own light/pump payload, at whatever slot it lives in,
+  plus the currently active one (`get_current_scene()`).
+- **Control scenes**: start feed mode, resume the normal schedule, or any
+  other configured scene — one write, broadcast to the whole mesh by
+  default (`broadcast=True`). Uses the same mesh-propagation mechanism
+  confirmed against real hardware for the clock-sync write below;
+  applying it to scene activation specifically hasn't been
+  independently verified the same way yet.
+- **Fetch everything one device poll needs in a single round-trip**
+  (`get_full_poll_batch()`) — identity, metadata, light/pump state, and
+  scene data together, confirmed 2-2.6x faster on real hardware than
+  reading each piece separately.
 - **Read device-specific settings**: VorTech's own "Local Control"/"Led
   Auto Dim" and Radion's own "Max Fan Speed"/"Fan Shutdown"
   (`get_advanced_features()`), plus Vectra and NYOS Quantum settings
   (`get_vectra_info()`/`get_coffee_info()` — no real hardware to verify
   either against, see
   [known gaps](./documentation/10-known-gaps-and-open-questions.md)).
-- **Control scenes**: start feed mode, resume the normal schedule, or any
-  other configured scene.
 - **Fix a desynced device clock** (`set_time_to_now()`) — a WRITE.
   Writing to one device appears to propagate to the rest of its Thread
   mesh too, confirmed against real hardware — see

{python_mobius-0.7.0.dist-info → python_mobius-0.7.2.dist-info}/RECORD

@@ -1,9 +1,9 @@
-mobius/__init__.py,sha256=-jv9tL5vbjC5ZFfY1vAOZI6s1371TmIZPrkgjyVc7Yc,6610
-mobius/cli.py,sha256=QFphEX10dpPu9bPzUjuUq6K0U9vHG7Kuk-d7BbFfqEs,47541
+mobius/__init__.py,sha256=gcj_rnHfu_zczKCP4aBKOuKREHxuvmdXV9zFvMcj4eQ,6788
+mobius/cli.py,sha256=antaLPQysyPethop24fjeKowczEvfoVodgYkyIT5YxE,50008
 mobius/coap.py,sha256=dRE4yUp413etAMhDg2bLvFMLWusqjEWgUpC36i76mJs,10966
-mobius/constants.py,sha256=LA6COD5QE_x97Ue7hKY0KVarcAQxhxWEARYBJtLIww8,42452
+mobius/constants.py,sha256=ytpf9S_cHBKFWi_scr06ydmv-MW1dLGlG3CYfOAkiAw,42480
 mobius/crc.py,sha256=kLtAYWZvLbo5_p9ep08ZlLg5Yah8Q2qq0IwTvqbBGW0,2700
-mobius/device.py,sha256=2C5Ry52eUFfSx-28DDesPFQuzkt6QDoUu8ETKBsu9ek,187683
+mobius/device.py,sha256=YxfIgKWsERx1m-ueU1Bau1cXCWYOf-dzu2z3fUq7IeI,190773
 mobius/device_status.py,sha256=xlLCMU4gLnp59Uqix679jRdVBY2Jt6oI4EUr8fraeRg,34089
 mobius/discovery.py,sha256=Q_Z0riOBrEOwqpwAhk1wesh3340fiIYFi-8BWqhZ0JI,11949
 mobius/dump.py,sha256=S7-KNeDi9TOETm4ty5DwMXTrthvuMau196UENDQoAb4,16785
@@ -14,9 +14,10 @@ mobius/modifiers.py,sha256=b_BLlkSweanYse0VM8TkscGc4It-Dm0Aq2JbNpK7pMU,7308
 mobius/power.py,sha256=2o91-Cl6tC3x9SKJ9gN0fP5HSTFeD31jtd2BwTyBn30,3913
 mobius/pump_status.py,sha256=RWTl8ZViCFDbiFU2mX-WAIH_cWhZOZ0M2B0oYXnPx3Y,1598
 mobius/relay.py,sha256=IG15TtKDjSkmmi_C2cJwPmucX7V4psfamI0hKgTb_v8,24197
+mobius/scenes.py,sha256=Wt0Ys2x1YjF8MNDEd6kxWqYBIYPdBSbfzXD-L5ZKzag,3592
 mobius/schedule.py,sha256=kkQgwkFtM3pvik7UFzHKVhPVZrCGSH9AYvAlVA6kAck,10848
-python_mobius-0.7.0.dist-info/METADATA,sha256=LgBpHt0QN5xw5eKuoA6s3MPpPlZTaGSYVZtOFeUSHwg,8306
-python_mobius-0.7.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-python_mobius-0.7.0.dist-info/entry_points.txt,sha256=Q2hlcek-bWm70zvd12v32essflPgC2su-dKDHAqbPoE,48
-python_mobius-0.7.0.dist-info/licenses/LICENSE,sha256=7a72Msu2Q-TnoiFxemxEGkwafJGObk1W3rw9hzmyM_Y,17984
-python_mobius-0.7.0.dist-info/RECORD,,
+python_mobius-0.7.2.dist-info/METADATA,sha256=X1Pa4FH6dPjYwjNRxFaRpu-hHgRn68f5F5eZubCNgqg,9036
+python_mobius-0.7.2.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+python_mobius-0.7.2.dist-info/entry_points.txt,sha256=Q2hlcek-bWm70zvd12v32essflPgC2su-dKDHAqbPoE,48
+python_mobius-0.7.2.dist-info/licenses/LICENSE,sha256=7a72Msu2Q-TnoiFxemxEGkwafJGObk1W3rw9hzmyM_Y,17984
+python_mobius-0.7.2.dist-info/RECORD,,