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

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

@@ -1,5 +1,23 @@
 # Changelog
 
+## 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
+  schedule point's MaxSpeed/MinSpeed value currently encodes reverse
+  rotation. Only AlpacaV1 pumps support this -- every other primitive
+  type always returns None.
+- Added `reboot_all()`: soft-reboots every device on the mesh at
+  once, matching the app's own "Restart all Devices" tank setting.
+
 ## 0.8.0
 
 - Added `supported_pump_modes(primitive_type, closed_loop=None)`: the

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

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

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

@@ -28,6 +28,7 @@ from .constants import (
     SceneID, OperationState, FsciStatus,
     PumpMode, PumpOverrideMode, RampType, PumpParam, PUMP_PARAM_SIZE, PUMP_MODE_PARAMS,
     supported_pump_modes,
+    get_pump_reverse,
     FirmwareType, FIRMWARE_TYPE_LABELS_ETM, HardwareInfo,
     Color, COLOR_LABELS, RadioType, RADIO_TYPE_LABELS,
     MotorType, MOTOR_TYPE_LABELS, ProductType, PRODUCT_TYPE_LABELS,
@@ -81,7 +82,7 @@ from .mob import (
     MAX_PUMP_PRIMITIVE_SIZE,
 )
 
-__version__ = "0.8.0"
+__version__ = "0.8.2"
 
 __all__ = [
     "__version__",
@@ -103,6 +104,7 @@ __all__ = [
     "SceneID", "OperationState", "FsciStatus",
     "PumpMode", "PumpOverrideMode", "RampType", "PumpParam", "PUMP_PARAM_SIZE", "PUMP_MODE_PARAMS",
     "supported_pump_modes",
+    "get_pump_reverse",
     "FirmwareType", "FIRMWARE_TYPE_LABELS_ETM", "HardwareInfo",
     "Color", "COLOR_LABELS", "RadioType", "RADIO_TYPE_LABELS",
     "MotorType", "MOTOR_TYPE_LABELS", "ProductType", "PRODUCT_TYPE_LABELS",

{python_mobius-0.8.0 → python_mobius-0.8.2}/src/mobius/constants.py

@@ -819,6 +819,35 @@ def supported_pump_modes(
     return _PUMP_SUPPORTED_MODES.get(primitive_type, [])
 
 
+def get_pump_reverse(primitive_type: PrimitiveType, params: dict[PumpParam, int]) -> bool | None:
+    """Whether this point's own MaxSpeed/MinSpeed value currently
+    encodes reverse rotation -- ported from the decompiled app's own
+    PumpPrimitive.getReverse(), which checks each of a primitive's own
+    params for one whose slider settings say supportsReverse, then
+    reports whether that param's raw (unabs'd) value is negative.
+
+    Confirmed directly from the app's own PumpParameterEntry.sliderSettings():
+    MaxSpeed and MinSpeed both only ever set supportsReverse=true when
+    primitive_type is AlpacaV1 -- every other primitive type
+    (VorTechV1, PumpV1, TurtleV1, CoffeeV1, VectraV1) never supports
+    reverse at all, regardless of mode or the value's own sign. This
+    always returns None for those, same as the app's own getReverse()
+    falling through to null when no param on the primitive supports
+    it.
+
+    parse()/schedule_to_dict() already report MaxSpeed/MinSpeed as
+    signed ints as-is (see PumpPrimitiveValue.parse()'s own comment),
+    so this just checks their sign -- it doesn't change what those
+    functions themselves return.
+    """
+    if primitive_type != PrimitiveType.AlpacaV1:
+        return None
+    for param in (PumpParam.MaxSpeed, PumpParam.MinSpeed):
+        if param in params:
+            return params[param] < 0
+    return None
+
+
 class RampType(IntEnum):
     Sinusoidal = 1
     Logarithmic = 2

{python_mobius-0.8.0 → python_mobius-0.8.2}/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]:
@@ -1296,6 +1316,28 @@ class MobiusDevice:
         """
         await self.set_attribute(C2Attribute.Reset, bytes([ResetType.Soft]))
 
+    async def reboot_all(self) -> None:
+        """
+        Soft-reboots every device on this mesh at once -- what the
+        app's own "Restart all Devices" (tank settings screen) does.
+
+        Confirmed from the app's own SettingsFragment.reboot(): this
+        is NOT a loop of individual reboot() calls against every
+        device. It's the exact same single Set as reboot() (Reset=Soft),
+        just with the frame's own reserved-byte "group" field set to 1
+        (see make_reserved()) instead of left at 0 -- one write to
+        this device, propagated to the rest of the mesh the same way
+        set_time_to_now()/start_scene(broadcast=True) already do.
+        group=1 specifically (not the app's own client-side, per-tank
+        group number, which isn't something this library has any way
+        to discover) matches set_time_to_now()'s own confirmed-working
+        value, and the same real-hardware caveats apply here: not
+        guaranteed reliable across every mesh topology or under
+        real-world conditions where a peer is briefly unreachable when
+        the write's own propagation happens.
+        """
+        await self.set_attribute(C2Attribute.Reset, bytes([ResetType.Soft]), reserved=make_reserved(group=1))
+
     # ---- scenes -----------------------------------------------------------
 
     async def start_scene(self, scene_id: int, duration_seconds: int = 0, broadcast: bool = True) -> None:
@@ -3768,7 +3810,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.0 → python_mobius-0.8.2}/tests/test_device_control.py

@@ -1,9 +1,10 @@
 """
-Tests for device control write operations -- currently just reboot().
-Confirmed wire format (attribute ID, single-byte value, no reserved-byte
-group involved) via the app's own source, which sends exactly this for
-its own "Restart" button. NOT confirmed: this specific write against real
-hardware, direct or relayed -- see reboot()'s own docstring.
+Tests for device control write operations -- reboot() and
+reboot_all(). Confirmed wire format via the app's own source, which
+sends exactly this for its own "Restart" button and "Restart all
+Devices" tank setting respectively. NOT confirmed: these specific
+writes against real hardware, direct or relayed -- see each method's
+own docstring.
 """
 
 import pytest
@@ -63,6 +64,49 @@ async def test_reboot_propagates_a_write_failure():
         await device.reboot()
 
 
+@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
+    "Restart all Devices" tank-settings option): the exact same Reset
+    Set as reboot(), but with the frame's own reserved-byte group
+    field set to 1 instead of left ungrouped -- one write to this
+    device propagates to the rest of the mesh, matching
+    set_time_to_now()'s own already-confirmed group=1 behavior."""
+    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
+        captured["reserved"] = reserved
+
+    device.set_attribute = fake_set_attribute
+    await device.reboot_all()
+
+    assert captured["attr_id"] == C2Attribute.Reset
+    assert captured["value"] == bytes([ResetType.Soft])
+    assert captured["reserved"] == make_reserved(group=1)
+    # Distinct from reboot()'s own ungrouped reserved bytes -- this is
+    # the whole point of the two methods being separate.
+    assert captured["reserved"] != b"\x00\x00"
+
+
+@pytest.mark.asyncio
+async def test_reboot_all_propagates_a_write_failure():
+    """Same reasoning as reboot()'s own equivalent test -- a caller
+    acting on a silently-swallowed failure here would wrongly believe
+    every device on the mesh actually rebooted."""
+    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 6")
+
+    device.set_attribute = fake_set_attribute
+
+    with pytest.raises(IOError, match="Failed setting attribute 6"):
+        await device.reboot_all()
+
+
 # --------------------------------------------------------------------------
 # set_attribute_multi() -- writing several elements of one attribute in
 # a single request (used by set_light_schedule()/set_pump_schedule()).

{python_mobius-0.8.0 → python_mobius-0.8.2}/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

python_mobius-0.8.2/tests/test_pump_reverse.py

@@ -0,0 +1,52 @@
+"""
+Tests for get_pump_reverse() -- ported from the decompiled app's own
+PumpPrimitive.getReverse(). Confirmed against the app's own
+PumpParameterEntry.sliderSettings(): MaxSpeed and MinSpeed only ever
+set supportsReverse=true when primitive_type is AlpacaV1 -- every
+other primitive type never supports reverse rotation at all,
+regardless of mode or the value's own sign.
+"""
+
+from mobius import PrimitiveType, PumpParam, get_pump_reverse
+
+
+def test_alpacav1_negative_max_speed_is_reverse():
+    assert get_pump_reverse(PrimitiveType.AlpacaV1, {PumpParam.MaxSpeed: -420}) is True
+
+
+def test_alpacav1_positive_max_speed_is_not_reverse():
+    assert get_pump_reverse(PrimitiveType.AlpacaV1, {PumpParam.MaxSpeed: 420}) is False
+
+
+def test_alpacav1_negative_min_speed_is_reverse():
+    assert get_pump_reverse(PrimitiveType.AlpacaV1, {PumpParam.MinSpeed: -100}) is True
+
+
+def test_alpacav1_checks_max_speed_before_min_speed_when_both_present():
+    # Matches the app's own getReverse() -- it stops at the first
+    # param on the primitive whose slider settings support reverse,
+    # which for AlpacaV1 is MaxSpeed before MinSpeed in params() order.
+    assert get_pump_reverse(PrimitiveType.AlpacaV1, {PumpParam.MaxSpeed: -420, PumpParam.MinSpeed: 100}) is True
+
+
+def test_non_alpaca_primitive_types_never_support_reverse_even_with_a_negative_value():
+    """The genuinely important case -- confirmed straight from the
+    app's own sliderSettings(): a negative value on any other
+    primitive type isn't a real, meaningful reverse-rotation signal,
+    since the concept doesn't apply there at all."""
+    for primitive in (
+        PrimitiveType.VorTechV1,
+        PrimitiveType.PumpV1,
+        PrimitiveType.TurtleV1,
+        PrimitiveType.CoffeeV1,
+        PrimitiveType.VectraV1,
+    ):
+        assert get_pump_reverse(primitive, {PumpParam.MaxSpeed: -420}) is None
+
+
+def test_returns_none_when_neither_speed_param_is_present():
+    assert get_pump_reverse(PrimitiveType.AlpacaV1, {PumpParam.PhaseShift: 180}) is None
+
+
+def test_returns_none_for_an_empty_params_dict():
+    assert get_pump_reverse(PrimitiveType.AlpacaV1, {}) is None