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

mobius/__init__.py

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

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

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,

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]

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.dist-info → python_mobius-0.4.4.dist-info}/METADATA

@@ -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.dist-info → python_mobius-0.4.4.dist-info}/RECORD

@@ -1,10 +1,10 @@
-mobius/__init__.py,sha256=BpkSMm-tv7BC2F_vWHd-jym24Hsmwfd_OSMeJa2FEfQ,5722
+mobius/__init__.py,sha256=3DdT6fMBcYJjlr_U1DMTJ3mHeoz_Ri-B9g8B8c9iAZo,5722
 mobius/cli.py,sha256=8XH-pVTX4KObzd0IOGXicT7KrcNEjm5xYZS8JOWfHDA,30726
 mobius/coap.py,sha256=eXf_-9heQD1UjLyqZU9KA-c0jB50NGzAd8D7d6kFMb0,10750
-mobius/constants.py,sha256=z_KrFev5vGD9-9lKn4J0nGVtzTmelGQ13bYlVcCdjm0,25217
+mobius/constants.py,sha256=mIMc2Xk9io4jt2i6EKaEGs2nrkHFdFm7ovoJR4kRctI,33377
 mobius/crc.py,sha256=kLtAYWZvLbo5_p9ep08ZlLg5Yah8Q2qq0IwTvqbBGW0,2700
-mobius/device.py,sha256=H5JGFtV90xu69jEOydMPqpj53e-5ws6TUVej0xd7WSg,79078
-mobius/device_status.py,sha256=p1l6RpCcg_G4p9nudhSo8MzBSgqkH8m5_0qrnjsFQ2k,8374
+mobius/device.py,sha256=TOT-hmlbrMjlJ7quZmm2plZC1ILxo67XtV7z9zUNoaA,83298
+mobius/device_status.py,sha256=ZlhZt5499l2tbA1tRvVoBLqakrexYboNZTDLptK0a3Y,8584
 mobius/discovery.py,sha256=LqHOEA_j1ZROuounn3PPmy8IEbpL6-N1TOW1MpoKg6A,11619
 mobius/frame.py,sha256=UNLTHuzVue5b6L4nv1hWJTSbn5k8lETWdsiL_52yI0Q,6141
 mobius/manufacturer.py,sha256=8-vBzckN8xmsPSMj5EWtOCXenbyQueoY5pnZHePgb_k,1937
@@ -12,10 +12,10 @@ mobius/mesh_address.py,sha256=PKQ-mm7Z4bY11ZnVmeWZO9EmOiAHp8hNtXceMGMs2tk,5940
 mobius/modifiers.py,sha256=zWJCsjaJ4TtwS1QgQoRFH-ve1mykuPWn5KX4YQpNqco,7215
 mobius/power.py,sha256=5l9ehjNCDrSsJjQkaU4M6pYnSMqw2FVF8Ogg6KIE5vQ,3844
 mobius/pump_status.py,sha256=RWTl8ZViCFDbiFU2mX-WAIH_cWhZOZ0M2B0oYXnPx3Y,1598
-mobius/relay.py,sha256=tMpV_67CYt9A1L_DPERzbqOgy3BOdG4NZpAG_IlefhY,16587
+mobius/relay.py,sha256=bo2uUV6HhHD_-LuH4CkuPJtnKGQGM6crmB6kLAU8i4E,18857
 mobius/schedule.py,sha256=d5iAHvKuFDwfbrSptPx6viiA_lj2qGfWhsZwM_Bpr1k,10974
-python_mobius-0.4.2.dist-info/METADATA,sha256=PBqNDTyqaF-wG4Q8YUZsMqsQ2TkBTFfOoUNKe0yYZG4,5952
-python_mobius-0.4.2.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-python_mobius-0.4.2.dist-info/entry_points.txt,sha256=Q2hlcek-bWm70zvd12v32essflPgC2su-dKDHAqbPoE,48
-python_mobius-0.4.2.dist-info/licenses/LICENSE,sha256=7a72Msu2Q-TnoiFxemxEGkwafJGObk1W3rw9hzmyM_Y,17984
-python_mobius-0.4.2.dist-info/RECORD,,
+python_mobius-0.4.4.dist-info/METADATA,sha256=izBMnM3A_kuwJ8hzrWdSt6p7X4Gpxy3R1k4lkhhTj0I,5952
+python_mobius-0.4.4.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+python_mobius-0.4.4.dist-info/entry_points.txt,sha256=Q2hlcek-bWm70zvd12v32essflPgC2su-dKDHAqbPoE,48
+python_mobius-0.4.4.dist-info/licenses/LICENSE,sha256=7a72Msu2Q-TnoiFxemxEGkwafJGObk1W3rw9hzmyM_Y,17984
+python_mobius-0.4.4.dist-info/RECORD,,