python-mobius 0.8.1__tar.gz → 0.8.3__tar.gz

{python_mobius-0.8.1 → python_mobius-0.8.3}/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 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
+  schedule-level master dimmer, matching `get_schedule_intensity()`'s
+  own return value. Not the same as `intensities.diagnostics["scalar"]`,
+  which reflects whichever value is currently in effect (the lunar
+  reduction factor during a night segment, not the schedule intensity
+  setting itself).
+
 ## 0.8.1
 
 - Added `get_pump_reverse(primitive_type, params)`: whether a pump

{python_mobius-0.8.1 → python_mobius-0.8.3}/PKG-INFO

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

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

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

{python_mobius-0.8.1 → python_mobius-0.8.3}/src/mobius/device.py

@@ -145,6 +145,24 @@ class LightPollResult:
     schedule_points: list[SchedulePoint]
     intensities: LightIntensityResult
     used_batch: bool = True
+    # The same raw 0.0-1.0 schedule-level master dimmer
+    # get_schedule_intensity() itself returns -- already fetched and
+    # consumed internally by both this method and the individual-reads
+    # fallback below (it's one of process_light_intensities()'s own
+    # required inputs), but never actually propagated out to the
+    # caller until this field existed. NOT the same thing as
+    # intensities.diagnostics["scalar"]: that reflects whichever value
+    # is CURRENTLY driving the effective per-channel output at this
+    # exact moment (which, during a lunar-reduced night segment, is
+    # the lunar reduction factor instead) -- this field is always the
+    # device's own raw schedule-level intensity setting itself,
+    # regardless of whether it's the thing actually in effect right
+    # now. A caller wanting "what would the user's own intensity
+    # slider currently show" wants this field specifically, not
+    # diagnostics["scalar"]. None only if the underlying read itself
+    # failed and decode_schedule_intensity() had truly nothing to fall
+    # back to.
+    schedule_intensity: Optional[float] = None
 
 
 @dataclass
@@ -545,7 +563,9 @@ def decode_light_poll_from_batch(
         lunar_enabled, lunar_date, lunar_date_source,
         schedule_intensity, acclimation_info, insolation_active,
     )
-    return LightPollResult(schedule_points=points, intensities=intensities, used_batch=True)
+    return LightPollResult(
+        schedule_points=points, intensities=intensities, used_batch=True, schedule_intensity=schedule_intensity,
+    )
 
 
 def decode_pump_flow_range(min_raw: list[bytes], max_raw: list[bytes]) -> Optional[PumpFlowRange]:
@@ -3443,6 +3463,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/
@@ -3790,7 +3839,11 @@ class MobiusDevice:
         """
         points = await self.get_light_schedule(which)
         intensities = await self.get_current_light_intensities(which, minute_of_day, now)
-        return LightPollResult(schedule_points=points, intensities=intensities, used_batch=False)
+        schedule_intensity = await self.get_schedule_intensity(which)
+        return LightPollResult(
+            schedule_points=points, intensities=intensities, used_batch=False,
+            schedule_intensity=schedule_intensity,
+        )
 
     async def get_full_poll_batch(
         self, primitive: PrimitiveType, model: Optional[Model] = None,

{python_mobius-0.8.1 → python_mobius-0.8.3}/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.1 → python_mobius-0.8.3}/tests/test_light_poll_batch.py

@@ -94,13 +94,23 @@ async def test_filters_request_to_only_supported_attributes():
 async def test_night_segment_with_lunar_matches_individual_path_scenario():
     """Mirrors test_night_segment_with_lunar_enabled_uses_lunar_reduction()
     in test_light_intensity_branching.py exactly, but via the batch
-    path -- same schedule, same time, same expected result."""
+    path -- same schedule, same time, same expected result.
+
+    Also the exact regression scenario for a real, confirmed
+    production bug: a caller reading intensities.diagnostics["scalar"]
+    as if it were always schedule_intensity itself would get this
+    exactly backwards during a lunar-reduced night segment, since
+    "scalar" here reflects the lunar reduction factor currently in
+    effect, not the device's own raw schedule-level intensity setting
+    -- which is what result.schedule_intensity (this field) is
+    specifically for."""
     device = MobiusDevice(_fake_ble_device())
 
     async def fake_get_attributes_batch(requests):
         return [
             _av(C2Attribute.Schedule1, 0, *_night_schedule()),
             _av(C2Attribute.LunarPhasesEnabled, 0, bytes([1])),
+            _av(C2Attribute.Schedule1Intensity, 0, bytes.fromhex("8103")),  # 0x0381 = 897 -> 0.897
             # Epoch/LocalTime deliberately absent -- same as that test's
             # own LocalTime=None, forcing the local_fallback path.
         ]
@@ -108,7 +118,8 @@ async def test_night_segment_with_lunar_matches_individual_path_scenario():
     device.get_attributes_batch = fake_get_attributes_batch
     now = datetime.datetime(2026, 1, 18, 20, 0)
     result = await device.get_light_poll_batch(
-        minute_of_day=1350, now=now, supported_attribute_ids={C2Attribute.Schedule1, C2Attribute.LunarPhasesEnabled},
+        minute_of_day=1350, now=now,
+        supported_attribute_ids={C2Attribute.Schedule1, C2Attribute.LunarPhasesEnabled, C2Attribute.Schedule1Intensity},
     )
 
     assert result.used_batch is True
@@ -120,6 +131,12 @@ async def test_night_segment_with_lunar_matches_individual_path_scenario():
     assert intensities.diagnostics["scalar_source"] == "lunar"
     assert intensities.diagnostics["lunar_date_source"] == "local_fallback"
     assert intensities.diagnostics["lunar_date"] == now.date()
+    # The actual regression: schedule_intensity is the device's own raw
+    # 0.897 setting, genuinely different from whatever lunar-derived
+    # value diagnostics["scalar"] holds during this segment -- these
+    # must never be conflated.
+    assert result.schedule_intensity == pytest.approx(0.897)
+    assert result.schedule_intensity != intensities.diagnostics["scalar"]
 
 
 @pytest.mark.asyncio
@@ -147,6 +164,7 @@ async def test_daytime_matches_individual_path_scenario():
     assert intensities.diagnostics["is_night_segment"] is False
     assert intensities.diagnostics["scalar_source"] == "schedule_intensity"
     assert intensities.diagnostics["scalar"] == pytest.approx(0.808)
+    assert result.schedule_intensity == pytest.approx(0.808)
     # RoyalBlue=500 raw * 0.808 scalar
     assert intensities[VisualID.RoyalBlue] == pytest.approx(500 * 0.808)
 
@@ -180,6 +198,7 @@ async def test_batch_failure_falls_back_and_used_batch_is_false():
     # get_schedule_intensity()'s own 0.5 default, since Schedule1Intensity
     # itself returns None from the fake get_attribute() above.
     assert result.intensities.diagnostics["scalar"] == pytest.approx(0.5)
+    assert result.schedule_intensity == pytest.approx(0.5)
 
 
 @pytest.mark.asyncio