python-mobius 0.6.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

mobius/__init__.py

@@ -56,7 +56,7 @@ from .mesh_address import (
 )
 from .relay import RelayedMobiusDevice
 from .device import (
-    MobiusDevice, MobiusPump, LightIntensityResult,
+    MobiusDevice, MobiusPump, LightIntensityResult, LightPollResult, FullPollResult,
     SERVICE_GENERAL, CHAR_RX_DATA, CHAR_RX_FINAL, CHAR_TX_DATA, CHAR_TX_FINAL,
 )
 from .discovery import (
@@ -71,7 +71,7 @@ from .dump import (
     enrich_attribute_dump,
 )
 
-__version__ = "0.6.0"
+__version__ = "0.7.0"
 
 __all__ = [
     "__version__",
@@ -117,7 +117,7 @@ __all__ = [
     "build_rloc_address", "extract_short_address", "is_short_address_derived",
     "RelayedMobiusDevice",
     # device
-    "MobiusDevice", "MobiusPump", "LightIntensityResult",
+    "MobiusDevice", "MobiusPump", "LightIntensityResult", "LightPollResult", "FullPollResult",
     "SERVICE_GENERAL", "CHAR_RX_DATA", "CHAR_RX_FINAL", "CHAR_TX_DATA", "CHAR_TX_FINAL",
     # discovery
     "scan_for_mobius_devices", "scan_for_mobius_devices_with_info", "group_by_pan_id",

mobius/device.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 import asyncio
 import struct
 import time
+from dataclasses import dataclass
 from typing import Optional, Callable
 
 from bleak import BleakClient, BleakScanner
@@ -119,6 +120,86 @@ class LightIntensityResult(dict):
         self.diagnostics = diagnostics or {}
 
 
+@dataclass
+class LightPollResult:
+    """
+    Everything get_light_poll_batch() reads in ONE combined round-trip
+    -- the schedule itself (for a caller's own schedule_point_count,
+    same as get_light_schedule() alone would give) AND the fully
+    computed current intensities (LightIntensityResult, same as
+    get_current_light_intensities() alone would give), both derived
+    from the SAME underlying batch response. Avoids the redundant
+    double-fetch of the schedule that existed before this method: a
+    caller needing both previously called get_light_schedule() once
+    directly, then get_current_light_intensities() separately, which
+    re-fetched the exact same schedule internally all over again.
+
+    used_batch mirrors MetadataSnapshot's own field of the same name --
+    True if the batched request itself succeeded, False if this
+    method's own individual-reads fallback was used instead (for any
+    reason, including force_individual_reads=True). This library
+    doesn't log anything itself; used_batch is the signal a caller
+    uses to notice a fallback happened and log/react to it on its own
+    terms.
+    """
+    schedule_points: list[SchedulePoint]
+    intensities: LightIntensityResult
+    used_batch: bool = True
+
+
+@dataclass
+class FullPollResult:
+    """
+    Everything a SINGLE device poll needs, in ONE combined round-trip
+    -- device identity (Model/Name/SerialNumber/ErrorState/MACAddress
+    -- deliberately NOT PrimitiveType, see below), everything
+    MetadataSnapshot covers, and everything a light's own
+    LightPollResult (light_poll) or a pump's own telemetry
+    (pump_telemetry, matching get_pump_telemetry()'s own return shape
+    exactly: speed/speed_percent/gph/motor_power_watts/minimum_gph/
+    maximum_gph/gph_reliable) covers.
+
+    Why PrimitiveType is deliberately excluded, unlike every other
+    identity field: it's the one thing about a physical device that's
+    genuinely permanent for its whole lifetime -- a light is a light
+    forever, a pump is a pump forever. get_full_poll_batch() itself
+    REQUIRES the caller to already know it (see that method's own
+    `primitive` parameter) specifically so a caller who's determined
+    it ONCE (e.g. on a coordinator's very first successful poll) never
+    needs to spend a single further round-trip re-confirming it,
+    unlike Model/Name/ErrorState/MACAddress, which this DOES keep
+    re-fetching every poll since any of them could, in principle,
+    change (a firmware update changing the reported Model number,
+    a user renaming the device in the app, a real fault raising
+    ErrorState) even though none of them are truly volatile like
+    schedule/intensity data.
+
+    device_info matches get_device_info()'s own dict shape exactly,
+    except "primitive_type" is always None in it (this method never
+    fetches that attribute at all) -- fill it in yourself from
+    whatever you already know, if you need it in that same dict.
+
+    pump_schedule_points -- a pump's own Schedule1/Schedule2, decoded
+    the same way get_pump_schedule() itself does (populated alongside
+    pump_telemetry, both only for a pump; None for a light, which gets
+    its own schedule via light_poll.schedule_points instead). This
+    request already includes the schedule attribute regardless of
+    device type (get_light_poll_batch()'s own candidate list needs it
+    too) -- decoding it for a pump costs nothing further and avoids a
+    caller needing a separate get_pump_schedule() call just to also
+    get schedule_point_count alongside everything else here.
+
+    used_batch mirrors every other *Result/Snapshot's own field of the
+    same name and purpose.
+    """
+    device_info: dict
+    metadata: MetadataSnapshot
+    light_poll: Optional[LightPollResult]
+    pump_telemetry: Optional[dict]
+    pump_schedule_points: Optional[list[PumpSchedulePoint]] = None
+    used_batch: bool = True
+
+
 # Used by get_hardware_info() -- which HardwareInfo sub-fields are
 # themselves confirmed enums with confirmed display labels, vs. plain
 # integers with no confirmed meaning (Revision/Segments, deliberately not
@@ -196,6 +277,443 @@ def decode_hardware_revision_blocks(blocks: list[AttributeValue]) -> dict:
     return result
 
 
+def decode_lunar_enabled(raw: list[bytes]) -> bool:
+    """
+    Pure decode for LunarPhasesEnabled (907) -- extracted from
+    get_lunar_enabled() itself so it's shared between that method
+    (individual fetch) and get_light_poll_batch() (batched fetch),
+    rather than each having its own copy of the decode logic. False
+    (matching this library's own fail-soft convention for optional
+    modifiers) if raw is empty.
+    """
+    if not raw:
+        return False
+    return raw[0][0] > 0
+
+
+def decode_schedule_intensity(raw: list[bytes]) -> float:
+    """
+    Pure decode for Schedule1Intensity/Schedule2Intensity (511/512) --
+    extracted from get_schedule_intensity() itself, whose own
+    docstring covers the full confirmed meaning (a schedule-level
+    master dimmer, separate from any individual channel's own value).
+    0.5 (the app's own schedule-initialization default) if raw is
+    empty.
+    """
+    if not raw:
+        return 0.5
+    value = struct.unpack("<h", raw[0])[0]
+    return value / 1000.0
+
+
+def decode_insolation_enabled(raw: list[bytes]) -> bool:
+    """
+    Pure decode for InsolationEnabled (912) -- extracted from
+    get_insolation_enabled() itself. False if raw is empty. See that
+    method's own docstring for what this flag is actually used for
+    (Insolation itself is NOT implemented -- this is a detection read
+    only, to flag get_current_light_intensities()'s own
+    diagnostics["insolation_active"]).
+    """
+    if not raw:
+        return False
+    return raw[0][0] > 0
+
+
+def decode_schedule_points(raw: list[bytes]) -> list[SchedulePoint]:
+    """
+    Pure decode for a light's Schedule1/Schedule2 response -- extracted
+    from get_light_schedule() itself, whose own docstring covers the
+    full confirmed response-parsing logic (fixed count*length layout).
+    Silently drops any element SchedulePoint.parse() itself rejects,
+    matching that method's own existing behavior.
+    """
+    points = []
+    for element in raw:
+        pt = SchedulePoint.parse(element)
+        if pt is not None:
+            points.append(pt)
+    return points
+
+
+def decode_pump_schedule_points(raw: list[bytes]) -> list[PumpSchedulePoint]:
+    """Same as decode_schedule_points() above, but for a pump's own
+    Schedule1/Schedule2 response -- extracted from get_pump_schedule()
+    itself."""
+    points = []
+    for element in raw:
+        pt = PumpSchedulePoint.parse(element)
+        if pt is not None:
+            points.append(pt)
+    return points
+
+
+def decode_acclimation_info(
+    enabled_raw: list[bytes], period_raw: list[bytes],
+    start_intensity_raw: list[bytes], start_time_raw: list[bytes],
+) -> Optional[AcclimationInfo]:
+    """
+    Pure decode for the 4 acclimation attributes (AcclimationEnabled/
+    Period/StartIntensity/StartTime) -- extracted from
+    get_acclimation_info() itself, whose own docstring covers the
+    confirmed all-or-nothing behavior: None if ANY of the 4 raw
+    values is empty (matching the app's own behavior for a device
+    that doesn't support every one of them).
+    """
+    if not (enabled_raw and period_raw and start_intensity_raw and start_time_raw):
+        return None
+    enabled = enabled_raw[0][0] > 0
+    period = period_raw[0][0]
+    start_intensity = struct.unpack("<h", start_intensity_raw[0])[0]
+    start_time = struct.unpack("<i", start_time_raw[0])[0]
+    return AcclimationInfo(enabled, start_time, period, start_intensity)
+
+
+def decode_metadata_from_batch(by_attr_id: dict, model: Optional[Model]) -> "MetadataSnapshot":
+    """
+    Pure decode, extracted from _get_metadata_via_batch() itself --
+    everything that method used to do AFTER its own get_attributes_batch()
+    call, now reusable by any caller that already has a by_attr_id dict
+    grouped the same way (attr_id -> list[AttributeValue]), regardless
+    of whether that dict came from get_metadata_batch()'s own, smaller
+    request or a larger, combined one (see get_full_poll_batch()) that
+    happens to also include every attribute this needs, among others.
+    Looking up only the keys this function itself cares about means it
+    works correctly either way -- extra, unrelated entries in by_attr_id
+    are simply ignored.
+
+    used_batch=True unconditionally -- this function IS the "batch
+    succeeded" decode path, by construction; a caller reusing it
+    outside that context is responsible for its own used_batch value.
+    """
+    def _first_value(attr_id):
+        blocks = by_attr_id.get(attr_id)
+        if not blocks:
+            return None
+        for block in sorted(blocks, key=lambda b: b.index):
+            if block.values:
+                return block.values[0]
+        return None
+
+    def _all_blocks(attr_id):
+        return by_attr_id.get(attr_id, [])
+
+    # -- AdvancedFeatures -- matching get_advanced_features()'s own decode exactly.
+    local_control_enabled = None
+    raw = _first_value(C2Attribute.LocalControlEnabled)
+    if raw:
+        local_control_enabled = raw[0] > 0
+    auto_dim_timeout = None
+    raw = _first_value(C2Attribute.AutoDimTimeout)
+    if raw:
+        auto_dim_timeout = struct.unpack("<h", raw)[0]
+    max_fan_speed = None
+    raw = _first_value(C2Attribute.MaxFanSpeed)
+    if raw:
+        raw_speed = struct.unpack("<h", raw)[0]
+        max_fan_speed = 100.0 if raw_speed == -1 else raw_speed / 10.0
+    fan_shutdown_enabled = None
+    raw = _first_value(C2Attribute.FanShutdownEnabled)
+    if raw:
+        fan_shutdown_enabled = raw[0] > 0
+    advanced_features = None
+    if any([
+        local_control_enabled is not None, auto_dim_timeout is not None,
+        max_fan_speed is not None, fan_shutdown_enabled is not None,
+    ]):
+        advanced_features = AdvancedFeatures(
+            local_control_enabled=local_control_enabled, auto_dim_timeout=auto_dim_timeout,
+            max_fan_speed=max_fan_speed, fan_shutdown_enabled=fan_shutdown_enabled,
+        )
+
+    # -- CalibrationInfo -- matching get_calibration_info()'s own decode exactly.
+    calibration = None
+    completed_raw = _first_value(C2Attribute.IsCalibrated)
+    date_raw = _first_value(C2Attribute.LastCalibrationTime)
+    if completed_raw and date_raw:
+        lower_bound = None
+        raw = _first_value(C2Attribute.MinCalibratedSpeed)
+        if raw:
+            lower_bound = struct.unpack("<h", raw)[0]
+        upper_bound = None
+        raw = _first_value(C2Attribute.MaxCalibratedSpeed)
+        if raw:
+            upper_bound = struct.unpack("<h", raw)[0]
+        calibration = CalibrationInfo(
+            completed=completed_raw[0] > 0,
+            date_of_last=struct.unpack("<i", date_raw)[0],
+            lower_bound=lower_bound, upper_bound=upper_bound,
+        )
+
+    # -- hardware_info / firmware_versions -- shared decode helpers,
+    # matching get_hardware_info()/get_firmware_versions() exactly.
+    hardware_info = decode_hardware_revision_blocks(_all_blocks(C2Attribute.HardwareRevision))
+    firmware_versions = decode_firmware_version_blocks(_all_blocks(C2Attribute.FirmwareVersion), model)
+
+    # -- supported_channels -- matching get_supported_channels()'s
+    # own decode exactly (flattening every block's own values, in
+    # index order, same as get_attribute_all() does internally).
+    supported_channels = []
+    for block in sorted(_all_blocks(C2Attribute.SupportedColorChannels), key=lambda b: b.index):
+        for v in block.values:
+            if v:
+                try:
+                    supported_channels.append(VisualID(v[0]))
+                except ValueError:
+                    pass
+
+    # -- error_state -- matching get_device_info()'s own decode exactly.
+    error_state = None
+    raw = _first_value(C2Attribute.ErrorState)
+    if raw and len(raw) >= 2:
+        error_val = struct.unpack("<h", raw)[0]
+        try:
+            error_state = ErrorState(error_val).name
+        except ValueError:
+            error_state = f"unknown({error_val})"
+
+    # -- time fields -- raw ints, matching get_app_lunar_date()/
+    # get_device_local_date()'s own attribute reads (both attribute
+    # 201/207/202 decodes match exactly what those methods read).
+    epoch = None
+    raw = _first_value(C2Attribute.Epoch)
+    if raw and len(raw) >= 4:
+        epoch = struct.unpack("<I", raw)[0]
+    local_time = None
+    raw = _first_value(C2Attribute.LocalTime)
+    if raw and len(raw) >= 4:
+        local_time = struct.unpack("<I", raw)[0]
+    tz_offset = None
+    raw = _first_value(C2Attribute.TimeZoneOffset)
+    if raw and len(raw) >= 2:
+        tz_offset = struct.unpack("<h", raw)[0]
+
+    return MetadataSnapshot(
+        advanced_features=advanced_features, calibration=calibration,
+        hardware_info=hardware_info, firmware_versions=firmware_versions,
+        supported_channels=supported_channels, error_state=error_state,
+        epoch=epoch, local_time=local_time, tz_offset=tz_offset,
+        used_batch=True,
+    )
+
+
+def decode_light_poll_from_batch(
+    by_attr_id: dict, which: int, minute_of_day: int, now: "datetime.datetime",
+) -> "LightPollResult":
+    """
+    Pure decode, extracted from _get_light_poll_via_batch() itself --
+    same reasoning as decode_metadata_from_batch() right above: reusable
+    by any caller with a by_attr_id dict grouped the same way, whether
+    it came from get_light_poll_batch()'s own smaller request or a
+    larger, combined one that happens to include everything this needs
+    too (see get_full_poll_batch()). used_batch=True unconditionally.
+    """
+    schedule_attr = C2Attribute.Schedule1 if which == 1 else C2Attribute.Schedule2
+    intensity_attr = C2Attribute.Schedule1Intensity if which == 1 else C2Attribute.Schedule2Intensity
+
+    def _values_for(attr_id):
+        blocks = by_attr_id.get(attr_id, [])
+        values = []
+        for block in sorted(blocks, key=lambda b: b.index):
+            values.extend(block.values)
+        return values
+
+    points = decode_schedule_points(_values_for(schedule_attr))
+    lunar_enabled = decode_lunar_enabled(_values_for(C2Attribute.LunarPhasesEnabled))
+
+    epoch_values = _values_for(C2Attribute.Epoch)
+    epoch = struct.unpack("<I", epoch_values[0])[0] if epoch_values else None
+    local_time_values = _values_for(C2Attribute.LocalTime)
+    local_time = struct.unpack("<I", local_time_values[0])[0] if local_time_values else None
+    lunar_date = compute_app_lunar_date(epoch, local_time)
+    lunar_date_source = "app_lunar_date" if lunar_date is not None else None
+
+    schedule_intensity = decode_schedule_intensity(_values_for(intensity_attr))
+    acclimation_info = decode_acclimation_info(
+        _values_for(C2Attribute.AcclimationEnabled), _values_for(C2Attribute.AcclimationPeriod),
+        _values_for(C2Attribute.AcclimationStartIntensity), _values_for(C2Attribute.AcclimationStartTime),
+    )
+    insolation_active = decode_insolation_enabled(_values_for(C2Attribute.InsolationEnabled))
+
+    intensities = process_light_intensities(
+        points, minute_of_day, now,
+        lunar_enabled, lunar_date, lunar_date_source,
+        schedule_intensity, acclimation_info, insolation_active,
+    )
+    return LightPollResult(schedule_points=points, intensities=intensities, used_batch=True)
+
+
+def decode_pump_flow_range(min_raw: list[bytes], max_raw: list[bytes]) -> Optional[PumpFlowRange]:
+    """
+    Pure decode for MinimumGallonsPerHour/MaximumGallonsPerHour
+    (707/708), extracted from get_pump_flow_range() itself -- see that
+    method's own docstring for the confirmed meaning. None if either
+    input is empty.
+    """
+    if not (min_raw and max_raw):
+        return None
+    return PumpFlowRange(
+        minimum_gph=struct.unpack("<h", min_raw[0])[0],
+        maximum_gph=struct.unpack("<h", max_raw[0])[0],
+    )
+
+
+def decode_pump_telemetry(
+    speed_raw: list[bytes], gph_raw: list[bytes], motor_power_raw: list[bytes],
+    flow_range: Optional[PumpFlowRange], model: Optional[Model], primitive: Optional[PrimitiveType],
+) -> dict:
+    """
+    Pure decode, extracted from get_pump_telemetry() itself -- see
+    that method's own docstring for the full confirmed field meanings
+    and the gph_reliable determination logic in particular (the actual
+    point of that method's own docstring). Takes an already-decoded
+    flow_range (from decode_pump_flow_range() above) rather than raw
+    bytes for it, since that's itself a composed value, not a single
+    attribute read.
+    """
+    speed = struct.unpack("<h", speed_raw[0])[0] if speed_raw else None
+    gph = struct.unpack("<i", gph_raw[0])[0] if gph_raw else None
+    motor_power_watts = struct.unpack("<i", motor_power_raw[0])[0] if motor_power_raw else None
+    speed_percent = abs(speed) / 10 if speed is not None else None
+
+    is_legacy_nero = model in (Model.Nero3, Model.Nero5, Model.Nero7)
+    if is_legacy_nero:
+        gph_reliable = gph is not None
+    else:
+        gph_reliable = primitive != PrimitiveType.VectraV1 and flow_range is not None
+
+    return {
+        "speed": speed, "speed_percent": speed_percent, "gph": gph,
+        "motor_power_watts": motor_power_watts,
+        "minimum_gph": flow_range.minimum_gph if flow_range else None,
+        "maximum_gph": flow_range.maximum_gph if flow_range else None,
+        "gph_reliable": gph_reliable,
+    }
+
+
+def decode_device_info(
+    model_raw: Optional[bytes], name_raw: Optional[bytes], serial_raw: Optional[bytes],
+    primitive_raw: Optional[bytes], error_raw: Optional[bytes], mac_raw: Optional[bytes],
+) -> dict:
+    """
+    Pure decode, extracted VERBATIM from get_device_info() itself --
+    see that method's own docstring for the confirmed field list.
+    Every input is the raw bytes get_attribute() itself would have
+    returned for that attribute (or None if unsupported/not fetched --
+    e.g. get_full_poll_batch() never fetches PrimitiveType at all,
+    since that's known once and cached by its own caller instead of
+    being re-fetched every poll; pass None for primitive_raw in that
+    case, same as this always did for any attribute that failed to
+    fetch, and "primitive_type" simply comes back None in the result).
+    """
+    model_val = struct.unpack("<h", model_raw)[0] if model_raw and len(model_raw) >= 2 else None
+    try:
+        model = Model(model_val) if model_val is not None else None
+    except ValueError:
+        model = None
+
+    error_val = struct.unpack("<h", error_raw)[0] if error_raw and len(error_raw) >= 2 else None
+    try:
+        error = ErrorState(error_val) if error_val is not None else None
+    except ValueError:
+        error = None
+
+    return {
+        "model_raw": model_val,
+        "model": model.name if model is not None else (f"unknown({model_val})" if model_val is not None else None),
+        "manufacturer": manufacturer_for_model(model),
+        "name": name_raw.decode("utf-8", errors="replace").rstrip("\x00") if name_raw else None,
+        "serial": _decode_serial(serial_raw) if serial_raw else None,
+        "primitive_type": PrimitiveType(primitive_raw[0]).name if primitive_raw else None,
+        "error_state": error.name if error is not None else (f"unknown({error_val})" if error_val is not None else None),
+        "mac_address": ":".join(f"{b:02X}" for b in mac_raw) if mac_raw else None,
+    }
+
+
+def compute_app_lunar_date(
+    epoch_seconds: Optional[int], local_time_seconds: Optional[int],
+) -> Optional["datetime.date"]:
+    """
+    Pure computation, extracted VERBATIM from get_app_lunar_date()
+    itself -- see that method's own docstring for the full, real-
+    hardware-confirmed derivation of this exact formula
+    (`2 * LocalTime - Epoch`, deliberately replicating a confirmed app
+    bug rather than computing the physically correct date). None if
+    either input is None, matching that method's own fallback
+    contract.
+    """
+    if epoch_seconds is None or local_time_seconds is None:
+        return None
+    import datetime as _datetime
+    effective_seconds = 2 * local_time_seconds - epoch_seconds
+    return _datetime.datetime.fromtimestamp(effective_seconds, tz=_datetime.timezone.utc).date()
+
+
+def process_light_intensities(
+    points: list[SchedulePoint], minute_of_day: int, now: "datetime.datetime",
+    lunar_enabled: Optional[bool], lunar_date: Optional["datetime.date"], lunar_date_source: Optional[str],
+    schedule_intensity: Optional[float], acclimation_info: Optional[AcclimationInfo],
+    insolation_active: bool,
+) -> LightIntensityResult:
+    """
+    Pure computation, extracted VERBATIM (same branching, same
+    variable reassignments, in the same order) from
+    get_current_light_intensities() itself -- see that method's own
+    docstring for the full, real-hardware-confirmed branching logic
+    this replicates exactly. This is the ONLY place that logic lives;
+    get_current_light_intensities() itself is now a thin wrapper that
+    fetches its own inputs (lazily, only whichever branch's own inputs
+    are actually needed, exactly as it always has) and calls this, and
+    get_light_poll_batch() calls this too, with everything fetched
+    upfront in one round trip regardless of which branch ends up
+    mattering.
+
+    Every optional input here is used ONLY by the branch that actually
+    needs it, matching the original method's own conditional-fetch
+    pattern -- an input the taken branch doesn't need is simply
+    ignored, whatever value (or None) the caller happened to supply
+    for it. schedule_intensity defaults to 0.5 if given as None
+    (matching get_schedule_intensity()'s own fail-soft default) --
+    belt-and-suspenders only, since both current callers already
+    guarantee a real float via decode_schedule_intensity()'s own same
+    default; never actually exercised by either as of this writing.
+    """
+    raw_intensities = interpolate_light_schedule(points, minute_of_day)
+
+    night_segment = is_night_segment(points, minute_of_day)
+    if night_segment:
+        if lunar_enabled:
+            if lunar_date is None:
+                lunar_date = now.date()
+                lunar_date_source = "local_fallback"
+            scalar = lunar_percent_reduction(lunar_date)
+            scalar_source = "lunar"
+        else:
+            lunar_date = None
+            lunar_date_source = None
+            scalar = 1.0
+            scalar_source = "night_no_lunar"
+    else:
+        lunar_enabled = None  # not checked/relevant outside the night segment
+        lunar_date = None
+        lunar_date_source = None
+        scalar = schedule_intensity if schedule_intensity is not None else 0.5
+        scalar_source = "schedule_intensity"
+        if acclimation_info and acclimation_info.enabled and not acclimation_info.is_complete(now):
+            scalar *= acclimation_info.current_intensity(now) / 1000.0
+
+    result = {ch: value * scalar for ch, value in raw_intensities.items()}
+    return LightIntensityResult(result, diagnostics={
+        "insolation_active": insolation_active,
+        "is_night_segment": night_segment,
+        "lunar_enabled": lunar_enabled,
+        "scalar_source": scalar_source,
+        "scalar": scalar,
+        "lunar_date": lunar_date,
+        "lunar_date_source": lunar_date_source,
+    })
+
+
 class MobiusDevice:
     """
     High-level async client for a single Mobius-protocol BLE device.
@@ -813,28 +1331,7 @@ class MobiusDevice:
         error_raw = await _get(C2Attribute.ErrorState)
         mac_raw = await _get(C2Attribute.MACAddress)
 
-        model_val = struct.unpack("<h", model_raw)[0] if model_raw and len(model_raw) >= 2 else None
-        try:
-            model = Model(model_val) if model_val is not None else None
-        except ValueError:
-            model = None
-
-        error_val = struct.unpack("<h", error_raw)[0] if error_raw and len(error_raw) >= 2 else None
-        try:
-            error = ErrorState(error_val) if error_val is not None else None
-        except ValueError:
-            error = None
-
-        return {
-            "model_raw": model_val,
-            "model": model.name if model is not None else (f"unknown({model_val})" if model_val is not None else None),
-            "manufacturer": manufacturer_for_model(model),
-            "name": name_raw.decode("utf-8", errors="replace").rstrip("\x00") if name_raw else None,
-            "serial": _decode_serial(serial_raw) if serial_raw else None,
-            "primitive_type": PrimitiveType(primitive_raw[0]).name if primitive_raw else None,
-            "error_state": error.name if error is not None else (f"unknown({error_val})" if error_val is not None else None),
-            "mac_address": ":".join(f"{b:02X}" for b in mac_raw) if mac_raw else None,
-        }
+        return decode_device_info(model_raw, name_raw, serial_raw, primitive_raw, error_raw, mac_raw)
 
     async def get_group_info(self) -> GroupInfo:
         """
@@ -1670,115 +2167,7 @@ class MobiusDevice:
             for av in raw_results:
                 by_attr_id.setdefault(av.attr_id, []).append(av)
 
-        def _first_value(attr_id):
-            blocks = by_attr_id.get(attr_id)
-            if not blocks:
-                return None
-            for block in sorted(blocks, key=lambda b: b.index):
-                if block.values:
-                    return block.values[0]
-            return None
-
-        def _all_blocks(attr_id):
-            return by_attr_id.get(attr_id, [])
-
-        # -- AdvancedFeatures -- matching get_advanced_features()'s own decode exactly.
-        local_control_enabled = None
-        raw = _first_value(C2Attribute.LocalControlEnabled)
-        if raw:
-            local_control_enabled = raw[0] > 0
-        auto_dim_timeout = None
-        raw = _first_value(C2Attribute.AutoDimTimeout)
-        if raw:
-            auto_dim_timeout = struct.unpack("<h", raw)[0]
-        max_fan_speed = None
-        raw = _first_value(C2Attribute.MaxFanSpeed)
-        if raw:
-            raw_speed = struct.unpack("<h", raw)[0]
-            max_fan_speed = 100.0 if raw_speed == -1 else raw_speed / 10.0
-        fan_shutdown_enabled = None
-        raw = _first_value(C2Attribute.FanShutdownEnabled)
-        if raw:
-            fan_shutdown_enabled = raw[0] > 0
-        advanced_features = None
-        if any([
-            local_control_enabled is not None, auto_dim_timeout is not None,
-            max_fan_speed is not None, fan_shutdown_enabled is not None,
-        ]):
-            advanced_features = AdvancedFeatures(
-                local_control_enabled=local_control_enabled, auto_dim_timeout=auto_dim_timeout,
-                max_fan_speed=max_fan_speed, fan_shutdown_enabled=fan_shutdown_enabled,
-            )
-
-        # -- CalibrationInfo -- matching get_calibration_info()'s own decode exactly.
-        calibration = None
-        completed_raw = _first_value(C2Attribute.IsCalibrated)
-        date_raw = _first_value(C2Attribute.LastCalibrationTime)
-        if completed_raw and date_raw:
-            lower_bound = None
-            raw = _first_value(C2Attribute.MinCalibratedSpeed)
-            if raw:
-                lower_bound = struct.unpack("<h", raw)[0]
-            upper_bound = None
-            raw = _first_value(C2Attribute.MaxCalibratedSpeed)
-            if raw:
-                upper_bound = struct.unpack("<h", raw)[0]
-            calibration = CalibrationInfo(
-                completed=completed_raw[0] > 0,
-                date_of_last=struct.unpack("<i", date_raw)[0],
-                lower_bound=lower_bound, upper_bound=upper_bound,
-            )
-
-        # -- hardware_info / firmware_versions -- shared decode helpers,
-        # matching get_hardware_info()/get_firmware_versions() exactly.
-        hardware_info = decode_hardware_revision_blocks(_all_blocks(C2Attribute.HardwareRevision))
-        firmware_versions = decode_firmware_version_blocks(_all_blocks(C2Attribute.FirmwareVersion), model)
-
-        # -- supported_channels -- matching get_supported_channels()'s
-        # own decode exactly (flattening every block's own values, in
-        # index order, same as get_attribute_all() does internally).
-        supported_channels = []
-        for block in sorted(_all_blocks(C2Attribute.SupportedColorChannels), key=lambda b: b.index):
-            for v in block.values:
-                if v:
-                    try:
-                        supported_channels.append(VisualID(v[0]))
-                    except ValueError:
-                        pass
-
-        # -- error_state -- matching get_device_info()'s own decode exactly.
-        error_state = None
-        raw = _first_value(C2Attribute.ErrorState)
-        if raw and len(raw) >= 2:
-            error_val = struct.unpack("<h", raw)[0]
-            try:
-                error_state = ErrorState(error_val).name
-            except ValueError:
-                error_state = f"unknown({error_val})"
-
-        # -- time fields -- raw ints, matching get_app_lunar_date()/
-        # get_device_local_date()'s own attribute reads (both attribute
-        # 201/207/202 decodes match exactly what those methods read).
-        epoch = None
-        raw = _first_value(C2Attribute.Epoch)
-        if raw and len(raw) >= 4:
-            epoch = struct.unpack("<I", raw)[0]
-        local_time = None
-        raw = _first_value(C2Attribute.LocalTime)
-        if raw and len(raw) >= 4:
-            local_time = struct.unpack("<I", raw)[0]
-        tz_offset = None
-        raw = _first_value(C2Attribute.TimeZoneOffset)
-        if raw and len(raw) >= 2:
-            tz_offset = struct.unpack("<h", raw)[0]
-
-        return MetadataSnapshot(
-            advanced_features=advanced_features, calibration=calibration,
-            hardware_info=hardware_info, firmware_versions=firmware_versions,
-            supported_channels=supported_channels, error_state=error_state,
-            epoch=epoch, local_time=local_time, tz_offset=tz_offset,
-            used_batch=True,
-        )
+        return decode_metadata_from_batch(by_attr_id, model)
 
     async def _get_metadata_via_individual_reads(self, model: Optional[Model]) -> MetadataSnapshot:
         """
@@ -2086,11 +2475,7 @@ class MobiusDevice:
             local_time_seconds = struct.unpack("<I", raw[0])[0] if raw else None
         except Exception:
             return None
-        if epoch_seconds is None or local_time_seconds is None:
-            return None
-        import datetime as _datetime
-        effective_seconds = 2 * local_time_seconds - epoch_seconds
-        return _datetime.datetime.fromtimestamp(effective_seconds, tz=_datetime.timezone.utc).date()
+        return compute_app_lunar_date(epoch_seconds, local_time_seconds)
 
     async def get_own_mesh_address(self) -> Optional[bytes]:
         """
@@ -2646,25 +3031,8 @@ class MobiusDevice:
         motor_power_raw = await self.get_attribute(
             C2Attribute.PhysicalValues, index=int(PhysicalValueID.MotorPower), count=1
         )
-        speed = struct.unpack("<h", speed_raw[0])[0] if speed_raw else None
-        gph = struct.unpack("<i", gph_raw[0])[0] if gph_raw else None
-        motor_power_watts = struct.unpack("<i", motor_power_raw[0])[0] if motor_power_raw else None
-        speed_percent = abs(speed) / 10 if speed is not None else None
-
         flow_range = await self.get_pump_flow_range()
-        is_legacy_nero = model in (Model.Nero3, Model.Nero5, Model.Nero7)
-        if is_legacy_nero:
-            gph_reliable = gph is not None
-        else:
-            gph_reliable = primitive != PrimitiveType.VectraV1 and flow_range is not None
-
-        return {
-            "speed": speed, "speed_percent": speed_percent, "gph": gph,
-            "motor_power_watts": motor_power_watts,
-            "minimum_gph": flow_range.minimum_gph if flow_range else None,
-            "maximum_gph": flow_range.maximum_gph if flow_range else None,
-            "gph_reliable": gph_reliable,
-        }
+        return decode_pump_telemetry(speed_raw, gph_raw, motor_power_raw, flow_range, model, primitive)
 
     async def get_pump_flow_range(self) -> Optional[PumpFlowRange]:
         """
@@ -2679,12 +3047,7 @@ class MobiusDevice:
             max_raw = await self.get_attribute(C2Attribute.MaximumGallonsPerHour)
         except Exception:
             return None
-        if not (min_raw and max_raw):
-            return None
-        return PumpFlowRange(
-            minimum_gph=struct.unpack("<h", min_raw[0])[0],
-            maximum_gph=struct.unpack("<h", max_raw[0])[0],
-        )
+        return decode_pump_flow_range(min_raw, max_raw)
 
     async def get_pump_override_mode(self) -> Optional[PumpOverrideMode]:
         """
@@ -2768,12 +3131,7 @@ class MobiusDevice:
         """
         attr = C2Attribute.Schedule1 if which == 1 else C2Attribute.Schedule2
         raw = await self.get_attribute(attr, index=0, count=0xFFFF)
-        points = []
-        for element in raw:
-            pt = SchedulePoint.parse(element)
-            if pt is not None:
-                points.append(pt)
-        return points
+        return decode_schedule_points(raw)
 
     async def get_schedule_intensity(self, which: int = 1) -> float:
         """
@@ -2809,10 +3167,7 @@ class MobiusDevice:
             raw = await self.get_attribute(attr)
         except Exception:
             return 0.5
-        if not raw:
-            return 0.5
-        value = struct.unpack("<h", raw[0])[0]
-        return value / 1000.0
+        return decode_schedule_intensity(raw)
 
     async def get_lunar_enabled(self, which: int = 1) -> bool:
         """Fetches LunarPhasesEnabled (907). Returns False (not raises) on
@@ -2823,9 +3178,7 @@ class MobiusDevice:
             raw = await self.get_attribute(C2Attribute.LunarPhasesEnabled)
         except Exception:
             return False
-        if not raw:
-            return False
-        return raw[0][0] > 0
+        return decode_lunar_enabled(raw)
 
     async def get_acclimation_info(self) -> Optional[AcclimationInfo]:
         """
@@ -2842,13 +3195,7 @@ class MobiusDevice:
             start_time_raw = await self.get_attribute(C2Attribute.AcclimationStartTime)
         except Exception:
             return None
-        if not (enabled_raw and period_raw and start_intensity_raw and start_time_raw):
-            return None
-        enabled = enabled_raw[0][0] > 0
-        period = period_raw[0][0]
-        start_intensity = struct.unpack("<h", start_intensity_raw[0])[0]
-        start_time = struct.unpack("<i", start_time_raw[0])[0]
-        return AcclimationInfo(enabled, start_time, period, start_intensity)
+        return decode_acclimation_info(enabled_raw, period_raw, start_intensity_raw, start_time_raw)
 
     async def get_insolation_enabled(self, which: int = 1) -> bool:
         """
@@ -2867,9 +3214,7 @@ class MobiusDevice:
             raw = await self.get_attribute(C2Attribute.InsolationEnabled)
         except Exception:
             return False
-        if not raw:
-            return False
-        return raw[0][0] > 0
+        return decode_insolation_enabled(raw)
 
     async def get_channel_power_info(self) -> ChannelPowerInfo:
         """
@@ -3036,43 +3381,361 @@ class MobiusDevice:
             minute_of_day = now.hour * 60 + now.minute
 
         points = await self.get_light_schedule(which)
-        raw_intensities = interpolate_light_schedule(points, minute_of_day)
-
         night_segment = is_night_segment(points, minute_of_day)
+
+        lunar_enabled = None
         lunar_date = None
         lunar_date_source = None
+        schedule_intensity = None
+        acclimation_info = None
         if night_segment:
             lunar_enabled = await self.get_lunar_enabled(which)
             if lunar_enabled:
                 lunar_date = await self.get_app_lunar_date()
                 lunar_date_source = "app_lunar_date"
-                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
-                scalar_source = "night_no_lunar"
         else:
-            lunar_enabled = None  # not checked/relevant outside the night segment
-            scalar = await self.get_schedule_intensity(which)
-            scalar_source = "schedule_intensity"
-            acclimation = await self.get_acclimation_info()
-            if acclimation and acclimation.enabled and not acclimation.is_complete(now):
-                scalar *= acclimation.current_intensity(now) / 1000.0
+            schedule_intensity = await self.get_schedule_intensity(which)
+            acclimation_info = await self.get_acclimation_info()
 
         insolation_active = await self.get_insolation_enabled(which)
-        result = {ch: value * scalar for ch, value in raw_intensities.items()}
-        return LightIntensityResult(result, diagnostics={
-            "insolation_active": insolation_active,
-            "is_night_segment": night_segment,
-            "lunar_enabled": lunar_enabled,
-            "scalar_source": scalar_source,
-            "scalar": scalar,
-            "lunar_date": lunar_date,
-            "lunar_date_source": lunar_date_source,
-        })
+
+        return process_light_intensities(
+            points, minute_of_day, now,
+            lunar_enabled, lunar_date, lunar_date_source,
+            schedule_intensity, acclimation_info, insolation_active,
+        )
+
+    async def get_light_poll_batch(
+        self, which: int = 1, minute_of_day: Optional[int] = None,
+        now: Optional["datetime.datetime"] = None,
+        supported_attribute_ids: Optional[set] = None,
+        force_individual_reads: bool = False,
+    ) -> LightPollResult:
+        """
+        ONE combined round-trip covering everything a light device's
+        own poll needs beyond get_metadata_batch(): the schedule
+        itself (Schedule1/Schedule2), LunarPhasesEnabled, Epoch/
+        LocalTime (for the app's own lunar-date calculation -- see
+        compute_app_lunar_date()), Schedule1Intensity/
+        Schedule2Intensity, the 4 Acclimation* attributes, and
+        InsolationEnabled -- everything process_light_intensities()
+        might need, regardless of which of its own branches
+        (night-segment+lunar vs daytime+acclimation) ends up actually
+        mattering, since that isn't knowable until AFTER the schedule
+        itself is fetched and interpolated. Reuses that exact same,
+        single-source-of-truth function for the actual computation --
+        this method's own job is purely gathering the raw inputs
+        differently (one batch instead of several individual reads),
+        never re-implementing any of the branching logic itself.
+
+        FALLBACK: same pattern as get_metadata_batch() -- if the
+        batched request itself fails for any reason (a device that
+        doesn't support the batch-get mechanism at all), falls back to
+        the original, lazy-fetch get_light_schedule()/
+        get_current_light_intensities() pair, which only fetches
+        whichever branch's own inputs are actually needed (unlike this
+        method's own upfront batch). Never returns less than those two
+        would have separately.
+
+        `used_batch` on the returned LightPollResult is exactly how a
+        caller knows which path actually ran -- see MetadataSnapshot's
+        own field of the same name and purpose. `force_individual_reads`
+        -- same purpose as get_metadata_batch()'s own parameter: skip
+        the batch attempt entirely for a caller that's already learned
+        this device's batch mechanism doesn't work.
+
+        `supported_attribute_ids` -- same purpose as
+        get_metadata_batch()'s own parameter: pass an already-known set
+        to skip this method's own internal get_supported_attributes()
+        call. A device's own attribute support essentially never
+        changes across a session, so a caller polling repeatedly can
+        fetch this once (e.g. alongside a get_metadata_batch() call
+        already needing it) and reuse it here too.
+        """
+        import datetime as _datetime
+        if now is None:
+            now = _datetime.datetime.now()
+        if minute_of_day is None:
+            minute_of_day = now.hour * 60 + now.minute
+
+        if supported_attribute_ids is None:
+            try:
+                supported = await self.get_supported_attributes()
+                supported_attribute_ids = {s.attr_id for s in supported}
+            except Exception:
+                supported_attribute_ids = set()
+
+        if not force_individual_reads:
+            try:
+                return await self._get_light_poll_via_batch(which, minute_of_day, now, supported_attribute_ids)
+            except Exception:
+                pass  # fall through to the individual-reads path below
+
+        return await self._get_light_poll_via_individual_reads(which, minute_of_day, now)
+
+    async def _get_light_poll_via_batch(
+        self, which: int, minute_of_day: int, now: "datetime.datetime", supported_attribute_ids: set,
+    ) -> LightPollResult:
+        """
+        The actual batched-request path -- see get_light_poll_batch()'s
+        own docstring for the full confirmed rationale and the
+        mandatory support-filtering this relies on (a single
+        unsupported attribute anywhere in a batched request fails the
+        WHOLE request over relay -- confirmed on real hardware for
+        get_metadata_batch(), same underlying mechanism here).
+
+        Deliberately RAISES if the batch request itself fails (does
+        NOT swallow the exception) -- get_light_poll_batch() is what
+        decides to fall back to individual reads on that failure; this
+        method's own job is just the batch attempt itself.
+        """
+        schedule_attr = C2Attribute.Schedule1 if which == 1 else C2Attribute.Schedule2
+        intensity_attr = C2Attribute.Schedule1Intensity if which == 1 else C2Attribute.Schedule2Intensity
+
+        candidate_requests = [
+            (schedule_attr, 0, 0xFFFF),
+            (C2Attribute.LunarPhasesEnabled, 0, 1),
+            (C2Attribute.Epoch, 0, 1),
+            (C2Attribute.LocalTime, 0, 1),
+            (intensity_attr, 0, 1),
+            (C2Attribute.AcclimationEnabled, 0, 1),
+            (C2Attribute.AcclimationPeriod, 0, 1),
+            (C2Attribute.AcclimationStartIntensity, 0, 1),
+            (C2Attribute.AcclimationStartTime, 0, 1),
+            (C2Attribute.InsolationEnabled, 0, 1),
+        ]
+        requests = [r for r in candidate_requests if r[0] in supported_attribute_ids]
+
+        by_attr_id: dict = {}
+        if requests:
+            raw_results = await self.get_attributes_batch(requests)
+            for av in raw_results:
+                by_attr_id.setdefault(av.attr_id, []).append(av)
+
+        return decode_light_poll_from_batch(by_attr_id, which, minute_of_day, now)
+
+    async def _get_light_poll_via_individual_reads(
+        self, which: int, minute_of_day: int, now: "datetime.datetime",
+    ) -> LightPollResult:
+        """
+        The fallback path -- reuses the existing, already-lazy
+        get_light_schedule()/get_current_light_intensities() pair
+        directly rather than duplicating their own orchestration logic
+        a second time. Accepts the minor cost of fetching the schedule
+        twice (once here, once again inside
+        get_current_light_intensities() itself) -- this is already the
+        degraded-performance path by design (matching
+        get_metadata_batch()'s own fallback philosophy: correctness
+        over speed once the batch mechanism itself doesn't work), so
+        avoiding that one extra round trip here isn't worth the added
+        code duplication. used_batch=False unconditionally -- this
+        method IS the "batch didn't work" path, by construction.
+        """
+        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)
+
+    async def get_full_poll_batch(
+        self, primitive: PrimitiveType, model: Optional[Model] = None,
+        which: int = 1, minute_of_day: Optional[int] = None, now: Optional["datetime.datetime"] = None,
+        supported_attribute_ids: Optional[set] = None, force_individual_reads: bool = False,
+    ) -> FullPollResult:
+        """
+        ONE combined round-trip for EVERYTHING a single device poll
+        needs: device identity (Model/Name/SerialNumber/ErrorState/
+        MACAddress -- see FullPollResult's own docstring for why
+        PrimitiveType is deliberately excluded), everything
+        get_metadata_batch() covers, and everything get_light_poll_batch()
+        (for a light) or get_pump_telemetry()/get_pump_flow_range() (for
+        a pump) covers. Reuses the exact same, single-source-of-truth
+        decode functions those methods themselves use
+        (decode_metadata_from_batch/decode_light_poll_from_batch/
+        decode_pump_telemetry) against ONE shared batch response,
+        rather than re-implementing any decode logic here.
+
+        Confirmed on real hardware (a real light and a real pump, both
+        via relay): combining device identity + metadata + light-poll
+        (or pump-telemetry) into one 18-23 attribute request measures
+        2-2.6x faster than the three separate calls this replaces
+        (get_device_info() + get_metadata_batch() +
+        get_light_poll_batch()-or-get_pump_telemetry()), with every
+        decoded value confirmed matching exactly.
+
+        `primitive` -- REQUIRED, unlike every other parameter here. A
+        device's own PrimitiveType is permanent for its whole lifetime
+        (a light is a light forever, a pump is a pump forever) -- see
+        FullPollResult's own docstring for the full rationale. This
+        method itself never fetches it at all; the caller must already
+        know it (e.g. a single PrimitiveType-only read, or a single
+        get_device_info() call, done ONCE and cached forever after --
+        exactly the same pattern already established for
+        supported_attribute_ids below).
+
+        FALLBACK: same pattern as every other *_batch() method in this
+        library -- if the combined request itself fails, falls back to
+        get_device_info()/get_metadata_batch()/get_light_poll_batch()-
+        or-get_pump_telemetry() run separately, so this never returns
+        less than calling those would have.
+        """
+        import datetime as _datetime
+        if now is None:
+            now = _datetime.datetime.now()
+        if minute_of_day is None:
+            minute_of_day = now.hour * 60 + now.minute
+
+        if supported_attribute_ids is None:
+            try:
+                supported = await self.get_supported_attributes()
+                supported_attribute_ids = {s.attr_id for s in supported}
+            except Exception:
+                supported_attribute_ids = set()
+
+        if not force_individual_reads:
+            try:
+                return await self._get_full_poll_via_batch(
+                    primitive, model, which, minute_of_day, now, supported_attribute_ids,
+                )
+            except Exception:
+                pass  # fall through to the individual-reads path below
+
+        return await self._get_full_poll_via_individual_reads(primitive, model, which, minute_of_day, now)
+
+    async def _get_full_poll_via_batch(
+        self, primitive: PrimitiveType, model: Optional[Model],
+        which: int, minute_of_day: int, now: "datetime.datetime", supported_attribute_ids: set,
+    ) -> FullPollResult:
+        """
+        The actual batched-request path -- see get_full_poll_batch()'s
+        own docstring for the full confirmed rationale. Deliberately
+        RAISES if the batch itself fails -- get_full_poll_batch() is
+        what decides to fall back to individual reads on that failure.
+        """
+        schedule_attr = C2Attribute.Schedule1 if which == 1 else C2Attribute.Schedule2
+        candidate_requests = [
+            # -- device identity (NOT PrimitiveType -- see FullPollResult's own docstring) --
+            (C2Attribute.Model, 0, 1),
+            (C2Attribute.Name, 0, 1),
+            (C2Attribute.SerialNumber, 0, 1),
+            (C2Attribute.ErrorState, 0, 1),
+            (C2Attribute.MACAddress, 0, 1),
+            # -- metadata (same candidate list as get_metadata_batch() itself) --
+            (C2Attribute.LocalControlEnabled, 0, 1),
+            (C2Attribute.AutoDimTimeout, 0, 1),
+            (C2Attribute.MaxFanSpeed, 0, 1),
+            (C2Attribute.FanShutdownEnabled, 0, 1),
+            (C2Attribute.IsCalibrated, 0, 1),
+            (C2Attribute.LastCalibrationTime, 0, 1),
+            (C2Attribute.MinCalibratedSpeed, 0, 1),
+            (C2Attribute.MaxCalibratedSpeed, 0, 1),
+            (C2Attribute.Epoch, 0, 1),
+            (C2Attribute.LocalTime, 0, 1),
+            (C2Attribute.TimeZoneOffset, 0, 1),
+            (C2Attribute.SupportedColorChannels, 0, 0xFFFF),
+            (C2Attribute.FirmwareVersion, 0, 0xFFFF),
+            (C2Attribute.HardwareRevision, 0, 0xFFFF),
+            (schedule_attr, 0, 0xFFFF),
+        ]
+        if primitive == PrimitiveType.VisualV1:
+            intensity_attr = C2Attribute.Schedule1Intensity if which == 1 else C2Attribute.Schedule2Intensity
+            candidate_requests += [
+                (C2Attribute.LunarPhasesEnabled, 0, 1),
+                (intensity_attr, 0, 1),
+                (C2Attribute.AcclimationEnabled, 0, 1),
+                (C2Attribute.AcclimationPeriod, 0, 1),
+                (C2Attribute.AcclimationStartIntensity, 0, 1),
+                (C2Attribute.AcclimationStartTime, 0, 1),
+                (C2Attribute.InsolationEnabled, 0, 1),
+            ]
+        else:
+            candidate_requests += [
+                (C2Attribute.MotorSpeed, 0, 1),
+                (C2Attribute.PhysicalValues, int(PhysicalValueID.GallonsPerHour), 1),
+                (C2Attribute.PhysicalValues, int(PhysicalValueID.MotorPower), 1),
+                (C2Attribute.MinimumGallonsPerHour, 0, 1),
+                (C2Attribute.MaximumGallonsPerHour, 0, 1),
+            ]
+        requests = [r for r in candidate_requests if r[0] in supported_attribute_ids]
+
+        by_attr_id: dict = {}
+        if requests:
+            raw_results = await self.get_attributes_batch(requests)
+            for av in raw_results:
+                by_attr_id.setdefault(av.attr_id, []).append(av)
+
+        def _first_value(attr_id, index=0):
+            blocks = by_attr_id.get(attr_id)
+            if not blocks:
+                return None
+            for block in sorted(blocks, key=lambda b: b.index):
+                if block.index == index and block.values:
+                    return block.values[0]
+            return None
+
+        def _values_for(attr_id):
+            blocks = by_attr_id.get(attr_id, [])
+            values = []
+            for block in sorted(blocks, key=lambda b: b.index):
+                values.extend(block.values)
+            return values
+
+        device_info = decode_device_info(
+            _first_value(C2Attribute.Model), _first_value(C2Attribute.Name),
+            _first_value(C2Attribute.SerialNumber), None,  # PrimitiveType never fetched here
+            _first_value(C2Attribute.ErrorState), _first_value(C2Attribute.MACAddress),
+        )
+        metadata = decode_metadata_from_batch(by_attr_id, model)
+
+        light_poll = None
+        pump_telemetry = None
+        pump_schedule_points = None
+        if primitive == PrimitiveType.VisualV1:
+            light_poll = decode_light_poll_from_batch(by_attr_id, which, minute_of_day, now)
+        else:
+            pump_schedule_points = decode_pump_schedule_points(_values_for(schedule_attr))
+            speed_raw = _first_value(C2Attribute.MotorSpeed)
+            gph_raw = _first_value(C2Attribute.PhysicalValues, index=int(PhysicalValueID.GallonsPerHour))
+            motor_power_raw = _first_value(C2Attribute.PhysicalValues, index=int(PhysicalValueID.MotorPower))
+            min_gph_raw = _first_value(C2Attribute.MinimumGallonsPerHour)
+            max_gph_raw = _first_value(C2Attribute.MaximumGallonsPerHour)
+            flow_range = decode_pump_flow_range(
+                [min_gph_raw] if min_gph_raw else [], [max_gph_raw] if max_gph_raw else [],
+            )
+            pump_telemetry = decode_pump_telemetry(
+                [speed_raw] if speed_raw else [], [gph_raw] if gph_raw else [],
+                [motor_power_raw] if motor_power_raw else [], flow_range, model, primitive,
+            )
+
+        return FullPollResult(
+            device_info=device_info, metadata=metadata,
+            light_poll=light_poll, pump_telemetry=pump_telemetry,
+            pump_schedule_points=pump_schedule_points, used_batch=True,
+        )
+
+    async def _get_full_poll_via_individual_reads(
+        self, primitive: PrimitiveType, model: Optional[Model],
+        which: int, minute_of_day: int, now: "datetime.datetime",
+    ) -> FullPollResult:
+        """
+        The fallback path -- reuses the existing, already-proven
+        get_device_info()/get_metadata_batch()/get_light_poll_batch()-
+        or-get_pump_telemetry() directly rather than duplicating their
+        own orchestration logic. used_batch=False unconditionally.
+        """
+        device_info = await self.get_device_info()
+        metadata = await self.get_metadata_batch(model=model)
+        light_poll = None
+        pump_telemetry = None
+        pump_schedule_points = None
+        if primitive == PrimitiveType.VisualV1:
+            light_poll = await self.get_light_poll_batch(which=which, minute_of_day=minute_of_day, now=now)
+        else:
+            pump_schedule_points = await self.get_pump_schedule(which=which)
+            pump_telemetry = await self.get_pump_telemetry(model=model, primitive=primitive)
+        return FullPollResult(
+            device_info=device_info, metadata=metadata,
+            light_poll=light_poll, pump_telemetry=pump_telemetry,
+            pump_schedule_points=pump_schedule_points, used_batch=False,
+        )
 
     async def get_current_light_percentages(self, which: int = 1,
                                               minute_of_day: Optional[int] = None,
@@ -3117,25 +3780,28 @@ class MobiusDevice:
         """Same Schedule1/Schedule2 attribute as lights, decoded as PumpPrimitive."""
         attr = C2Attribute.Schedule1 if which == 1 else C2Attribute.Schedule2
         raw = await self.get_attribute(attr, index=0, count=0xFFFF)
-        points = []
-        for element in raw:
-            pt = PumpSchedulePoint.parse(element)
-            if pt is not None:
-                points.append(pt)
-        return points
+        return decode_pump_schedule_points(raw)
 
     async def get_current_pump_block(self, which: int = 1,
-                                      minute_of_day: Optional[int] = None) -> Optional[PumpSchedulePoint]:
+                                      minute_of_day: Optional[int] = None,
+                                      points: Optional[list[PumpSchedulePoint]] = None) -> Optional[PumpSchedulePoint]:
         """
         Returns the PumpSchedulePoint currently active (block lookup, not
         interpolation -- see get_active_pump_block()). Defaults to local
         system time, same rationale as get_current_light_intensities().
+
+        `points` -- pass an already-fetched schedule (e.g. from a
+        caller that already called get_pump_schedule() itself for its
+        own purposes, such as a schedule_point_count) to skip this
+        method's own redundant re-fetch of the exact same attribute.
+        None (the default) fetches it fresh, same as always.
         """
         if minute_of_day is None:
             import datetime
             now = datetime.datetime.now()
             minute_of_day = now.hour * 60 + now.minute
-        points = await self.get_pump_schedule(which)
+        if points is None:
+            points = await self.get_pump_schedule(which)
         return get_active_pump_block(points, minute_of_day)
 
 

{python_mobius-0.6.0.dist-info → python_mobius-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-mobius
-Version: 0.6.0
+Version: 0.7.0
 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.6.0.dist-info → python_mobius-0.7.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-mobius/__init__.py,sha256=EU--56oVYOCdcWx7S_ap82Y0FgjvVsjlcX7kfiAGtXs,6540
+mobius/__init__.py,sha256=-jv9tL5vbjC5ZFfY1vAOZI6s1371TmIZPrkgjyVc7Yc,6610
 mobius/cli.py,sha256=QFphEX10dpPu9bPzUjuUq6K0U9vHG7Kuk-d7BbFfqEs,47541
 mobius/coap.py,sha256=dRE4yUp413etAMhDg2bLvFMLWusqjEWgUpC36i76mJs,10966
 mobius/constants.py,sha256=LA6COD5QE_x97Ue7hKY0KVarcAQxhxWEARYBJtLIww8,42452
 mobius/crc.py,sha256=kLtAYWZvLbo5_p9ep08ZlLg5Yah8Q2qq0IwTvqbBGW0,2700
-mobius/device.py,sha256=xMd1g8mm_RQNjO3TYKfNo2AMz3srxw8LIYAikZFCQv8,156148
+mobius/device.py,sha256=2C5Ry52eUFfSx-28DDesPFQuzkt6QDoUu8ETKBsu9ek,187683
 mobius/device_status.py,sha256=xlLCMU4gLnp59Uqix679jRdVBY2Jt6oI4EUr8fraeRg,34089
 mobius/discovery.py,sha256=Q_Z0riOBrEOwqpwAhk1wesh3340fiIYFi-8BWqhZ0JI,11949
 mobius/dump.py,sha256=S7-KNeDi9TOETm4ty5DwMXTrthvuMau196UENDQoAb4,16785
@@ -15,8 +15,8 @@ mobius/power.py,sha256=2o91-Cl6tC3x9SKJ9gN0fP5HSTFeD31jtd2BwTyBn30,3913
 mobius/pump_status.py,sha256=RWTl8ZViCFDbiFU2mX-WAIH_cWhZOZ0M2B0oYXnPx3Y,1598
 mobius/relay.py,sha256=IG15TtKDjSkmmi_C2cJwPmucX7V4psfamI0hKgTb_v8,24197
 mobius/schedule.py,sha256=kkQgwkFtM3pvik7UFzHKVhPVZrCGSH9AYvAlVA6kAck,10848
-python_mobius-0.6.0.dist-info/METADATA,sha256=nPwPkfpT_K4tlVwBajfhTq94M9j1igyedPUDrpclUYs,8306
-python_mobius-0.6.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-python_mobius-0.6.0.dist-info/entry_points.txt,sha256=Q2hlcek-bWm70zvd12v32essflPgC2su-dKDHAqbPoE,48
-python_mobius-0.6.0.dist-info/licenses/LICENSE,sha256=7a72Msu2Q-TnoiFxemxEGkwafJGObk1W3rw9hzmyM_Y,17984
-python_mobius-0.6.0.dist-info/RECORD,,
+python_mobius-0.7.0.dist-info/METADATA,sha256=LgBpHt0QN5xw5eKuoA6s3MPpPlZTaGSYVZtOFeUSHwg,8306
+python_mobius-0.7.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+python_mobius-0.7.0.dist-info/entry_points.txt,sha256=Q2hlcek-bWm70zvd12v32essflPgC2su-dKDHAqbPoE,48
+python_mobius-0.7.0.dist-info/licenses/LICENSE,sha256=7a72Msu2Q-TnoiFxemxEGkwafJGObk1W3rw9hzmyM_Y,17984
+python_mobius-0.7.0.dist-info/RECORD,,