python-mobius 0.4.3__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.3"
+__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 "