python-mobius 0.4.2__tar.gz → 0.4.4__tar.gz

{python_mobius-0.4.2 → python_mobius-0.4.4}/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 0.4.4
+
+- Filled in the rest of the device model list (EcoTech Marine,
+  AquaIllumination, Neptune Systems, NYOS), previously a curated
+  subset. Also corrects Model.VersaVX1, mismarked as AquaIllumination;
+  it's an EcoTech Marine product.
+- Several Model entries are now named for their real product (e.g.
+  Model.Axis40, Model.Blade, Model.Quantum160) instead of the app's
+  own internal placeholder codename (Turtle2, Saddle, Coffee1).
+- Fixed the lunar-phase-scaled light intensity sometimes disagreeing
+  with the app for hours at a stretch. The lunar calculation now uses
+  the gateway device's own reported date instead of the local
+  system's, matching what the app itself actually does.
+
+## 0.4.3
+
+- Fixed relayed devices (anything reached through a gateway over the
+  Thread mesh, not directly over BLE) occasionally losing a read for
+  no apparent reason, even though the official app kept working fine.
+  A single relay round-trip crosses both BLE and the Thread mesh, and
+  one dropped or delayed packet somewhere in that longer path turned
+  out to be common enough that the app always retries once before
+  giving up -- this library now does the same.
+
 ## 0.4.2
 
 - Fixed `MeshPeer.age` being parsed as a signed number instead of

{python_mobius-0.4.2 → python_mobius-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-mobius
-Version: 0.4.2
+Version: 0.4.4
 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.4.2 → python_mobius-0.4.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "python-mobius"
-version = "0.4.2"
+version = "0.4.4"
 description = "Reverse-engineered Python client for the Mobius BLE protocol (EcoTech Marine VorTech/Radion, AquaIllumination, Neptune Systems, NYOS)"
 readme = "README.md"
 license = { text = "GPL-2.0-only" }

{python_mobius-0.4.2 → python_mobius-0.4.4}/src/mobius/__init__.py

@@ -65,7 +65,7 @@ from .discovery import (
     discover_tank,
 )
 
-__version__ = "0.4.2"
+__version__ = "0.4.4"
 
 __all__ = [
     "__version__",

{python_mobius-0.4.2 → python_mobius-0.4.4}/src/mobius/constants.py

@@ -61,71 +61,133 @@ PUMP_PRIMITIVES_EXPERIMENTAL = {PrimitiveType.CoffeeV1}
 
 
 class Model(IntEnum):
-    """Device model identifiers. Confirmed literal values via reverse
-    engineering the app's own model-identifier enum
-    (a curated subset -- the full enum covers ~100 models across EcoTech
-    Marine, AquaIllumination, Neptune Systems, NYOS, and Hera product lines;
-    add entries here as needed)."""
+    """Device model identifiers. Confirmed literal values -- and, for
+    every entry, the real product name -- via reverse engineering the
+    app's own model-identifier enum and its own getName() method
+    directly (base64-decoded where the app itself stores the string
+    that way, confirmed real product names even for entries whose own
+    internal enum constant name is an unrelated food-themed placeholder
+    -- e.g. this enum's own Plumbus really is called "Plumbus" by the
+    real app itself, not a decompiler artifact). The full set, not a
+    curated subset -- see MODEL_MANUFACTURER below for the same
+    treatment of manufacturer. A few entries (the RadionXR#w G5/G6 FW/
+    Pro/Blue range specifically) are named here for the real product,
+    not the app's own internal enum constant name, to stay consistent
+    with how every other RadionXR#w entry in this same enum is already
+    named -- each renamed entry's own comment says what the app itself
+    actually calls it internally, for anyone cross-referencing against
+    the decompiled source directly."""
     Unknown = 0
-    VorTechMP10wES = 10
-    VorTechMP10wQD = 11
-    RadionXR30w = 30
-    RadionXR30wG2 = 31
-    RadionXR30wPro = 32
-    RadionXR30wG3 = 33
-    RadionXR30wG3Pro = 34
-    RadionXR30wG4 = 35
-    RadionXR30wG4Pro = 36
-    RadionXR30wFWPro = 37
-    RadionXR30wPrototype = 39
-    VorTechMP40wES = 40
-    VorTechMP40wQD = 41
-    VorTechMP40wG3QD = 42
-    VorTechMP60wES = 60
-    VorTechMP60wQD = 61
-    VectraM1 = 144
-    VectraL1 = 145
-    VectraS1 = 146
-    VectraS2 = 147
-    VectraM2 = 148
-    VectraL2 = 149
-    RadionXR15wG3Pro = 160
-    RadionXR15wFW = 161
-    RadionXR15wG4Pro = 162
-    RadionXR15wFWPro = 163
-    RadionXR15wPrototype = 175
-    RadionXR15G5Pro = 176
-    RadionXR15wG5Blue = 177
-    RadionXR15wG5FW = 178       # "Radion XR15w G5 FW" (base64-decoded from getName())
-    RadionXR15wG6Pro = 179      # "Radion XR15w G6 Pro" (base64-decoded from getName())
-    RadionXR15wG6Blue = 180     # "Radion XR15w G6 Blue" (inferred sequential id, base64-decoded name)
-    RadionXR30wG5Pro = 192
-    RadionXR30wG5Blue = 193
-    Nero5 = 256
-    Nero3 = 257
-    DosingPump = 272
-    Muffler = 275           # "Dose QD" -- another doser model
-    Coffee1 = 396            # "Quantum 160" (NYOS) -- CoffeeV1 primitive
-    Coffee2 = 397            # "Quantum 220/300" (NYOS)
-
-
-# Confirmed via reverse engineering the app's own manufacturer-lookup logic.
-# The decompiled version branches on
-# enum *ordinal* against a hardcoded position list (the full ~100-entry
-# Model enum's index 1-37 range, plus a few extras, all map to "EcoTech
-# Marine"); since this library only implements a curated subset of Model,
-# this is re-derived by name pattern against that same logic instead of by
-# ordinal position -- functionally equivalent for every Model value defined
-# above, but if you add more Model entries, add their manufacturer here too.
+    VorTechMP10wES = 10  # "VorTech MP10wES"
+    VorTechMP10wQD = 11  # "VorTech MP10mQD"
+    RadionXR30w = 30  # "Radion XR30w"
+    RadionXR30wG2 = 31  # "Radion XR30w G2"
+    RadionXR30wPro = 32  # "Radion XR30w Pro"
+    RadionXR30wG3 = 33  # "Radion XR30w G3"
+    RadionXR30wG3Pro = 34  # "Radion XR30wG3 Pro"
+    RadionXR30wG4 = 35  # "Radion XR30w G4"
+    RadionXR30wG4Pro = 36  # "Radion XR30w G4 Pro"
+    RadionXR30wFWPro = 37  # "Radion XR30wFW Pro"
+    RadionXR30wPrototype = 39  # "Radion XR30w Prototype"
+    VorTechMP40wES = 40  # "VorTech MP40wES"
+    VorTechMP40wQD = 41  # "VorTech MP40mQD"
+    VorTechMP40wG3QD = 42  # "VorTech MP40mQD"
+    VorTechMP60wES = 60  # "VorTech MP60wES"
+    VorTechMP60wQD = 61  # "VorTech MP60mQD"
+    VectraM1 = 144  # "Vectra M1"
+    VectraL1 = 145  # "Vectra L1"
+    VectraS1 = 146  # "Vectra S1"
+    VectraS2 = 147  # "Vectra S2"
+    VectraM2 = 148  # "Vectra M2"
+    VectraL2 = 149  # "Vectra L2"
+    RadionXR15wG3Pro = 160  # "Radion XR15wG3 Pro"
+    RadionXR15wFW = 161  # "Radion XR15w FW"
+    RadionXR15wG4Pro = 162  # "Radion XR15w G4 Pro"
+    RadionXR15wFWPro = 163  # "Radion XR15w FW Pro"
+    RadionXR15wPrototype = 175  # "Radion XR15w Prototype"
+    RadionXR15G5Pro = 176  # "Radion XR15w G5 Pro"
+    RadionXR15wG5Blue = 177  # "Radion XR15w G5 Blue"
+    RadionXR15wG5FW = 178  # "Radion XR15w G5 FW" (app's own internal enum name: BeefChalupa)
+    RadionXR15wG6Pro = 179  # "Radion XR15w G6 Pro" (app's own internal enum name: SteakQuesadilla)
+    RadionXR15wG6Blue = 180  # "Radion XR15w G6 Blue" (app's own internal enum name: SteakNachoFriesBurrito)
+    RadionXR30wG5Pro = 192  # "Radion XR30w G5 Pro"
+    RadionXR30wG5Blue = 193  # "Radion XR30w G5 Blue"
+    RadionXR30wG5FW = 194  # "Radion XR30w G5 FW" (app's own internal enum name: CrunchwrapSupreme)
+    RadionXR30wG6Pro = 195  # "Radion XR30w G6 Pro" (app's own internal enum name: SteakTaco)
+    RadionXR30wG6Blue = 196  # "Radion XR30w G6 Blue" (app's own internal enum name: BeefyMeltBurrito)
+    Nero5 = 256  # "Nero 5"
+    Nero3 = 257  # "Nero 3"
+    Nero7 = 258  # "Nero 7" (app's own internal enum name: Slack)
+    Orbit2 = 259  # "Orbit 2" (app's own internal enum name: Alpaca2)
+    Orbit4 = 260  # "Orbit 4" (app's own internal enum name: Alpaca4)
+    Axis20 = 261  # "Axis 20" (app's own internal enum name: Turtle1)
+    Axis40 = 262  # "Axis 40" (app's own internal enum name: Turtle2)
+    Axis90 = 263  # "Axis 90" (app's own internal enum name: Turtle3)
+    Axis200 = 264  # "Axis 200" (app's own internal enum name: Turtle4)
+    VersaVX1 = 272  # "Versa VX-1" (app's own internal enum name: DosingPump)
+    DoseQD = 275  # "Dose QD" (app's own internal enum name: Muffler)
+    SproutSL1 = 288  # "Sprout SL1" (app's own internal enum name: Chalupa)
+    EnvironmentalSensor = 304  # "Environmental Sensor" (app's own internal enum name: DoritosLocosTacos)
+    Prime = 320  # "Prime"
+    PrimeHD = 321  # "Prime HD"
+    PrimeFW = 322  # "Prime FW" (the app's own getName() genuinely returns an empty string for this one specifically -- not a parsing gap here)
+    HydraTwentySixHD = 323  # "Hydra TwentySix HD"
+    HydraFiftyTwoHD = 324  # "Hydra FiftyTwo HD"
+    RedSeaMAX13 = 325  # "RedSea MAX 13"
+    RedSeaMAX26 = 326  # "RedSea MAX 26"
+    PrimeSixteenHD = 333  # "Prime Sixteen HD"
+    HydraThirtyTwoHD = 334  # "Hydra ThirtyTwo HD"
+    HydraSixtyFourHD = 335  # "Hydra SixtyFour HD"
+    PrimeSixteenHdFw = 339  # "16 Freshwater"
+    PrimeSixteenHdFuge = 340  # "16 Fuge"
+    PrimeSixteenHdSol = 341  # "16 Sol"
+    PrimeFuge = 342  # "Prime Fuge"
+    Hydra32HDFreshwater = 344  # "Hydra 32HD Freshwater" (app's own internal enum name: Quesarito)
+    Thundervolt = 345  # "Thundervolt" (app's own internal enum name: NachosBellGrande)
+    Plumbus = 346  # "Plumbus"
+    Blade = 347  # "Blade" (app's own internal enum name: Saddle)
+    Leap = 349  # "Leap" (app's own internal enum name: BeanBurrito)
+    MXM = 350  # "MXM" (app's own internal enum name: Cowboy)
+    BladeD = 360  # "Blade" (app's own internal enum name: SaddleD)
+    BladeCoralGlow = 361  # "Blade Coral Glow" (app's own internal enum name: SaddleA)
+    BladeCoralGrow = 362  # "Blade Coral Grow" (app's own internal enum name: SaddleM)
+    BladeFreshwater = 363  # "Blade Freshwater" (app's own internal enum name: SaddleF)
+    BladeRefugium = 364  # "Blade Refugium" (app's own internal enum name: SaddleR)
+    BladeGrowPlus = 365  # "Blade Grow+" (app's own internal enum name: SaddleG)
+    BladeGloFish = 368  # "Blade GloFish" (app's own internal enum name: SaddleGF)
+    HydraEdge44HD = 371  # "Hydra Edge 44HD" (app's own internal enum name: AlfalfaRS)
+    HydraEdge68HD = 372  # "Hydra Edge 68HD" (app's own internal enum name: AlfalfaRL)
+    HydraEdge44HDFreshwater = 373  # "Hydra Edge 44HD Freshwater" (app's own internal enum name: AlfalfaFS)
+    HydraEdge68HDFreshwater = 374  # "Hydra Edge 68HD Freshwater" (app's own internal enum name: AlfalfaFL)
+    Quantum160 = 396  # "Quantum 160" (app's own internal enum name: Coffee1)
+    Quantum220300 = 397  # "Quantum 220/300" (app's own internal enum name: Coffee2)
+    Hera = 512  # "Hera" (app's own internal enum name: CrunchyTaco)
+    HeraBackplane = 513  # "Hera Backplane" (app's own internal enum name: SoftTaco)
+    HeraPHSensor = 514  # "Hera pH Sensor" (app's own internal enum name: LuxeBox)
+    HeraDissolvedOxygenSensor = 515  # "Hera Dissolved Oxygen Sensor" (app's own internal enum name: DiabloSauce)
+    HeraFluidMonitoringModule = 516  # "Hera Fluid Monitoring Module" (app's own internal enum name: FlaminHotRice)
+    HeraIOModule = 517  # "Hera I/O Module" (app's own internal enum name: CinnabonDelights)
+    HeraORPSensor = 518  # "Hera ORP sensor" (app's own internal enum name: BajaBlast)
+    HeraSalinitySensor = 519  # "Hera Salinity Sensor" (app's own internal enum name: CantinaChicken)
+    HeraSwitchedPowerModule = 520  # "Hera Switched Power Module" (app's own internal enum name: VeggieBowl)
+    RFModDev = 61441  # "RF Mod Dev"
+    WiFiModDev = 61442  # "WiFi Mod Dev"
+    ETMRFModProd = 61443  # "ETM RF Mod Prod"
+    WiFiModBreakout = 61444  # "WiFi Mod Breakout"
+    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).
 MODEL_MANUFACTURER: dict[Model, str] = {
     Model.Unknown: "Unknown",
+
+    # EcoTech Marine
     Model.VorTechMP10wES: "EcoTech Marine",
     Model.VorTechMP10wQD: "EcoTech Marine",
-    Model.VorTechMP40wES: "EcoTech Marine",
-    Model.VorTechMP40wQD: "EcoTech Marine",
-    Model.VorTechMP40wG3QD: "EcoTech Marine",
-    Model.VorTechMP60wES: "EcoTech Marine",
-    Model.VorTechMP60wQD: "EcoTech Marine",
     Model.RadionXR30w: "EcoTech Marine",
     Model.RadionXR30wG2: "EcoTech Marine",
     Model.RadionXR30wPro: "EcoTech Marine",
@@ -135,6 +197,17 @@ MODEL_MANUFACTURER: dict[Model, str] = {
     Model.RadionXR30wG4Pro: "EcoTech Marine",
     Model.RadionXR30wFWPro: "EcoTech Marine",
     Model.RadionXR30wPrototype: "EcoTech Marine",
+    Model.VorTechMP40wES: "EcoTech Marine",
+    Model.VorTechMP40wQD: "EcoTech Marine",
+    Model.VorTechMP40wG3QD: "EcoTech Marine",
+    Model.VorTechMP60wES: "EcoTech Marine",
+    Model.VorTechMP60wQD: "EcoTech Marine",
+    Model.VectraM1: "EcoTech Marine",
+    Model.VectraL1: "EcoTech Marine",
+    Model.VectraS1: "EcoTech Marine",
+    Model.VectraS2: "EcoTech Marine",
+    Model.VectraM2: "EcoTech Marine",
+    Model.VectraL2: "EcoTech Marine",
     Model.RadionXR15wG3Pro: "EcoTech Marine",
     Model.RadionXR15wFW: "EcoTech Marine",
     Model.RadionXR15wG4Pro: "EcoTech Marine",
@@ -147,18 +220,75 @@ MODEL_MANUFACTURER: dict[Model, str] = {
     Model.RadionXR15wG6Blue: "EcoTech Marine",
     Model.RadionXR30wG5Pro: "EcoTech Marine",
     Model.RadionXR30wG5Blue: "EcoTech Marine",
-    Model.VectraM1: "EcoTech Marine",
-    Model.VectraL1: "EcoTech Marine",
-    Model.VectraS1: "EcoTech Marine",
-    Model.VectraS2: "EcoTech Marine",
-    Model.VectraM2: "EcoTech Marine",
-    Model.VectraL2: "EcoTech Marine",
+    Model.RadionXR30wG5FW: "EcoTech Marine",
+    Model.RadionXR30wG6Pro: "EcoTech Marine",
+    Model.RadionXR30wG6Blue: "EcoTech Marine",
+    Model.VersaVX1: "EcoTech Marine",
+    Model.Thundervolt: "EcoTech Marine",
+    Model.Leap: "EcoTech Marine",
+    Model.ETMRFModProd: "EcoTech Marine",
+
+    # AquaIllumination
     Model.Nero5: "AquaIllumination",
     Model.Nero3: "AquaIllumination",
-    Model.DosingPump: "AquaIllumination",
-    Model.Muffler: "Neptune Systems",   # confirmed explicitly in the decompile's manufacturer list
-    Model.Coffee1: "NYOS",               # confirmed explicitly (CoffeeV1 branch)
-    Model.Coffee2: "NYOS",
+    Model.Nero7: "AquaIllumination",
+    Model.Orbit2: "AquaIllumination",
+    Model.Orbit4: "AquaIllumination",
+    Model.Axis20: "AquaIllumination",
+    Model.Axis40: "AquaIllumination",
+    Model.Axis90: "AquaIllumination",
+    Model.Axis200: "AquaIllumination",
+    Model.SproutSL1: "AquaIllumination",
+    Model.EnvironmentalSensor: "AquaIllumination",
+    Model.Prime: "AquaIllumination",
+    Model.PrimeHD: "AquaIllumination",
+    Model.PrimeFW: "AquaIllumination",
+    Model.HydraTwentySixHD: "AquaIllumination",
+    Model.HydraFiftyTwoHD: "AquaIllumination",
+    Model.RedSeaMAX13: "AquaIllumination",
+    Model.RedSeaMAX26: "AquaIllumination",
+    Model.PrimeSixteenHD: "AquaIllumination",
+    Model.HydraThirtyTwoHD: "AquaIllumination",
+    Model.HydraSixtyFourHD: "AquaIllumination",
+    Model.PrimeSixteenHdFw: "AquaIllumination",
+    Model.PrimeSixteenHdFuge: "AquaIllumination",
+    Model.PrimeSixteenHdSol: "AquaIllumination",
+    Model.PrimeFuge: "AquaIllumination",
+    Model.Hydra32HDFreshwater: "AquaIllumination",
+    Model.Plumbus: "AquaIllumination",
+    Model.Blade: "AquaIllumination",
+    Model.BladeD: "AquaIllumination",
+    Model.BladeCoralGlow: "AquaIllumination",
+    Model.BladeCoralGrow: "AquaIllumination",
+    Model.BladeFreshwater: "AquaIllumination",
+    Model.BladeRefugium: "AquaIllumination",
+    Model.BladeGrowPlus: "AquaIllumination",
+    Model.BladeGloFish: "AquaIllumination",
+    Model.HydraEdge44HD: "AquaIllumination",
+    Model.HydraEdge68HD: "AquaIllumination",
+    Model.HydraEdge44HDFreshwater: "AquaIllumination",
+    Model.HydraEdge68HDFreshwater: "AquaIllumination",
+    Model.RFModDev: "AquaIllumination",
+    Model.WiFiModDev: "AquaIllumination",
+    Model.WiFiModBreakout: "AquaIllumination",
+    Model.Passthrough: "AquaIllumination",
+
+    # Neptune Systems
+    Model.DoseQD: "Neptune Systems",
+    Model.MXM: "Neptune Systems",
+    Model.Hera: "Neptune Systems",
+    Model.HeraBackplane: "Neptune Systems",
+    Model.HeraPHSensor: "Neptune Systems",
+    Model.HeraDissolvedOxygenSensor: "Neptune Systems",
+    Model.HeraFluidMonitoringModule: "Neptune Systems",
+    Model.HeraIOModule: "Neptune Systems",
+    Model.HeraORPSensor: "Neptune Systems",
+    Model.HeraSalinitySensor: "Neptune Systems",
+    Model.HeraSwitchedPowerModule: "Neptune Systems",
+
+    # NYOS
+    Model.Quantum160: "NYOS",
+    Model.Quantum220300: "NYOS",
 }
 
 
@@ -276,6 +406,9 @@ class C2Attribute(IntEnum):
     LunarPhasesEnabled = 907
     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
     # 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

{python_mobius-0.4.2 → python_mobius-0.4.4}/src/mobius/device.py

@@ -637,10 +637,12 @@ class MobiusDevice:
         a real, known thing worth
         checking, using this exact same drift computation
         (local_time_seconds - device_reported_seconds). See
-        DeviceTimeInfo's docstring for the important caveat that this
-        doesn't directly explain schedule-interpolation mismatches (the
-        app's own schedule lookup uses the phone/tank clock, not either
-        of these), but is still worth ruling out as a general health check.
+        DeviceTimeInfo's docstring for the important caveat that these
+        two specific attributes don't directly explain a schedule-
+        interpolation mismatch by themselves (LocalTime, a different
+        attribute entirely, is what actually matters there -- see
+        get_device_local_date()), but real device clock drift is still
+        worth ruling out as a general health check.
         """
         import datetime as _datetime
         now = int(_datetime.datetime.now().timestamp())
@@ -668,6 +670,52 @@ class MobiusDevice:
             rtc_drift_seconds=(now - device_rtc) if device_rtc is not None else None,
         )
 
+    async def get_device_local_date(self) -> Optional["datetime.date"]:
+        """
+        The gateway device's own, ALREADY TIMEZONE-ADJUSTED idea of what
+        calendar date it currently is -- confirmed, not assumed, to be
+        the actual source get_current_light_intensities() needs for its
+        own lunar-phase calculation, by tracing the real app's own call
+        chain directly: VPointScheduleView's own lunar.percentReduction()
+        call passes vPointScheduleView2.time.date(), where that `time`
+        is set via Tank.getDateTime() -- which is populated by
+        DateTime.parseRequest(), which reads Epoch (201) AND LocalTime
+        (207) directly off the connected gateway device itself, NOT
+        computed from the phone's own system clock at all. An earlier
+        version of this library's own DeviceTimeInfo docstring claimed
+        the opposite ("the app's own schedule interpolation uses the
+        phone/tank's own clock, NOT either of these device-reported
+        values") -- that claim was wrong specifically for the lunar
+        calculation, confirmed by a real, reported production mismatch
+        (this library showing the wrong lunar phase for hours at a
+        stretch, spanning exactly the window between local calendar
+        midnight and whenever the device's own reported date actually
+        rolled over) that this method's own existence now fixes.
+
+        LocalTime specifically, not Epoch: the device itself already
+        applies its own configured timezone offset when reporting this
+        value (confirmed by the app's own DateTime constructor -- it
+        derives its own UTC offset as Epoch minus LocalTime, meaning
+        LocalTime is Epoch already shifted by that same offset), so it
+        can be treated directly as an offset-adjusted "local-looking"
+        Unix timestamp -- no separate timezone lookup or arithmetic
+        needed on this library's own side at all.
+
+        Returns None if this attribute isn't available for any reason
+        (unsupported, or a soft read failure) -- callers should fall
+        back to their own local system date in that case, same as
+        get_current_light_intensities() itself does.
+        """
+        try:
+            raw = await self.get_attribute(C2Attribute.LocalTime)
+        except Exception:
+            return None
+        if not raw:
+            return None
+        import datetime as _datetime
+        local_time_seconds = struct.unpack("<I", raw[0])[0]
+        return _datetime.datetime.fromtimestamp(local_time_seconds, tz=_datetime.timezone.utc).date()
+
     async def get_own_mesh_address(self) -> Optional[bytes]:
         """
         Fetches MeshLocalAddresses (1005) -- THIS device's own Thread
@@ -1464,16 +1512,27 @@ class MobiusDevice:
                                               now: Optional["datetime.datetime"] = None) -> LightIntensityResult:
         """
         Replicates what the app actually shows as "current intensity": fetch
-        the schedule, linearly interpolate it for the given time (defaults
-        to local system time -- NOT read from the device; the app itself
-        uses the tank's configured timezone against phone-local time, not a
-        device clock read, so this mirrors that behavior), then apply
-        whichever scalar the app itself would apply on top -- confirmed via
-        reverse engineering the app's own exact branching:
+        the schedule, linearly interpolate it for the given time (minute_of_day
+        defaults to local system time if not given -- pass it explicitly with
+        a timezone-aware value if the caller has one, since this library has
+        no way to know the correct timezone on its own), then apply whichever
+        scalar the app itself would apply on top -- confirmed via reverse
+        engineering the app's own exact branching:
 
           - dusk-to-night segment (see is_night_segment()) AND lunar phases
             enabled -> lunar_percent_reduction(date) in place of the normal
-            schedule intensity
+            schedule intensity. The date used here specifically is
+            get_device_local_date()'s own result (the connected gateway's
+            own reported LocalTime attribute), falling back to `now`'s own
+            date only if that read fails -- confirmed by tracing the real
+            app's own call chain directly (see get_device_local_date()'s
+            own docstring for the full trace) that this is genuinely a
+            DEVICE-reported value, not phone/system-local time at all,
+            unlike everything else this method computes. A real, reported
+            production mismatch (this library showing the wrong lunar
+            phase for hours at a stretch, spanning exactly the gap between
+            local calendar midnight and whenever the device's own reported
+            date actually rolled over) is what confirmed this.
           - dusk-to-night segment, lunar not enabled -> scalar = 1.0
             (full/unreduced)
           - otherwise (normal daytime) -> the schedule-level master
@@ -1491,13 +1550,17 @@ class MobiusDevice:
 
         `.diagnostics` also includes "is_night_segment", "lunar_enabled",
         "scalar_source" (one of "lunar"/"night_no_lunar"/
-        "schedule_intensity"), and "scalar" (the actual final multiplier
-        applied) -- added specifically to make it possible to tell which
-        branch was taken and why, since a mismatch against the app's own
-        displayed value could stem from either is_night_segment()
-        misjudging this schedule's specific point structure, or
-        get_lunar_enabled() reading incorrectly, and those need to be told
-        apart with real data rather than guessed at.
+        "schedule_intensity"), "scalar" (the actual final multiplier
+        applied), and, specifically for the "lunar" case, "lunar_date"
+        (the actual date used for that calculation) and
+        "lunar_date_source" (one of "device"/"local_fallback") -- added
+        specifically to make it possible to tell which branch was taken
+        and why, since a mismatch against the app's own displayed value
+        could stem from is_night_segment() misjudging this schedule's
+        specific point structure, get_lunar_enabled() reading
+        incorrectly, or (confirmed now to be a real, genuine possibility)
+        the wrong date being used for the lunar calculation itself, and
+        those need to be told apart with real data rather than guessed at.
         """
         import datetime as _datetime
         if now is None:
@@ -1509,10 +1572,17 @@ class MobiusDevice:
         raw_intensities = interpolate_light_schedule(points, minute_of_day)
 
         night_segment = is_night_segment(points, minute_of_day)
+        lunar_date = None
+        lunar_date_source = None
         if night_segment:
             lunar_enabled = await self.get_lunar_enabled(which)
             if lunar_enabled:
-                scalar = lunar_percent_reduction(now.date())
+                lunar_date = await self.get_device_local_date()
+                lunar_date_source = "device"
+                if lunar_date is None:
+                    lunar_date = now.date()
+                    lunar_date_source = "local_fallback"
+                scalar = lunar_percent_reduction(lunar_date)
                 scalar_source = "lunar"
             else:
                 scalar = 1.0
@@ -1533,6 +1603,8 @@ class MobiusDevice:
             "lunar_enabled": lunar_enabled,
             "scalar_source": scalar_source,
             "scalar": scalar,
+            "lunar_date": lunar_date,
+            "lunar_date_source": lunar_date_source,
         })
 
     async def get_current_light_percentages(self, which: int = 1,

{python_mobius-0.4.2 → python_mobius-0.4.4}/src/mobius/device_status.py

@@ -99,12 +99,15 @@ class DeviceTimeInfo:
     clock, treating a large discrepancy as a real, known failure mode --
     this isn't speculative, it's the exact same check the app runs.
 
-    Note: the app's own schedule interpolation uses
-    the phone/tank's own clock, NOT either of
-    these device-reported values -- so this doesn't directly explain a
-    schedule-interpolation mismatch by itself, but real device clock drift
-    is still worth ruling out as a general health signal, exactly as the
-    app's own troubleshooting tool treats it.
+    Note: this doesn't include LocalTime (207) -- see
+    get_device_local_date()'s own docstring for why that one specific
+    attribute is genuinely different (it's what the app's own lunar-
+    phase calculation actually uses, confirmed by tracing the app's own
+    call chain directly), unlike Epoch/RTCTime here, which the app's
+    own schedule interpolation itself does NOT use (an earlier version
+    of this docstring incorrectly extended that same "not used for
+    schedule purposes" claim to LocalTime too, before that call chain
+    had actually been traced).
     """
     device_epoch: Optional[int]  # raw UNIX timestamp reported by the device
     device_rtc: Optional[int]

{python_mobius-0.4.2 → python_mobius-0.4.4}/src/mobius/relay.py

@@ -177,12 +177,52 @@ class RelayedMobiusDevice(MobiusDevice):
         embedded in its payload (confirmed via reverse engineering:
         coapRequest.getToken() == coapResponse.getToken()) -- never by
         this outer frame's own message ID.
+
+        Retries exactly once on a timeout before actually raising --
+        confirmed via reverse engineering the app's own request-timeout
+        handling: it never treats a single timed-out relay round-trip as
+        a real failure, always transparently retrying (fresh send, same
+        request) once first, only surfacing a failure if the retry ALSO
+        times out. A relayed round-trip crosses BLE (to the gateway) and
+        then the Thread mesh itself (gateway to target and back) -- a
+        single dropped/delayed packet somewhere in that longer path is
+        evidently common enough that the app was built assuming it will
+        happen regularly, not as an edge case. Each attempt gets its own
+        fresh CoAP token (this library generates one per call already,
+        not tied to a single request object the way the app's own retry
+        reuses one) -- deliberately, so a late, delayed response to the
+        first, abandoned attempt can never be mismatched against the
+        retry's own, separate wait.
         """
         if not self.gateway.is_connected:
             raise IOError(
                 f"gateway device is not connected -- cannot relay to {self.peer.serial!r} through it"
             )
 
+        last_timeout_token: Optional[int] = None
+        for attempt in (1, 2):
+            try:
+                return await self._relay_attempt(inner_request_frame, is_retry=(attempt == 2))
+            except asyncio.TimeoutError as err:
+                last_timeout_token = err.args[0] if err.args else None
+                if attempt == 1 and self.debug:
+                    print(f"    [relay debug] timed out waiting {self.timeout}s for "
+                          f"{self.peer.serial!r} -- retrying once before giving up")
+                continue
+
+        raise IOError(
+            f"timed out waiting {self.timeout}s for a relayed response from target "
+            f"{self.peer.serial!r} (no CoAP indication received for token {last_timeout_token}, "
+            f"even after one retry)"
+        )
+
+    async def _relay_attempt(self, inner_request_frame: bytes, is_retry: bool) -> ParsedFrame:
+        """One full send-and-await cycle for _relay() -- split out so
+        _relay() itself can retry it once on a timeout without
+        duplicating this whole body. Raises asyncio.TimeoutError itself
+        (not wrapped in IOError) specifically so _relay() can catch just
+        that case to decide whether to retry; every other exception here
+        propagates as-is, unwrapped, straight out of _relay() too."""
         token = next_coap_token()
         # Confirmed always GET regardless of the inner operation -- see
         # this module's docstring for why.
@@ -193,7 +233,8 @@ class RelayedMobiusDevice(MobiusDevice):
         outer_frame = build_frame(OPGROUP_C2CI_REQUEST, COAP_OPCODE, coap_payload, outer_message_id)
 
         if self.debug:
-            print(f"    [relay debug] inner request frame ({len(inner_request_frame)}B): "
+            retry_note = " (retry)" if is_retry else ""
+            print(f"    [relay debug] inner request frame{retry_note} ({len(inner_request_frame)}B): "
                   f"{inner_request_frame.hex()}")
             print(f"    [relay debug] target address: {self.peer.address.hex()}  token: {token}")
             print(f"    [relay debug] outer request frame ({len(outer_frame)}B): {outer_frame.hex()}")
@@ -220,10 +261,7 @@ class RelayedMobiusDevice(MobiusDevice):
             coap_response = await asyncio.wait_for(coap_future, timeout=self.timeout)
         except asyncio.TimeoutError:
             self.gateway._pending_coap_tokens.pop(token, None)
-            raise IOError(
-                f"timed out waiting {self.timeout}s for a relayed response from target "
-                f"{self.peer.serial!r} (no CoAP indication received for token {token})"
-            )
+            raise asyncio.TimeoutError(token) from None
         finally:
             if self.debug:
                 self.gateway.on_any_frame = previous_hook

{python_mobius-0.4.2 → python_mobius-0.4.4}/tests/test_device_time.py

@@ -5,6 +5,7 @@ device-clock-drift check confirmed real via the app's own
 under Troubleshoot.
 """
 
+import datetime
 import struct
 import time
 
@@ -123,3 +124,61 @@ async def test_get_device_time_info_unsigned_wraparound():
 
     assert info.device_epoch == high_bit_set_value
     assert info.device_epoch > 0  # not decoded as a negative signed int
+
+
+# --------------------------------------------------------------------------
+# get_device_local_date() -- a genuinely different attribute (LocalTime,
+# 207) from Epoch/RTCTime above. See its own docstring in device.py for
+# the full trace confirming this is the actual date source the real app
+# itself uses for its own lunar-phase calculation -- these tests cover
+# just the raw LocalTime -> date conversion in isolation, separate from
+# test_light_intensity_branching.py's own end-to-end coverage of how
+# get_current_light_intensities() actually uses it.
+# --------------------------------------------------------------------------
+
+@pytest.mark.asyncio
+async def test_get_device_local_date_converts_local_time_correctly():
+    device = MobiusDevice(_fake_ble_device())
+    # LocalTime is already device-timezone-adjusted -- treated as a
+    # "local-looking" UTC timestamp, per this method's own docstring.
+    local_time_value = int(datetime.datetime(2026, 3, 15, 23, 30, tzinfo=datetime.timezone.utc).timestamp())
+
+    async def fake_get_attribute(attr_id, index=0, count=1):
+        if attr_id == C2Attribute.LocalTime:
+            return [struct.pack("<I", local_time_value)]
+        raise AssertionError(f"unexpected attribute: {attr_id}")
+
+    device.get_attribute = fake_get_attribute
+    result = await device.get_device_local_date()
+
+    assert result == datetime.date(2026, 3, 15)
+
+
+@pytest.mark.asyncio
+async def test_get_device_local_date_fails_soft_when_unsupported():
+    """Callers (get_current_light_intensities()) depend on this
+    returning None cleanly, not raising, so they can fall back to their
+    own local date -- not every device necessarily supports this
+    attribute."""
+    device = MobiusDevice(_fake_ble_device())
+
+    async def fake_get_attribute(attr_id, index=0, count=1):
+        raise IOError("unsupported attribute")
+
+    device.get_attribute = fake_get_attribute
+    result = await device.get_device_local_date()
+
+    assert result is None
+
+
+@pytest.mark.asyncio
+async def test_get_device_local_date_fails_soft_on_empty_response():
+    device = MobiusDevice(_fake_ble_device())
+
+    async def fake_get_attribute(attr_id, index=0, count=1):
+        return []
+
+    device.get_attribute = fake_get_attribute
+    result = await device.get_device_local_date()
+
+    assert result is None

{python_mobius-0.4.2 → python_mobius-0.4.4}/tests/test_light_intensity_branching.py

@@ -52,6 +52,8 @@ async def test_night_segment_with_lunar_enabled_uses_lunar_reduction():
             return _night_schedule()
         if attr_id == C2Attribute.LunarPhasesEnabled:
             return [bytes([1])]
+        if attr_id == C2Attribute.LocalTime:
+            return None  # deliberately unavailable -- falls back to now's own date
         raise AssertionError(f"unexpected attribute during night+lunar test: {attr_id}")
 
     device.get_attribute = fake_get_attribute
@@ -72,6 +74,52 @@ async def test_night_segment_with_lunar_enabled_uses_lunar_reduction():
     assert result.diagnostics["lunar_enabled"] is True
     assert result.diagnostics["scalar_source"] == "lunar"
     assert result.diagnostics["scalar"] == pytest.approx(0.0)
+    assert result.diagnostics["lunar_date_source"] == "local_fallback"
+    assert result.diagnostics["lunar_date"] == now.date()
+
+
+@pytest.mark.asyncio
+async def test_night_segment_with_lunar_uses_the_devices_own_reported_date():
+    """The actual, real, reported production bug this fixes: an earlier
+    version of this method always used `now`'s own date for the lunar
+    calculation, having incorrectly assumed (based on an earlier,
+    incomplete trace) that the real app does the same. It doesn't --
+    confirmed by tracing the real app's own call chain all the way
+    through to DateTime.parseRequest(), which reads Epoch AND LocalTime
+    directly off the connected gateway device itself. This test proves
+    the fix actually uses that device-reported date, not `now`'s own --
+    by making them deliberately, unambiguously disagree (device says
+    one date, `now` says a different one), and confirming the device's
+    own date is what the lunar reduction is actually computed from."""
+    device = MobiusDevice(_fake_ble_device())
+
+    # A real new-moon date the device itself reports, deliberately
+    # different from `now`'s own date below.
+    device_date = datetime.date(2026, 1, 18)
+    device_local_time = int(datetime.datetime(
+        2026, 1, 18, 22, 30, tzinfo=datetime.timezone.utc,
+    ).timestamp())
+
+    async def fake_get_attribute(attr_id, index=0, count=1):
+        if attr_id == C2Attribute.Schedule1:
+            return _night_schedule()
+        if attr_id == C2Attribute.LunarPhasesEnabled:
+            return [bytes([1])]
+        if attr_id == C2Attribute.LocalTime:
+            return [device_local_time.to_bytes(4, "little")]
+        raise AssertionError(f"unexpected attribute: {attr_id}")
+
+    device.get_attribute = fake_get_attribute
+    # A DIFFERENT date than what the device itself reports above --
+    # if this were used instead, the lunar reduction would come out
+    # different (a real, non-zero value on this specific date, not the
+    # 0.0 a new moon gives).
+    now = datetime.datetime(2026, 3, 3, 20, 0)
+    result = await device.get_current_light_intensities(minute_of_day=1350, now=now)
+
+    assert result.diagnostics["lunar_date_source"] == "device"
+    assert result.diagnostics["lunar_date"] == device_date
+    assert result[VisualID.MoonlightWhite] == pytest.approx(0.0)  # new moon on the DEVICE's own date
 
 
 @pytest.mark.asyncio

python_mobius-0.4.4/tests/test_manufacturer_lookup.py

@@ -0,0 +1,59 @@
+from mobius import Model, MODEL_MANUFACTURER, manufacturer_for_model
+
+
+def test_vortech_is_ecotech_marine():
+    assert manufacturer_for_model(Model.VorTechMP40wG3QD) == "EcoTech Marine"
+
+
+def test_radion_is_ecotech_marine():
+    assert manufacturer_for_model(Model.RadionXR15wG6Pro) == "EcoTech Marine"
+
+
+def test_nero_is_aquaillumination():
+    assert manufacturer_for_model(Model.Nero5) == "AquaIllumination"
+
+
+def test_ai_prime_and_axis_are_aquaillumination():
+    """Real, confirmed via actual hardware -- a real user's own AI Prime
+    16HD and AI Axis 40 (both AquaIllumination-brand devices) previously
+    showed as "unknown(333)"/"unknown(262)" entirely, since neither model
+    value existed in this library's own Model enum yet."""
+    assert manufacturer_for_model(Model.PrimeSixteenHD) == "AquaIllumination"
+    assert manufacturer_for_model(Model.Axis40) == "AquaIllumination"
+
+
+def test_coffee_is_nyos():
+    assert manufacturer_for_model(Model.Quantum160) == "NYOS"
+    assert manufacturer_for_model(Model.Quantum220300) == "NYOS"
+
+
+def test_muffler_is_neptune_systems():
+    assert manufacturer_for_model(Model.DoseQD) == "Neptune Systems"
+
+
+def test_dosing_pump_versa_is_ecotech_marine():
+    """A real, confirmed correction: an earlier version of this table
+    had Model.VersaVX1 ("Versa VX-1") as AquaIllumination, based on a
+    name-pattern guess rather than the app's own decompiled
+    getManufacturer()/isEtm() logic directly -- "Versa" dosing pumps
+    are a real, well-known EcoTech Marine product line, matching what
+    that logic actually says (ordinal 47, one of its own explicit,
+    hardcoded EcoTech Marine special cases)."""
+    assert manufacturer_for_model(Model.VersaVX1) == "EcoTech Marine"
+
+
+def test_every_model_has_a_manufacturer_entry():
+    """MODEL_MANUFACTURER is meant to be complete, not a curated subset
+    -- confirmed directly against the app's own decompiled Model enum,
+    covering all ~98 real entries (not the food-themed internal
+    placeholder names some of them have -- those aren't fake, just
+    obfuscated; see this module's own Model docstring). This is the
+    backstop: if a future addition to Model itself is ever forgotten
+    here, this catches it immediately rather than silently returning
+    None the next time some real device happens to report that model."""
+    missing = [m for m in Model if m not in MODEL_MANUFACTURER]
+    assert missing == []
+
+
+def test_none_model_returns_none():
+    assert manufacturer_for_model(None) is None

{python_mobius-0.4.2 → python_mobius-0.4.4}/tests/test_relay.py

@@ -133,6 +133,92 @@ class TestRelayedGetAttribute:
         with pytest.raises(IOError, match="timed out"):
             await relayed.get_attribute(C2Attribute.Epoch)
 
+    @pytest.mark.asyncio
+    async def test_retries_once_on_timeout_then_succeeds(self, connected_gateway):
+        """A real, confirmed production issue this addresses directly: a
+        relayed round-trip crosses BLE AND the Thread mesh, and a single
+        dropped/delayed packet somewhere in that longer path turned out
+        to be common enough that two lights lost data within seconds of
+        each other from single, transient relay timeouts -- confirmed
+        via reverse engineering that the real app never treats one timed-
+        out relay attempt as an actual failure, always retrying once
+        first. Simulates exactly that: the first attempt's own token
+        never gets a response, the retry's own (different) token does."""
+        relayed = RelayedMobiusDevice(connected_gateway, PEER, timeout=0.2)
+        inner_frame = _build_inner_get_response(C2Attribute.Epoch, index=0, value=struct.pack("<I", 1700000000))
+
+        call_count = 0
+
+        async def fake_send_frame(frame, message_id, wait_response=True, timeout=5.0):
+            nonlocal call_count
+            call_count += 1
+            assert wait_response is False
+            if call_count == 1:
+                return None  # first attempt: nothing ever arrives for its token
+            # second attempt (the retry): deliver the real response for
+            # ITS OWN token -- confirms each attempt truly gets a fresh
+            # one, not a reused/stale one from the first, abandoned try.
+            token = _extract_sent_token(frame)
+            indication_bytes = _build_indication_frame_bytes(inner_frame, token)
+            connected_gateway._on_rx_final(None, bytearray(indication_bytes))
+            return None
+
+        connected_gateway._send_frame = fake_send_frame
+
+        result = await relayed.get_attribute(C2Attribute.Epoch)
+
+        assert result == [struct.pack("<I", 1700000000)]
+        assert call_count == 2  # confirms a retry genuinely happened, not just luck
+
+    @pytest.mark.asyncio
+    async def test_raises_only_after_both_attempts_time_out(self, connected_gateway):
+        """The other half of the retry behavior: it's a single retry,
+        not unlimited -- if the retry ALSO times out, this must still
+        raise (not hang or retry forever), and the error message should
+        reflect that a retry was already attempted."""
+        relayed = RelayedMobiusDevice(connected_gateway, PEER, timeout=0.2)
+
+        call_count = 0
+
+        async def fake_send_frame(frame, message_id, wait_response=True, timeout=5.0):
+            nonlocal call_count
+            call_count += 1
+            return None  # never arrives, on either attempt
+
+        connected_gateway._send_frame = fake_send_frame
+
+        with pytest.raises(IOError, match="even after one retry"):
+            await relayed.get_attribute(C2Attribute.Epoch)
+
+        assert call_count == 2  # confirms exactly one retry happened, not zero or unlimited
+
+    @pytest.mark.asyncio
+    async def test_does_not_retry_a_malformed_response(self, connected_gateway):
+        """Only a TIMEOUT gets retried -- a response that actually
+        arrived, just malformed, is a different failure mode a retry
+        wouldn't help with (the same bad data would just arrive again),
+        so this should raise immediately, not after a second attempt."""
+        relayed = RelayedMobiusDevice(connected_gateway, PEER, timeout=0.2)
+
+        call_count = 0
+
+        async def fake_send_frame(frame, message_id, wait_response=True, timeout=5.0):
+            nonlocal call_count
+            call_count += 1
+            token = _extract_sent_token(frame)
+            # A real indication frame, but with garbage as the inner
+            # FSCI payload -- parse_frame() will reject this (bad CRC).
+            indication_bytes = _build_indication_frame_bytes(b"\x00\x00\x00\x00", token)
+            connected_gateway._on_rx_final(None, bytearray(indication_bytes))
+            return None
+
+        connected_gateway._send_frame = fake_send_frame
+
+        with pytest.raises(IOError, match="malformed"):
+            await relayed.get_attribute(C2Attribute.Epoch)
+
+        assert call_count == 1  # confirms no retry was attempted for this failure mode
+
     @pytest.mark.asyncio
     async def test_ignores_the_meaningless_opcode_25_confirm(self, connected_gateway):
         """Confirms a bare opcode-25 confirm (matching the real, confirmed

python_mobius-0.4.2/tests/test_manufacturer_lookup.py

@@ -1,26 +0,0 @@
-from mobius import Model, manufacturer_for_model
-
-
-def test_vortech_is_ecotech_marine():
-    assert manufacturer_for_model(Model.VorTechMP40wG3QD) == "EcoTech Marine"
-
-
-def test_radion_is_ecotech_marine():
-    assert manufacturer_for_model(Model.RadionXR15wG6Pro) == "EcoTech Marine"
-
-
-def test_nero_is_aquaillumination():
-    assert manufacturer_for_model(Model.Nero5) == "AquaIllumination"
-
-
-def test_coffee_is_nyos():
-    assert manufacturer_for_model(Model.Coffee1) == "NYOS"
-    assert manufacturer_for_model(Model.Coffee2) == "NYOS"
-
-
-def test_muffler_is_neptune_systems():
-    assert manufacturer_for_model(Model.Muffler) == "Neptune Systems"
-
-
-def test_none_model_returns_none():
-    assert manufacturer_for_model(None) is None