python-mobius 0.8.2__tar.gz → 0.8.4__tar.gz

{python_mobius-0.8.2 → python_mobius-0.8.4}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.8.4
+
+- Added `LightPollResult.lunar_enabled`/`lunar_phase_day`: the device's
+  own actual LunarPhasesEnabled setting and current lunar-cycle phase,
+  correct at any time of day. Not the same as
+  `intensities.diagnostics`'s own `lunar_enabled`/`lunar_date` keys,
+  which are only meaningful at night.
+
+## 0.8.3
+
+- Added `set_lunar_enabled(enabled)`. Confirmed byte-for-byte against
+  the app's own compiled bytecode: exactly what its "Lunar" chip (top
+  of the light schedule editor) writes when toggled.
+
 ## 0.8.2
 
 - Added `LightPollResult.schedule_intensity`: the device's own raw

{python_mobius-0.8.2 → python_mobius-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-mobius
-Version: 0.8.2
+Version: 0.8.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.8.2 → python_mobius-0.8.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "python-mobius"
-version = "0.8.2"
+version = "0.8.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.8.2 → python_mobius-0.8.4}/src/mobius/__init__.py

@@ -82,7 +82,7 @@ from .mob import (
     MAX_PUMP_PRIMITIVE_SIZE,
 )
 
-__version__ = "0.8.2"
+__version__ = "0.8.4"
 
 __all__ = [
     "__version__",

{python_mobius-0.8.2 → python_mobius-0.8.4}/src/mobius/device.py

@@ -47,7 +47,7 @@ from .schedule import (
 )
 from .scenes import Scene, ActiveScene, decode_configured_scenes, decode_active_scene
 from .modifiers import (
-    AcclimationInfo, is_night_segment, lunar_percent_reduction,
+    AcclimationInfo, is_night_segment, lunar_percent_reduction, lunar_days_into_phase,
 )
 from .power import ChannelPowerInfo, channel_percent_value
 from .pump_status import PumpFlowRange, BatteryBackupInfo, BoostedBatteryInfo
@@ -163,6 +163,35 @@ class LightPollResult:
     # failed and decode_schedule_intensity() had truly nothing to fall
     # back to.
     schedule_intensity: Optional[float] = None
+    # The device's own raw LunarPhasesEnabled (907) setting -- confirmed
+    # against the app's own "Lunar" chip, whose on/off state this
+    # matches exactly, at any time of day.
+    #
+    # A second, real, confirmed bug lived here before this field
+    # existed, same shape as schedule_intensity's own bug above:
+    # intensities.diagnostics["lunar_enabled"] is NOT this. Read
+    # process_light_intensities()'s own source: outside the night
+    # segment, it unconditionally sets lunar_enabled = None ("not
+    # checked/relevant outside the night segment" -- true for ITS OWN
+    # calculation, since the toggle only affects anything during the
+    # night segment, but not true for a caller that wants to know the
+    # device's own current setting regardless of time of day). A
+    # caller reading diagnostics["lunar_enabled"] during the day always
+    # gets None, even when the device's own toggle is genuinely on --
+    # this field is the one that's always correct, any time of day.
+    lunar_enabled: Optional[bool] = None
+    # The current lunar-cycle phase day (0-29, lunar_days_into_phase()'s
+    # own "days since new moon" convention), for a caller that wants to
+    # display the current moon phase -- not the same thing as the raw
+    # date this is computed from (which is only useful internally, for
+    # the schedule's own night-segment reduction calculation, and isn't
+    # exposed here at all). Falls back to today's local date when the
+    # device itself didn't provide one (Epoch/LocalTime unavailable),
+    # matching process_light_intensities()'s own "local_fallback"
+    # philosophy, so this is populated whenever `now` itself is valid --
+    # which it always is, since callers of get_light_poll_batch() are
+    # required to supply it.
+    lunar_phase_day: Optional[int] = None
 
 
 @dataclass
@@ -565,6 +594,7 @@ def decode_light_poll_from_batch(
     )
     return LightPollResult(
         schedule_points=points, intensities=intensities, used_batch=True, schedule_intensity=schedule_intensity,
+        lunar_enabled=lunar_enabled, lunar_phase_day=lunar_days_into_phase(lunar_date or now.date()),
     )
 
 
@@ -3463,6 +3493,35 @@ class MobiusDevice:
             return False
         return decode_lunar_enabled(raw)
 
+    async def set_lunar_enabled(self, enabled: bool) -> None:
+        """Writes LunarPhasesEnabled (907) -- confirmed byte-for-byte
+        against the app's own compiled bytecode (LunarInfo.smali's own
+        save() method): a single byte, the boolean enabled field stored
+        directly as 0 or 1, via the exact same SetC2AttrFsciRequest.
+        addAttribute() mechanism this library's own set_attribute()
+        uses. This is exactly what the app's own "Lunar" chip (top of
+        the light schedule editor) toggles: clicking it turns
+        lunar-phase night-time dimming on/off, and while enabled that
+        same chip also displays the current moon phase.
+
+        No group/broadcast involved -- confirmed by tracing
+        LightingFragment's own saveLunar(), which loops over every
+        light device in the tank and calls this same per-device,
+        ungrouped write on EACH one individually (not a single
+        mesh-wide broadcast the way set_time_to_now() works). The
+        app's own UI applies the same new value to every light in the
+        tank with that one tap, but the underlying wire mechanism is
+        still one ordinary, targeted write per device -- this method
+        only ever writes to the single device it's called on, matching
+        every other attribute write in this library.
+
+        No which/schedule parameter -- unlike Schedule1Intensity/
+        Schedule2Intensity, there's only ever a single
+        LunarPhasesEnabled attribute (confirmed: no LunarPhasesEnabled2
+        exists), so this applies to the light as a whole rather than to
+        either schedule individually."""
+        await self.set_attribute(C2Attribute.LunarPhasesEnabled, bytes([1 if enabled else 0]))
+
     async def get_acclimation_info(self) -> Optional[AcclimationInfo]:
         """
         Fetches all 4 acclimation attributes (AcclimationEnabled/Period/
@@ -3811,9 +3870,12 @@ class MobiusDevice:
         points = await self.get_light_schedule(which)
         intensities = await self.get_current_light_intensities(which, minute_of_day, now)
         schedule_intensity = await self.get_schedule_intensity(which)
+        lunar_enabled = await self.get_lunar_enabled(which)
+        lunar_date = await self.get_app_lunar_date()
         return LightPollResult(
             schedule_points=points, intensities=intensities, used_batch=False,
-            schedule_intensity=schedule_intensity,
+            schedule_intensity=schedule_intensity, lunar_enabled=lunar_enabled,
+            lunar_phase_day=lunar_days_into_phase(lunar_date or now.date()),
         )
 
     async def get_full_poll_batch(

{python_mobius-0.8.2 → python_mobius-0.8.4}/tests/test_device_control.py

@@ -64,6 +64,39 @@ async def test_reboot_propagates_a_write_failure():
         await device.reboot()
 
 
+async def test_set_lunar_enabled_writes_a_single_byte():
+    """Confirmed directly against the app's own behavior: LunarPhasesEnabled
+    (907) is exactly what the app's own "Lunar" chip (top of the light
+    schedule editor) toggles."""
+    device = MobiusDevice(_fake_ble_device())
+    captured = {}
+
+    async def fake_set_attribute(attr_id, value, index=0, reserved=b"\x00\x00"):
+        captured["attr_id"] = attr_id
+        captured["value"] = value
+
+    device.set_attribute = fake_set_attribute
+
+    await device.set_lunar_enabled(True)
+    assert captured["attr_id"] == C2Attribute.LunarPhasesEnabled
+    assert captured["value"] == bytes([1])
+
+    await device.set_lunar_enabled(False)
+    assert captured["value"] == bytes([0])
+
+
+async def test_set_lunar_enabled_propagates_a_write_failure():
+    device = MobiusDevice(_fake_ble_device())
+
+    async def fake_set_attribute(attr_id, value, index=0, reserved=b"\x00\x00"):
+        raise IOError("device returned FSCI status Failed setting attribute 907")
+
+    device.set_attribute = fake_set_attribute
+
+    with pytest.raises(IOError, match="Failed setting attribute 907"):
+        await device.set_lunar_enabled(True)
+
+
 @pytest.mark.asyncio
 async def test_reboot_all_writes_reset_soft_with_group_1_reserved_byte():
     """Confirmed via the app's own SettingsFragment.reboot() (the

{python_mobius-0.8.2 → python_mobius-0.8.4}/tests/test_light_poll_batch.py

@@ -11,12 +11,14 @@ invented data.
 """
 
 import datetime
+import struct
 
 import pytest
 from bleak.backends.device import BLEDevice
 
 from mobius import C2Attribute, AttributeValue, SupportedAttribute, VisualID, SchedulePoint
-from mobius.device import MobiusDevice
+from mobius.device import MobiusDevice, compute_app_lunar_date
+from mobius.modifiers import lunar_days_into_phase
 
 
 def _fake_ble_device():
@@ -137,26 +139,55 @@ async def test_night_segment_with_lunar_matches_individual_path_scenario():
     # must never be conflated.
     assert result.schedule_intensity == pytest.approx(0.897)
     assert result.schedule_intensity != intensities.diagnostics["scalar"]
+    # Same fields as the daytime test's own regression check -- here,
+    # where lunar reduction genuinely is in effect, they happen to
+    # agree with diagnostics, but they're still their own, independent
+    # fields (not simply forwarding diagnostics's own value).
+    assert result.lunar_enabled is True
+    # Epoch/LocalTime are deliberately absent in this scenario (see the
+    # comment above), so lunar_phase_day falls back to today's local
+    # date (matching process_light_intensities()'s own internal
+    # "local_fallback" philosophy) rather than being left unpopulated.
+    assert result.lunar_phase_day == lunar_days_into_phase(now.date())
 
 
 @pytest.mark.asyncio
 async def test_daytime_matches_individual_path_scenario():
     """Mirrors test_daytime_without_acclimation_uses_schedule_scalar_only
     in test_light_intensity_branching.py -- daytime, no acclimation
-    data supported, schedule_intensity present."""
+    data supported, schedule_intensity present.
+
+    Also the exact regression scenario for a second, real, confirmed
+    production bug (same shape as schedule_intensity's own above):
+    the device's own LunarPhasesEnabled toggle is genuinely on here
+    (matching a real user's own report -- the app's "Lunar" chip shows
+    enabled at all times of day, not just at night), but
+    process_light_intensities() itself unconditionally wipes
+    diagnostics["lunar_enabled"]/["lunar_date"] to None outside the
+    night segment (true for its own reduction-factor calculation,
+    since the toggle only affects anything during the night segment --
+    not true for a caller wanting the device's own current setting
+    regardless of time of day). result.lunar_enabled/lunar_date are
+    the fields that stay correct at any time of day."""
     device = MobiusDevice(_fake_ble_device())
 
     async def fake_get_attributes_batch(requests):
         return [
             _av(C2Attribute.Schedule1, 0, *_day_schedule()),
             _av(C2Attribute.Schedule1Intensity, 0, bytes.fromhex("2803")),  # 0x0328 = 808 -> 0.808
+            _av(C2Attribute.LunarPhasesEnabled, 0, bytes([1])),
+            _av(C2Attribute.Epoch, 0, struct.pack("<I", 1750000000)),
+            _av(C2Attribute.LocalTime, 0, struct.pack("<I", 1750000000)),
         ]
 
     device.get_attributes_batch = fake_get_attributes_batch
     now = datetime.datetime(2026, 6, 15, 12, 0)
     result = await device.get_light_poll_batch(
         minute_of_day=720, now=now,
-        supported_attribute_ids={C2Attribute.Schedule1, C2Attribute.Schedule1Intensity},
+        supported_attribute_ids={
+            C2Attribute.Schedule1, C2Attribute.Schedule1Intensity, C2Attribute.LunarPhasesEnabled,
+            C2Attribute.Epoch, C2Attribute.LocalTime,
+        },
     )
 
     assert result.used_batch is True
@@ -167,6 +198,13 @@ async def test_daytime_matches_individual_path_scenario():
     assert result.schedule_intensity == pytest.approx(0.808)
     # RoyalBlue=500 raw * 0.808 scalar
     assert intensities[VisualID.RoyalBlue] == pytest.approx(500 * 0.808)
+    # The actual regression: the device's own toggle is genuinely on,
+    # but diagnostics unconditionally wipes it to None outside the
+    # night segment -- these must never be conflated.
+    assert intensities.diagnostics["lunar_enabled"] is None
+    assert result.lunar_enabled is True
+    assert intensities.diagnostics["lunar_date"] is None
+    assert result.lunar_phase_day == lunar_days_into_phase(compute_app_lunar_date(1750000000, 1750000000))
 
 
 # --------------------------------------------------------------------------