From f612258fff6b72afe95c3705dc864bda6b6bef1e Mon Sep 17 00:00:00 2001 From: Moustachauve <2206577+Moustachauve@users.noreply.github.com> Date: Wed, 18 Nov 2026 11:44:03 -0500 Subject: [PATCH 1/6] Reconstruct misaligned power, diagnostic, and runtime metrics Previous electrical and runtime fields assumed fixed-point scaling (/ 2560.0 for current and / 32.0 for voltage), which produced nonsensical values such as idle heater draw while the heater was off and negative pump runtimes after 97 days. Controlled live load testing alongside utility smart-meter measurements revealed that the Home Network Adapter's JSON output has a byte-alignment offset across adjacent little-endian values: 16-bit electrical registers are split across neighboring keys in /status and /addDebugData, and 24-bit runtime counters are shifted into adjacent status fields. Reconstructing the split bytes into a unified PowerMetrics model on Spa exposes per-circuit apparent/real power, whole-amp currents, and total power without leaking raw endpoint boundaries to callers. Idle and pump-only power resolve directly from /status alone, so HotSpring.update() only polls /addDebugData when active heater or Jet 3 loads require its upper bytes on spas equipped with current sensors, avoiding extra LoRA radio round-trips when idle or on entry-level boards without current sensing. Partial command echoes and unpaired status updates preserve or invalidate active load readings without pairing bytes from different polls. As a breaking cleanup for v5.0.0, the misdecoded current, voltage, and runtime attributes on Heater, Jet, SpaTestData, and Diagnostics have been removed or replaced. Runtime counters are now routed to the components they actually measure (Jet 1, Jet 3, Blower, and Spa.system_uptime_seconds), SpaTestData retains only calibration fields, and Diagnostics exposes the decoded voltage indicator, clean-cycle flag, and filter cycle durations. --- README.md | 12 +- demo/demo_print_data.py | 55 ++- src/hotspring/__init__.py | 2 + src/hotspring/hotspring.py | 14 +- src/hotspring/models.py | 632 +++++++++++++++++++----- tests/__snapshots__/test_hotspring.ambr | 58 +-- tests/__snapshots__/test_models.ambr | 74 ++- tests/test_hotspring.py | 152 +++++- tests/test_models.py | 495 +++++++++++++++++-- 9 files changed, 1225 insertions(+), 269 deletions(-) diff --git a/README.md b/README.md index f9304de..7b10c7f 100644 --- a/README.md +++ b/README.md @@ -13,10 +13,6 @@ Asynchronous Python client for Hot Spring Connected Spa Kit 2. > This library is currently in heavy development. Not all features might work > perfectly, and some features may not be fully tested as they depend on the > physical hardware available for testing. -> -> The spa's energy consumption estimates (watts, power draw) are not accurate -> and are most likely incorrect, as the power calculation registers have not -> been fully reverse-engineered. ## About @@ -37,9 +33,11 @@ It is primarily designed to be used as the communication layer for an official plus the logo light - **Water care** — Monitor FreshWater IQ salt system metrics (pH, chlorine, ORP, sensor life) -- **Diagnostics & Test Metrics** — Read raw hardware test point currents, line voltages, - sensor flow/switch states, and failure diagnostics -- **Runtime Tracking** — Cumulative heater runtime and individual jet pump runtime in hours +- **Power & Diagnostics**: Read per-circuit power and current metrics (on spas equipped + with current-sensing hardware), filter cycle durations, sensor flow/switch states, and + failure diagnostics +- **Runtime Tracking**: System uptime and cumulative runtime for supported jet pumps and + blower in hours - **Connection monitoring** — Check LoRA bridge and cloud connectivity status - **Energy saving schedules** — View configured energy saving time windows - **Clean cycle** — Start or stop the 10-minute clean cycle diff --git a/demo/demo_print_data.py b/demo/demo_print_data.py index 08b8b07..9b64f56 100644 --- a/demo/demo_print_data.py +++ b/demo/demo_print_data.py @@ -43,11 +43,9 @@ def print_heater_and_jets(s: Spa) -> None: print(f"Current Temp: {s.heater.current_temperature} {unit}") print(f"Set Temp: {s.heater.set_temperature} {unit}") print(f"Heating Mode: {s.heater.heating_mode.value}") - print( - f"Heater Hours: {s.heater.heater_on_hours:.2f} hrs ({s.heater.heater_on_seconds} s)" - ) print(f"Heater Lock: {s.heater.heater_lock}") print(f"Heat Pump: {s.heater.heatpump_installed}") + print(f"System Uptime: {s.system_uptime_hours} hrs ({s.system_uptime_seconds} s)") print("\n" + "=" * 20) print(" JETS & BLOWER") @@ -57,14 +55,24 @@ def print_heater_and_jets(s: Spa) -> None: extra = "" if jet.concurrent_mode: extra += " Concurrent=True" + runtime = ( + f"{jet.on_hours:.2f}h ({jet.on_seconds}s)" + if jet.on_hours is not None + else "N/A" + ) print( f"Jet {jet.jet_id:1}: Available={jet.is_available!s:5} " f"SpeedType={jet.speed_type.value:11} State={jet.speed.value:10} " - f"Supported=[{supported}] Runtime={jet.on_hours:.2f}h ({jet.on_seconds}s){extra}" + f"Supported=[{supported}] Runtime={runtime}{extra}" ) + blower_runtime = ( + f"{s.blower.on_hours:.2f}h ({s.blower.on_seconds}s)" + if s.blower.on_hours is not None + else "N/A" + ) print( f"Blower: Status={'ON' if s.blower.is_on else 'OFF':3} " - f"Enabled={s.blower.is_enabled}" + f"Enabled={s.blower.is_enabled} Runtime={blower_runtime}" ) @@ -104,26 +112,41 @@ def print_lighting_and_watercare(s: Spa) -> None: def print_diagnostics(s: Spa) -> None: - """Print diagnostics info.""" + """Print power and diagnostics info.""" + print("\n" + "=" * 20) + print(" POWER & CURRENT") + print("=" * 20) + print(f"Supported: {s.power.supported}") + print(f"Total Power: {s.power.total_power} VA/W") + print( + f"Small Loads: {s.power.small_loads_power} W ({s.power.small_loads_current} A)" + ) + print( + f"J1+J2+Blower: {s.power.jet1_jet2_blower_power} VA " + f"({s.power.jet1_jet2_blower_current} A)" + ) + print(f"Heater: {s.power.heater_power} W ({s.power.heater_current} A)") + print(f"Jet 3: {s.power.jet3_power} VA ({s.power.jet3_current} A)") + print("\n" + "=" * 20) print(" DIAGNOSTICS (DEBUG)") print("=" * 20) print(f"Failure State: {s.diagnostics.spa_failure_state.value}") - print(f"L1 Volts: {s.diagnostics.l1_n_volts:.1f} V") - print(f"L2 Volts: {s.diagnostics.l2_n_volts:.1f} V") - print(f"Heater Volts: {s.diagnostics.heater_volts:.1f} V") - print(f"Jet 3 Volts: {s.diagnostics.jet3_volts:.1f} V") - print(f"Frequency: {s.diagnostics.power_frequency} Hz") + print(f"L2 >= 256V: {s.diagnostics.l2_voltage_above_256v}") + print(f"Jet 3 Volts: {s.diagnostics.jet3_volts} V") + print( + f"Filter 1 / 2: {s.diagnostics.filter_1_minutes} / {s.diagnostics.filter_2_minutes} min" + ) + print(f"Frequency Flag: {s.diagnostics.power_frequency}") print(f"Circ Flow: {s.diagnostics.circulation_pump_flow_status}") print(f"Pressure Switch: {s.diagnostics.pressure_switch_status}") print("\n" + "=" * 20) - print(" RAW TEST METRICS") + print(" CALIBRATION METRICS") print("=" * 20) - print(f"Heater Current: {s.test_metrics.heater_current:.2f} A") - print(f"Jet 3 Current: {s.test_metrics.jet3_current:.2f} A") - print(f"Small Loads: {s.test_metrics.small_loads_current:.2f} A") - print(f"J1+J2+Blower: {s.test_metrics.jet1_jet2_blower_current:.2f} A") + print(f"Heater Test: {s.test_metrics.heater_test_status}") + print(f"Temp Offset: {s.test_metrics.temp_offset}") + print(f"Vsense Cal: {s.test_metrics.vsense_cal}") print("\n" + "=" * 20) print(" VERSIONS") diff --git a/src/hotspring/__init__.py b/src/hotspring/__init__.py index 0bbf311..59f07b9 100644 --- a/src/hotspring/__init__.py +++ b/src/hotspring/__init__.py @@ -35,6 +35,7 @@ Jet, LightZone, LogoLight, + PowerMetrics, Spa, SpaInfo, SpaLock, @@ -71,6 +72,7 @@ "LightWheelMode", "LightZone", "LogoLight", + "PowerMetrics", "Spa", "SpaBrand", "SpaFailureState", diff --git a/src/hotspring/hotspring.py b/src/hotspring/hotspring.py index 525a2fb..f834261 100644 --- a/src/hotspring/hotspring.py +++ b/src/hotspring/hotspring.py @@ -258,7 +258,9 @@ async def update(self, *, refresh_identity: bool = False) -> Spa: On subsequent routine polling cycles, it queries /status and /spaConnectStatus sequentially, avoiding redundant radio (LoRA) queries for static identity data - while keeping telemetry and connection status fresh. + while keeping telemetry and connection status fresh. When power monitoring is + supported and active loads (such as the heater or Jet 3) require /addDebugData + to complete power reconstruction, it is also fetched opportunistically. Args: ---- @@ -314,6 +316,7 @@ async def update(self, *, refresh_identity: bool = False) -> Spa: ) raise HotSpringSNADetectedError(msg) + await self._refresh_power_diagnostics() self._identity_loaded = True return self.spa @@ -334,8 +337,17 @@ async def update(self, *, refresh_identity: bool = False) -> Spa: ): self.spa.connection_status.spa_connected = True + await self._refresh_power_diagnostics() return self.spa + async def _refresh_power_diagnostics(self) -> None: + """Fetch /addDebugData when active loads require it for power metrics.""" + if self.spa is not None and self.spa.needs_diagnostics_for_power: + debug_res = await self._safe_request(Endpoint.DEBUG_DATA) + if debug_res: + with _parsing(Endpoint.DEBUG_DATA): + self.spa.update_diagnostics(debug_res) + async def get_device_info(self) -> SpaInfo: """Fetch lightweight device identity directly from /startup. diff --git a/src/hotspring/models.py b/src/hotspring/models.py index f31902d..40adb2b 100644 --- a/src/hotspring/models.py +++ b/src/hotspring/models.py @@ -53,6 +53,9 @@ class Spa: connection_status: ConnectionStatus diagnostics: Diagnostics test_metrics: SpaTestData + power: PowerMetrics + system_uptime_seconds: int | None + _status_electrical: _StatusElectrical | None def __init__(self, data: dict[str, object]) -> None: """Initialize a Spa from the API response. @@ -72,11 +75,14 @@ def __init__(self, data: dict[str, object]) -> None: self.water_care = WaterCare() self.freshwater_iq = FreshWaterIQ() self.test_metrics = SpaTestData() + self.power = PowerMetrics() + self.system_uptime_seconds = None self.energy_savings = {} self.versions = Versions() self.info = SpaInfo() self.connection_status = ConnectionStatus() self.diagnostics = Diagnostics() + self._status_electrical = None if data: self.update_from_dict(data) @@ -93,6 +99,9 @@ def update_from_dict(self, data: dict[str, object]) -> set[str]: """ updated: set[str] = set() + prior_active = self._active_circuit_flags + prev_power = self.power + prev_uptime = self.system_uptime_seconds for section in _SECTION_PARSERS: if section.json_key in data and isinstance(data[section.json_key], dict): @@ -142,6 +151,21 @@ def update_from_dict(self, data: dict[str, object]) -> set[str]: updated.add("freshwater_iq") updated.add("versions") + self._apply_shifted_runtimes(data, updated) + if self.system_uptime_seconds != prev_uptime: + updated.add("system_uptime_seconds") + + next_electrical = _extract_status_electrical(data) + if next_electrical is not None: + self._status_electrical = next_electrical + + self._recompute_power( + prior_active=prior_active, + status_fresh=next_electrical is not None, + ) + if self.power != prev_power: + updated.add("power") + return updated def update_info(self, data: dict[str, object]) -> None: @@ -196,14 +220,18 @@ def update_connection_status(self, data: dict[str, object]) -> None: self.connection_status = ConnectionStatus.from_dict(data) def update_diagnostics(self, data: dict[str, object]) -> None: - """Update diagnostics from /addDebugData response. + """Update diagnostics and power metrics from /addDebugData response. Args: ---- data: The JSON response from GET /addDebugData. """ - self.diagnostics = Diagnostics.from_dict(data) + self.diagnostics, debug_electrical = _parse_diagnostics_and_electrical(data) + self._recompute_power( + prior_active=self._active_circuit_flags, + debug_electrical=debug_electrical, + ) def update_freshwater_iq(self, data: dict[str, object]) -> None: """Update FreshWater IQ data from /getFWIQData response. @@ -227,6 +255,173 @@ def _apply_fwiq_firmware_installed(self) -> bool: return True return False + def _apply_shifted_runtimes( + self, data: dict[str, object], updated: set[str] + ) -> None: + """Route misaligned 24-bit runtime fields to their actual components. + + Live testing shows that runtime counters in /status are shifted across + adjacent fields: ``heaterHours`` tracks Jet 1 runtime, ``jet_1_ON_sec`` + tracks overall system uptime, ``jet_2_ON_sec`` tracks Jet 3 runtime, and + ``jet_3_ON_sec`` tracks blower runtime. + """ + raw_j1_on, raw_upt, raw_j3_on, raw_blower_on = _extract_raw_runtimes(data) + present_values = [ + v for v in (raw_j1_on, raw_upt, raw_j3_on, raw_blower_on) if v is not None + ] + if not present_values: + return + + is_synced = ( + bool(self.versions.control_box) + or self.system_uptime_seconds is not None + or any(v != 0 for v in present_values) + ) + if not is_synced: + return + + if raw_upt is not None: + self.system_uptime_seconds = raw_upt + if ( + raw_j1_on is not None + and 1 in self.jets + and self.jets[1].on_seconds != raw_j1_on + ): + self.jets[1] = replace(self.jets[1], on_seconds=raw_j1_on) + updated.add("jets") + if ( + raw_j3_on is not None + and 3 in self.jets + and self.jets[3].on_seconds != raw_j3_on + ): + self.jets[3] = replace(self.jets[3], on_seconds=raw_j3_on) + updated.add("jets") + if raw_blower_on is not None and self.blower.on_seconds != raw_blower_on: + self.blower = replace(self.blower, on_seconds=raw_blower_on) + updated.add("blower") + + def _recompute_power( + self, + *, + prior_active: tuple[bool, bool, tuple[JetSpeed, JetSpeed, bool]], + status_fresh: bool = False, + debug_electrical: _DebugElectrical | None = None, + ) -> None: + """Reconstruct PowerMetrics from /status and paired /addDebugData words.""" + if self._status_electrical is None: + self.power = PowerMetrics() + return + + se = self._status_electrical + small_loads_power = _reconstruct_u16(se.h_cur, se.j3_cur) + if small_loads_power <= 0: + self.power = PowerMetrics() + return + + was_heating, was_jet3_on, prior_j12b_state = prior_active + jet3_is_on = self._is_jet3_on + j12b_state = self._j12b_state + j12b_is_on = j12b_state != (JetSpeed.OFF, JetSpeed.OFF, False) + same_j12b = j12b_is_on and j12b_state == prior_j12b_state + de = debug_electrical + + self.power = PowerMetrics( + supported=True, + small_loads_power=small_loads_power, + jet1_jet2_blower_power=_resolve_gated_metric( + is_active=j12b_is_on, + was_active=same_j12b, + fresh_value=( + _reconstruct_u16(se.sl_cur, se.h_cur) if status_fresh else None + ), + previous_value=self.power.jet1_jet2_blower_power, + ), + heater_power=_resolve_gated_metric( + is_active=self.heater.is_on, + was_active=was_heating, + fresh_value=( + _reconstruct_u16(se.j3_cur, de.j12p_raw) if de is not None else None + ), + previous_value=self.power.heater_power, + ), + jet3_power=_resolve_gated_metric( + is_active=jet3_is_on, + was_active=was_jet3_on, + fresh_value=( + _reconstruct_u16(de.j12p_raw, de.slp_raw) + if de is not None + else None + ), + previous_value=self.power.jet3_power, + ), + jet1_jet2_blower_current=_resolve_gated_metric( + is_active=j12b_is_on, + was_active=same_j12b, + fresh_value=( + _reconstruct_u16(de.l2_raw, de.hv_raw) if de is not None else None + ), + previous_value=self.power.jet1_jet2_blower_current, + ), + small_loads_current=( + _reconstruct_u16(de.hv_raw, de.j3v_raw) + if de is not None + else self.power.small_loads_current + ), + heater_current=_resolve_gated_metric( + is_active=self.heater.is_on, + was_active=was_heating, + fresh_value=( + _reconstruct_u16(de.j3v_raw, se.j12b_cur) + if de is not None + else None + ), + previous_value=self.power.heater_current, + ), + jet3_current=_resolve_gated_metric( + is_active=jet3_is_on, + was_active=was_jet3_on, + fresh_value=( + _reconstruct_u16(se.j12b_cur, se.sl_cur) if status_fresh else None + ), + previous_value=self.power.jet3_current, + ), + ) + + @property + def _active_circuit_flags( + self, + ) -> tuple[bool, bool, tuple[JetSpeed, JetSpeed, bool]]: + """Return active-state snapshot for (heater, jet3, jet1+jet2+blower).""" + return (self.heater.is_on, self._is_jet3_on, self._j12b_state) + + @property + def _is_jet3_on(self) -> bool: + """Return True if an enabled Jet 3 is currently running.""" + return bool((jet3 := self.jets.get(3)) and jet3.is_enabled and jet3.is_on) + + @property + def _j12b_state(self) -> tuple[JetSpeed, JetSpeed, bool]: + """Return normalized active state of (Jet 1, Jet 2, Blower).""" + jet1 = self.jets.get(1) + jet2 = self.jets.get(2) + return ( + jet1.speed if jet1 is not None and jet1.is_on else JetSpeed.OFF, + jet2.speed if jet2 is not None and jet2.is_on else JetSpeed.OFF, + self.blower.is_on, + ) + + @property + def system_uptime_hours(self) -> float | None: + """Return system uptime in hours when available.""" + if self.system_uptime_seconds is None: + return None + return round(self.system_uptime_seconds / 3600.0, 2) + + @property + def needs_diagnostics_for_power(self) -> bool: + """Return True when /addDebugData is needed for active power readings.""" + return self.power.supported and (self.heater.is_on or self._is_jet3_on) + @property def is_hna(self) -> bool: """Return True if this device is the Home Network Adapter (HNA).""" @@ -361,24 +556,17 @@ def is_hna(self) -> bool: @dataclass -class Heater: # pylint: disable=too-many-instance-attributes +class Heater: """Heater status and configuration.""" is_on: bool = False heater_lock: bool = False heatpump_installed: bool = False heating_mode: HeatingMode = HeatingMode.UNKNOWN - heater_current: float = 0.0 - heater_on_seconds: int = 0 set_temperature: float | None = None current_temperature: float | None = None temperature_unit: TemperatureUnit = TemperatureUnit.UNKNOWN - @property - def heater_on_hours(self) -> float: - """Return cumulative heater runtime in hours.""" - return round(self.heater_on_seconds / 3600.0, 2) - @staticmethod def from_dict(data: dict[str, object], existing: Heater | None = None) -> Heater: """Create a Heater from API response data. @@ -415,8 +603,7 @@ class Jet: speed_type: JetSpeedType = JetSpeedType.UNKNOWN is_enabled: bool = True concurrent_mode: bool = False - current: float = 0.0 - on_seconds: int = 0 + on_seconds: int | None = None @property def is_available(self) -> bool: @@ -448,8 +635,10 @@ def supported_speeds(self) -> list[JetSpeed]: return [JetSpeed.OFF, JetSpeed.HIGH_SPEED] @property - def on_hours(self) -> float: - """Return cumulative jet runtime in hours.""" + def on_hours(self) -> float | None: + """Return cumulative jet runtime in hours when available.""" + if self.on_seconds is None: + return None return round(self.on_seconds / 3600.0, 2) @staticmethod @@ -486,22 +675,8 @@ def from_dict( ) status = data.get("status") - if isinstance(status, dict): - if "speed" in status: - kwargs["speed"] = JetSpeed.build(status.get("speed")) - if "current" in status: - kwargs["current"] = int(status.get("current", 0)) / 2560.0 - on_sec_key = f"jet_{jet_id}_ON_sec" - if on_sec_key in status: - # The ESP32 firmware tracks runtime using an unsigned 32-bit counter - # in units of 1/256 seconds (Q24.8 fixed-point), but formats it as a - # signed 32-bit integer (`%d`) in the JSON output. Once runtime - # exceeds 2^31 ticks (~97.1 days), it overflows into a negative value. - # Masking with `& 0xFFFFFFFF` restores the true unsigned 32-bit counter - # before dividing by 256 to convert to whole elapsed seconds. - kwargs["on_seconds"] = ( - int(status.get(on_sec_key, 0)) & 0xFFFFFFFF - ) // 256 + if isinstance(status, dict) and "speed" in status: + kwargs["speed"] = JetSpeed.build(status["speed"]) control = data.get("control") if isinstance(control, str): @@ -509,7 +684,7 @@ def from_dict( if speed != JetSpeed.UNKNOWN: kwargs["speed"] = speed elif isinstance(control, dict) and "speed" in control: - speed = JetSpeed.build(control.get("speed")) + speed = JetSpeed.build(control["speed"]) if speed != JetSpeed.UNKNOWN: kwargs["speed"] = speed @@ -555,6 +730,14 @@ class Blower: is_enabled: bool = False is_on: bool = False + on_seconds: int | None = None + + @property + def on_hours(self) -> float | None: + """Return cumulative blower runtime in hours when available.""" + if self.on_seconds is None: + return None + return round(self.on_seconds / 3600.0, 2) @staticmethod def from_dict(data: dict[str, object], existing: Blower | None = None) -> Blower: @@ -573,17 +756,17 @@ def from_dict(data: dict[str, object], existing: Blower | None = None) -> Blower kwargs: dict[str, object] = {} config = data.get("config") if isinstance(config, dict) and "blower" in config: - kwargs["is_enabled"] = config.get("blower", "disable") != "disable" + kwargs["is_enabled"] = config["blower"] != "disable" status = data.get("status") if isinstance(status, dict) and "blower" in status: - kwargs["is_on"] = status.get("blower", "off") not in ("off", "disable") + kwargs["is_on"] = status["blower"] not in ("off", "disable") control = data.get("control") if isinstance(control, str): kwargs["is_on"] = _is_truthy(control) elif isinstance(control, dict) and "blower" in control: - raw_blower = control.get("blower") + raw_blower = control["blower"] if raw_blower is not None: kwargs["is_on"] = _is_truthy(raw_blower) @@ -1086,17 +1269,54 @@ def from_dict(data: dict[str, object]) -> ConnectionStatus: return ConnectionStatus(spa_connected=connected) +@dataclass +class PowerMetrics: # pylint: disable=too-many-instance-attributes + """Reconstructed electrical power and current telemetry. + + On IQ2020/Eagle control boards equipped with current-sensing hardware, + power readings reflect apparent power (``V_rms * I_rms`` in VA, equal to + real Watts for the resistive heater and within ~1-25% of real Watts on + pump motors depending on power factor). On entry-level control boards + without current sensors or before initial controller sync, ``supported`` + is ``False`` and all reading fields remain ``None``. + """ + + supported: bool = False + small_loads_power: int | None = None + jet1_jet2_blower_power: int | None = None + heater_power: int | None = None + jet3_power: int | None = None + jet1_jet2_blower_current: int | None = None + small_loads_current: int | None = None + heater_current: int | None = None + jet3_current: int | None = None + + @property + def total_power(self) -> int | None: + """Return combined power across all four spa circuits when known.""" + if ( + not self.supported + or self.small_loads_power is None + or self.jet1_jet2_blower_power is None + or self.heater_power is None + or self.jet3_power is None + ): + return None + return ( + self.small_loads_power + + self.jet1_jet2_blower_power + + self.heater_power + + self.jet3_power + ) + + @dataclass class SpaTestData: - """Test data metrics from the spa, including raw current readings.""" + """Factory calibration and test-status values from the spa.""" heater_test_status: str = "off" temp_offset: float = 0.0 vsense_cal: float = 0.0 - jet1_jet2_blower_current: float = 0.0 - small_loads_current: float = 0.0 - heater_current: float = 0.0 - jet3_current: float = 0.0 @staticmethod def from_dict( @@ -1118,28 +1338,11 @@ def from_dict( status = data.get("status") if isinstance(status, dict): if "heaterTestStatus" in status: - kwargs["heater_test_status"] = str( - status.get("heaterTestStatus", "off") - ) + kwargs["heater_test_status"] = str(status["heaterTestStatus"]) if "tempOffset" in status: - kwargs["temp_offset"] = float(status.get("tempOffset", 0.0)) + kwargs["temp_offset"] = float(status["tempOffset"]) if "VsenseCal" in status: - kwargs["vsense_cal"] = float(status.get("VsenseCal", 0.0)) - # Current metrics are encoded in Q8.8 fixed-point deciapps (0.1 A units - # left-shifted by 8 bits / multiplied by 256). - # Dividing by 2560.0 (256 * 10) scales the raw integer to Amperes (A). - if "jet1+jet2+blowerCurrent" in status: - kwargs["jet1_jet2_blower_current"] = ( - int(status.get("jet1+jet2+blowerCurrent", 0)) / 2560.0 - ) - if "smallLoadsCurrent" in status: - kwargs["small_loads_current"] = ( - int(status.get("smallLoadsCurrent", 0)) / 2560.0 - ) - if "heaterCurrent" in status: - kwargs["heater_current"] = int(status.get("heaterCurrent", 0)) / 2560.0 - if "jet3Current" in status: - kwargs["jet3_current"] = int(status.get("jet3Current", 0)) / 2560.0 + kwargs["vsense_cal"] = float(status["VsenseCal"]) base = existing or SpaTestData() return replace(base, **kwargs) @@ -1147,12 +1350,7 @@ def from_dict( @dataclass class Diagnostics: # pylint: disable=too-many-instance-attributes - """Diagnostic and power metrics from the spa. - - Availability depends on the spa model and whether the main control - board (IQ2020/Eagle) is equipped with current-sensing transformers. - Values may be ``0`` if sensors are not installed. - """ + """Hardware diagnostic status flags and filter settings from /addDebugData.""" spa_failure_state: SpaFailureState = SpaFailureState.UNKNOWN heater_error: str = "0" @@ -1161,14 +1359,11 @@ class Diagnostics: # pylint: disable=too-many-instance-attributes circulation_pump_flow_status: str = "0" regulation_thermistor_temp_status: str = "0" limit_thermistor_status: str = "0" - l1_n_volts: float = 0.0 - l2_n_volts: float = 0.0 - heater_volts: float = 0.0 - jet3_volts: float = 0.0 - jet1_jet2_blower_power: str = "0" - small_loads_power: str = "0" - heater_power: str = "0" - jet3_power: str = "0" + l2_voltage_above_256v: bool | None = None + jet3_volts: int | None = None + daily_clean_cycle: int | None = None + filter_1_minutes: int | None = None + filter_2_minutes: int | None = None @staticmethod def from_dict(data: dict[str, object]) -> Diagnostics: @@ -1184,47 +1379,247 @@ def from_dict(data: dict[str, object]) -> Diagnostics: A Diagnostics instance. """ - debug_data = data.get("debugData") - if not isinstance(debug_data, dict): - return Diagnostics() - - debug = debug_data.get("status") - if not isinstance(debug, dict) or not debug: - return Diagnostics() - - volt_keys = { - "L1_N_Volts": "l1_n_volts", - "L2_N_Volts": "l2_n_volts", - "Heater_Volts": "heater_volts", - "jet3_Volts": "jet3_volts", - } - str_keys = { - "heaterError": "heater_error", - "powerFrequency": "power_frequency", - "pressureSwitchStatus": "pressure_switch_status", - "circulationPumpFlowStatus": "circulation_pump_flow_status", - "regulationThermistorTempStatus": "regulation_thermistor_temp_status", - "limitThermistorStatus": "limit_thermistor_status", - "jet1_jet2_blowerPower": "jet1_jet2_blower_power", - "smallLoadsPower": "small_loads_power", - "heaterPower": "heater_power", - "jet3Power": "jet3_power", - } - kwargs: dict[str, object] = {} - if "spaFailureState" in debug: - kwargs["spa_failure_state"] = SpaFailureState.build( - debug.get("spaFailureState") - ) - for json_key, attr in str_keys.items(): - if json_key in debug: - kwargs[attr] = str(debug[json_key]) - # Voltage registers use Q11.5 fixed-point format (1/32 V resolution). - # Dividing raw integer by 32.0 converts to Volts. - for json_key, attr in volt_keys.items(): - if json_key in debug: - kwargs[attr] = int(debug.get(json_key) or 0) / 32.0 + diagnostics, _ = _parse_diagnostics_and_electrical(data) + return diagnostics + + +@dataclass(frozen=True) +class _StatusElectrical: + """Raw 16-bit electrical words carried in /status.""" + + j12b_cur: int = 0 + sl_cur: int = 0 + h_cur: int = 0 + j3_cur: int = 0 + + +@dataclass(frozen=True) +class _DebugElectrical: + """Raw 16-bit electrical words carried in /addDebugData.""" + + l2_raw: int = 0 + hv_raw: int = 0 + j3v_raw: int = 0 + j12p_raw: int = 0 + slp_raw: int = 0 + + +def _reconstruct_u16(low_word: int, high_word: int) -> int: + """Reconstruct a 16-bit register split across two adjacent misaligned words. + + Live load testing shows an alignment bug in the HNA's JSON output where + adjacent 16-bit values are shifted by one byte: ``low_word`` holds the + register's low byte in bits 8..15, and ``high_word`` holds its high byte + in bits 0..7. + """ + return ((high_word & 0xFF) << 8) | ((low_word >> 8) & 0xFF) + + +def _decode_runtime_seconds(raw: object) -> int: + """Decode a 24-bit runtime counter shifted by 8 bits into signed 32-bit JSON. - return replace(Diagnostics(), **kwargs) + Runtime counters are left-shifted by 8 bits and formatted as signed 32-bit + integers, wrapping negative past ~97.1 days. Masking with ``0xFFFFFFFF`` + and shifting right by 8 recovers elapsed whole seconds. + """ + raw_int: int = int(raw) + return (raw_int & 0xFFFFFFFF) >> 8 + + +def _find_jet_status(jets_data: dict[str, object], jet_id: int) -> dict[str, object]: + """Return the status dict for ``JET`` (case-insensitive), or empty dict.""" + target = f"JET{jet_id}" + source = ( + jets_data["control"] + if "control" in jets_data and isinstance(jets_data["control"], dict) + else jets_data + ) + for key, value in source.items(): + if key.upper() == target and isinstance(value, dict): + status = value.get("status") + if isinstance(status, dict): + return status + return {} + + +def _extract_raw_runtimes( + data: dict[str, object], +) -> tuple[int | None, int | None, int | None, int | None]: + """Extract decoded runtime counters from /status sections when present.""" + raw_j1_on: int | None = None + raw_upt: int | None = None + raw_j3_on: int | None = None + raw_blower_on: int | None = None + + heater = data.get("heater") + if isinstance(heater, dict): + h_status = heater.get("status") + if isinstance(h_status, dict) and "heaterHours" in h_status: + raw_j1_on = _decode_runtime_seconds(h_status["heaterHours"]) + + jets = data.get("JET") + if isinstance(jets, dict): + j1_status = _find_jet_status(jets, 1) + if "jet_1_ON_sec" in j1_status: + raw_upt = _decode_runtime_seconds(j1_status["jet_1_ON_sec"]) + + j2_status = _find_jet_status(jets, 2) + if "jet_2_ON_sec" in j2_status: + raw_j3_on = _decode_runtime_seconds(j2_status["jet_2_ON_sec"]) + + j3_status = _find_jet_status(jets, 3) + if "jet_3_ON_sec" in j3_status: + raw_blower_on = _decode_runtime_seconds(j3_status["jet_3_ON_sec"]) + + return raw_j1_on, raw_upt, raw_j3_on, raw_blower_on + + +_TD_ELECTRICAL_KEYS: tuple[str, ...] = ( + "jet1+jet2+blowerCurrent", + "smallLoadsCurrent", + "heaterCurrent", + "jet3Current", +) + + +def _extract_status_electrical(data: dict[str, object]) -> _StatusElectrical | None: + """Extract a complete 4-word electrical block from /status when present. + + Standalone ``heaterCurrent`` or ``JET3.status.current`` fields in partial + command echoes are validated as integers, while ``_StatusElectrical`` is + only updated when ``test_data.status`` carries all four contiguous words so + adjacent bytes are never paired across different polls. + """ + heater = data.get("heater") + if isinstance(heater, dict): + h_status = heater.get("status") + if isinstance(h_status, dict) and "heaterCurrent" in h_status: + int(h_status["heaterCurrent"]) + + jets = data.get("JET") + if isinstance(jets, dict): + j3_status = _find_jet_status(jets, 3) + if "current" in j3_status: + int(j3_status["current"]) + + test_data = data.get("test_data") + if not isinstance(test_data, dict): + return None + td_status = test_data.get("status") + if not isinstance(td_status, dict) or not all( + key in td_status for key in _TD_ELECTRICAL_KEYS + ): + return None + + return _StatusElectrical( + j12b_cur=int(td_status["jet1+jet2+blowerCurrent"]), + sl_cur=int(td_status["smallLoadsCurrent"]), + h_cur=int(td_status["heaterCurrent"]), + j3_cur=int(td_status["jet3Current"]), + ) + + +_DEBUG_STR_KEYS: dict[str, str] = { + "heaterError": "heater_error", + "powerFrequency": "power_frequency", + "pressureSwitchStatus": "pressure_switch_status", + "circulationPumpFlowStatus": "circulation_pump_flow_status", + "regulationThermistorTempStatus": "regulation_thermistor_temp_status", + "limitThermistorStatus": "limit_thermistor_status", +} + +_DEBUG_INT_KEYS: tuple[str, ...] = ( + "L1_N_Volts", + "L2_N_Volts", + "Heater_Volts", + "jet3_Volts", + "jet1_jet2_blowerPower", + "smallLoadsPower", + "heaterPower", + "jet3Power", +) + + +def _resolve_gated_metric( + *, + is_active: bool, + was_active: bool, + fresh_value: int | None, + previous_value: int | None, +) -> int | None: + """Resolve an active-gated metric without tearing across asynchronous polls.""" + if not is_active: + return 0 + if fresh_value is not None: + return fresh_value + if was_active: + return previous_value + return None + + +def _decode_synced_diagnostics_fields(parsed_ints: dict[str, int]) -> dict[str, object]: + """Extract decoded voltage, clean-cycle, and filter fields from /addDebugData.""" + decoded: dict[str, object] = {} + if "L1_N_Volts" in parsed_ints: + l1_raw = parsed_ints["L1_N_Volts"] + decoded["l2_voltage_above_256v"] = bool(l1_raw & 0xFF) + if "L2_N_Volts" in parsed_ints: + decoded["jet3_volts"] = _reconstruct_u16(l1_raw, parsed_ints["L2_N_Volts"]) + if "smallLoadsPower" in parsed_ints: + decoded["daily_clean_cycle"] = (parsed_ints["smallLoadsPower"] >> 8) & 0xFF + if "heaterPower" in parsed_ints: + decoded["filter_1_minutes"] = parsed_ints["heaterPower"] + if "jet3Power" in parsed_ints: + decoded["filter_2_minutes"] = parsed_ints["jet3Power"] + return decoded + + +def _parse_diagnostics_and_electrical( + data: dict[str, object], +) -> tuple[Diagnostics, _DebugElectrical | None]: + """Parse /addDebugData into Diagnostics and raw electrical words.""" + debug_data = data.get("debugData") + if not isinstance(debug_data, dict): + return Diagnostics(), None + + debug = debug_data.get("status") + if not isinstance(debug, dict) or not debug: + return Diagnostics(), None + + str_fields = { + attr: str(debug[json_key]) + for json_key, attr in _DEBUG_STR_KEYS.items() + if json_key in debug + } + parsed_ints = { + json_key: int(debug[json_key]) + for json_key in _DEBUG_INT_KEYS + if json_key in debug + } + + raw_failure = debug.get("spaFailureState") + has_fault = raw_failure is not None and str(raw_failure) not in ("", "Spa_Ok") + is_synced = ( + has_fault + or any(v != "0" for v in str_fields.values()) + or any(v != 0 for v in parsed_ints.values()) + ) + if not is_synced: + return Diagnostics(), None + + kwargs: dict[str, object] = dict(str_fields) + if "spaFailureState" in debug: + kwargs["spa_failure_state"] = SpaFailureState.build(raw_failure) + kwargs.update(_decode_synced_diagnostics_fields(parsed_ints)) + + debug_elec = _DebugElectrical( + l2_raw=parsed_ints.get("L2_N_Volts", 0), + hv_raw=parsed_ints.get("Heater_Volts", 0), + j3v_raw=parsed_ints.get("jet3_Volts", 0), + j12p_raw=parsed_ints.get("jet1_jet2_blowerPower", 0), + slp_raw=parsed_ints.get("smallLoadsPower", 0), + ) + return replace(Diagnostics(), **kwargs), debug_elec class _SectionParser(NamedTuple): @@ -1298,17 +1693,6 @@ def _parse_heater_status(status: dict[str, object]) -> dict[str, object]: mode = HeatingMode.build(raw_mode) if mode != HeatingMode.UNKNOWN or str(raw_mode).strip().lower() == "invalid": kwargs["heating_mode"] = mode - if "heaterCurrent" in status: - # Motherboard current registers use Q8.8 fixed point in deciapps (0.1 A): - # raw / 256 / 10.0 = raw / 2560.0 Amperes. - kwargs["heater_current"] = int(status.get("heaterCurrent", 0)) / 2560.0 - if "heaterHours" in status: - # Like jet runtime counters, `heaterHours` is an unsigned 32-bit counter - # in 1/256 seconds (Q24.8) formatted as signed `%d` in ESP32 JSON. - # Mask with `& 0xFFFFFFFF` to handle 32-bit integer overflow and divide by 256. - kwargs["heater_on_seconds"] = ( - int(status.get("heaterHours", 0)) & 0xFFFFFFFF - ) // 256 kwargs.update(_parse_heater_temperatures(status)) return kwargs diff --git a/tests/__snapshots__/test_hotspring.ambr b/tests/__snapshots__/test_hotspring.ambr index 87eca2e..890727f 100644 --- a/tests/__snapshots__/test_hotspring.ambr +++ b/tests/__snapshots__/test_hotspring.ambr @@ -4,6 +4,7 @@ blower=Blower( is_enabled=False, is_on=False, + on_seconds=0, ), clean_cycle=CleanCycle( clean_timer_enabled=False, @@ -18,20 +19,17 @@ device_type=, diagnostics=Diagnostics( circulation_pump_flow_status='0', + daily_clean_cycle=0, + filter_1_minutes=60, + filter_2_minutes=30, heater_error='0', - heater_power='0', - heater_volts=0.0, - jet1_jet2_blower_power='0', - jet3_power='0', - jet3_volts=0.0, - l1_n_volts=0.0, - l2_n_volts=0.0, + jet3_volts=0, + l2_voltage_above_256v=False, limit_thermistor_status='0', power_frequency='0', - pressure_switch_status='0', + pressure_switch_status='1', regulation_thermistor_temp_status='0', - small_loads_power='0', - spa_failure_state=, + spa_failure_state=, ), energy_savings=dict({ 1: EnergySaving( @@ -63,9 +61,7 @@ ), heater=Heater( current_temperature=100.0, - heater_current=7.5, heater_lock=False, - heater_on_seconds=52046, heating_mode=, heatpump_installed=False, is_on=True, @@ -89,25 +85,22 @@ jets=dict({ 1: Jet( concurrent_mode=False, - current=0.0, is_enabled=True, jet_id=1, - on_seconds=1061668, + on_seconds=52046, speed=, speed_type=, ), 2: Jet( concurrent_mode=False, - current=0.0, is_enabled=True, jet_id=2, - on_seconds=0, + on_seconds=None, speed=, speed_type=, ), 3: Jet( concurrent_mode=False, - current=0.0, is_enabled=False, jet_id=3, on_seconds=0, @@ -172,15 +165,25 @@ logo_light=LogoLight( brightness=, ), + needs_diagnostics_for_power=True, + power=PowerMetrics( + heater_current=14, + heater_power=3584, + jet1_jet2_blower_current=15, + jet1_jet2_blower_power=0, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=75, + supported=True, + ), spa_lock=SpaLock( is_locked=False, ), + system_uptime_hours=294.91, + system_uptime_seconds=1061668, test_metrics=SpaTestData( - heater_current=7.5, heater_test_status='off', - jet1_jet2_blower_current=0.0, - jet3_current=0.0, - small_loads_current=0.0, temp_offset=0.0, vsense_cal=0.0, ), @@ -213,19 +216,16 @@ # name: TestUpdateDiagnostics.test_update_diagnostics Diagnostics( circulation_pump_flow_status='0', + daily_clean_cycle=0, + filter_1_minutes=60, + filter_2_minutes=30, heater_error='0', - heater_power='60', - heater_volts=0.0, - jet1_jet2_blower_power='14', - jet3_power='30', - jet3_volts=112.0, - l1_n_volts=0.0, - l2_n_volts=120.0, + jet3_volts=0, + l2_voltage_above_256v=False, limit_thermistor_status='0', power_frequency='0', pressure_switch_status='1', regulation_thermistor_temp_status='0', - small_loads_power='0', spa_failure_state=, ) # --- diff --git a/tests/__snapshots__/test_models.ambr b/tests/__snapshots__/test_models.ambr index db541ea..9b73341 100644 --- a/tests/__snapshots__/test_models.ambr +++ b/tests/__snapshots__/test_models.ambr @@ -3,12 +3,14 @@ Blower( is_enabled=False, is_on=False, + on_seconds=None, ) # --- # name: TestBlower.test_from_dict_enabled_on Blower( is_enabled=True, is_on=True, + on_seconds=None, ) # --- # name: TestCleanCycle.test_from_dict @@ -28,19 +30,16 @@ # name: TestDiagnostics.test_from_dict Diagnostics( circulation_pump_flow_status='0', + daily_clean_cycle=0, + filter_1_minutes=60, + filter_2_minutes=30, heater_error='0', - heater_power='60', - heater_volts=0.0, - jet1_jet2_blower_power='14', - jet3_power='30', - jet3_volts=112.0, - l1_n_volts=0.0, - l2_n_volts=120.0, + jet3_volts=0, + l2_voltage_above_256v=False, limit_thermistor_status='0', power_frequency='0', pressure_switch_status='1', regulation_thermistor_temp_status='0', - small_loads_power='0', spa_failure_state=, ) # --- @@ -121,9 +120,7 @@ # name: TestHeater.test_from_dict Heater( current_temperature=100.0, - heater_current=7.5, heater_lock=False, - heater_on_seconds=52046, heating_mode=, heatpump_installed=False, is_on=True, @@ -135,28 +132,25 @@ dict({ 1: Jet( concurrent_mode=False, - current=0.0, is_enabled=True, jet_id=1, - on_seconds=1061668, + on_seconds=None, speed=, speed_type=, ), 2: Jet( concurrent_mode=False, - current=0.0, is_enabled=True, jet_id=2, - on_seconds=0, + on_seconds=None, speed=, speed_type=, ), 3: Jet( concurrent_mode=False, - current=0.0, is_enabled=False, jet_id=3, - on_seconds=0, + on_seconds=None, speed=, speed_type=, ), @@ -165,10 +159,9 @@ # name: TestJet.test_jet3_concurrent_and_current Jet( concurrent_mode=True, - current=3.6, is_enabled=True, jet_id=3, - on_seconds=2, + on_seconds=None, speed=, speed_type=, ) @@ -254,6 +247,7 @@ blower=Blower( is_enabled=False, is_on=False, + on_seconds=0, ), clean_cycle=CleanCycle( clean_timer_enabled=False, @@ -268,19 +262,16 @@ device_type=, diagnostics=Diagnostics( circulation_pump_flow_status='0', + daily_clean_cycle=None, + filter_1_minutes=None, + filter_2_minutes=None, heater_error='0', - heater_power='0', - heater_volts=0.0, - jet1_jet2_blower_power='0', - jet3_power='0', - jet3_volts=0.0, - l1_n_volts=0.0, - l2_n_volts=0.0, + jet3_volts=None, + l2_voltage_above_256v=None, limit_thermistor_status='0', power_frequency='0', pressure_switch_status='0', regulation_thermistor_temp_status='0', - small_loads_power='0', spa_failure_state=, ), energy_savings=dict({ @@ -313,9 +304,7 @@ ), heater=Heater( current_temperature=100.0, - heater_current=7.5, heater_lock=False, - heater_on_seconds=52046, heating_mode=, heatpump_installed=False, is_on=True, @@ -339,25 +328,22 @@ jets=dict({ 1: Jet( concurrent_mode=False, - current=0.0, is_enabled=True, jet_id=1, - on_seconds=1061668, + on_seconds=52046, speed=, speed_type=, ), 2: Jet( concurrent_mode=False, - current=0.0, is_enabled=True, jet_id=2, - on_seconds=0, + on_seconds=None, speed=, speed_type=, ), 3: Jet( concurrent_mode=False, - current=0.0, is_enabled=False, jet_id=3, on_seconds=0, @@ -422,15 +408,25 @@ logo_light=LogoLight( brightness=, ), + needs_diagnostics_for_power=True, + power=PowerMetrics( + heater_current=None, + heater_power=None, + jet1_jet2_blower_current=None, + jet1_jet2_blower_power=0, + jet3_current=0, + jet3_power=0, + small_loads_current=None, + small_loads_power=75, + supported=True, + ), spa_lock=SpaLock( is_locked=False, ), + system_uptime_hours=294.91, + system_uptime_seconds=1061668, test_metrics=SpaTestData( - heater_current=7.5, heater_test_status='off', - jet1_jet2_blower_current=0.0, - jet3_current=0.0, - small_loads_current=0.0, temp_offset=0.0, vsense_cal=0.0, ), @@ -482,11 +478,7 @@ # --- # name: TestSpaTestData.test_from_dict SpaTestData( - heater_current=7.5, heater_test_status='off', - jet1_jet2_blower_current=0.0, - jet3_current=0.0, - small_loads_current=0.0, temp_offset=0.0, vsense_cal=0.0, ) diff --git a/tests/test_hotspring.py b/tests/test_hotspring.py index bbd39a0..abaa6ef 100644 --- a/tests/test_hotspring.py +++ b/tests/test_hotspring.py @@ -71,6 +71,7 @@ def _add_update_mocks( # noqa: PLR0913 startup_fixture: str = "startup.json", connect_payload: str | None = None, spamodel_status: int = 200, + debug_status: int | None = 200, ) -> None: """Add mock responses for a full update() call.""" host = "192.168.1.100" @@ -100,6 +101,13 @@ def _add_update_mocks( # noqa: PLR0913 HTTPMethod.GET, _json_response("spamodel.json", status=spamodel_status), ) + if debug_status is not None and status_fixture == "status.json": + aresponses.add( + host, + Endpoint.DEBUG_DATA, + HTTPMethod.GET, + _json_response("debug_data.json", status=debug_status), + ) class TestUpdate: @@ -570,7 +578,7 @@ async def test_update_water_care_without_update( class TestUpdateDiagnostics: - """Tests for the update_diagnostics() method.""" + """Tests for update_diagnostics() and opportunistic /addDebugData polling.""" async def test_update_diagnostics( self, aresponses: ResponsesMockServer, snapshot: SnapshotAssertion @@ -590,6 +598,148 @@ async def test_update_diagnostics( assert diag == snapshot + @pytest.mark.parametrize( + ("heater_state", "heater_current", "expected_supported", "expected_total"), + [ + pytest.param("off", 19200, True, 75, id="heater_and_jet3_off"), + pytest.param("on", 0, False, None, id="power_unsupported"), + ], + ) + async def test_update_skips_debug_data_when_not_needed( + self, + aresponses: ResponsesMockServer, + heater_state: str, + heater_current: int, + expected_supported: bool, + expected_total: int | None, + ) -> None: + """Test update() skips /addDebugData when no active load needs it.""" + host = "192.168.1.100" + status = json.loads(_load("status.json")) + status["heater"]["status"]["heater"] = heater_state + status["heater"]["status"]["heaterCurrent"] = heater_current + status["test_data"]["status"]["heaterCurrent"] = heater_current + + async def fail_if_called(_: aiohttp.web.Request) -> Response: + pytest.fail("/addDebugData should not be requested") + + aresponses.add(host, Endpoint.STATUS, HTTPMethod.GET, _raw_json(status)) + aresponses.add( + host, Endpoint.STARTUP, HTTPMethod.GET, _json_response("startup.json") + ) + aresponses.add( + host, + Endpoint.SPA_CONNECT_STATUS, + HTTPMethod.GET, + _json_response("spa_connect_status.json"), + ) + aresponses.add( + host, Endpoint.SPA_MODEL, HTTPMethod.GET, _json_response("spamodel.json") + ) + aresponses.add(host, Endpoint.DEBUG_DATA, HTTPMethod.GET, fail_if_called) + + async with aiohttp.ClientSession() as session: + client = HotSpring(host=host, session=session) + spa = await client.update() + + assert spa.power.supported is expected_supported + assert spa.power.total_power == expected_total + + async def test_update_fetches_debug_data_when_jet3_on_and_heater_off( + self, aresponses: ResponsesMockServer + ) -> None: + """Test update() fetches /addDebugData when Jet 3 is running with heater off.""" + host = "192.168.1.100" + status = json.loads(_load("status.json")) + status["heater"]["status"]["heater"] = "off" + status["JET"]["JET3"]["config"]["JET3"] = "enable" + status["JET"]["JET3"]["status"]["speed"] = "highSpeed" + status["test_data"]["status"]["jet1+jet2+blowerCurrent"] = 2048 + + aresponses.add(host, Endpoint.STATUS, HTTPMethod.GET, _raw_json(status)) + aresponses.add( + host, Endpoint.STARTUP, HTTPMethod.GET, _json_response("startup.json") + ) + aresponses.add( + host, + Endpoint.SPA_CONNECT_STATUS, + HTTPMethod.GET, + _json_response("spa_connect_status.json"), + ) + aresponses.add( + host, Endpoint.SPA_MODEL, HTTPMethod.GET, _json_response("spamodel.json") + ) + aresponses.add( + host, + Endpoint.DEBUG_DATA, + HTTPMethod.GET, + _raw_json( + { + "debugData": { + "status": { + "spaFailureState": "Spa_Ok", + "jet1_jet2_blowerPower": "51200", + "smallLoadsPower": "7", + } + } + } + ), + ) + + async with aiohttp.ClientSession() as session: + client = HotSpring(host=host, session=session) + spa = await client.update() + + assert spa.power.jet3_current == 8 + assert spa.power.jet3_power == 1992 + assert spa.power.total_power == 2067 + + async def test_update_debug_data_failure_is_non_critical( + self, aresponses: ResponsesMockServer + ) -> None: + """Test /addDebugData HTTP error during update() does not fail update().""" + _add_update_mocks(aresponses, debug_status=500) + async with aiohttp.ClientSession() as session: + client = HotSpring(host="192.168.1.100", session=session) + spa = await client.update() + + assert spa.power.supported is True + assert spa.power.small_loads_power == 75 + assert spa.power.heater_power is None + + async def test_routine_poll_fetches_debug_data_when_heating( + self, aresponses: ResponsesMockServer + ) -> None: + """Test routine update() fetches /addDebugData to populate heater_power.""" + _add_update_mocks(aresponses, debug_status=500) + aresponses.add( + "192.168.1.100", + Endpoint.STATUS, + HTTPMethod.GET, + _json_response("status.json"), + ) + aresponses.add( + "192.168.1.100", + Endpoint.SPA_CONNECT_STATUS, + HTTPMethod.GET, + _json_response("spa_connect_status.json"), + ) + aresponses.add( + "192.168.1.100", + Endpoint.DEBUG_DATA, + HTTPMethod.GET, + _json_response("debug_data.json"), + ) + async with aiohttp.ClientSession() as session: + client = HotSpring(host="192.168.1.100", session=session) + spa = await client.update() + assert spa.power.heater_power is None + + spa = await client.update() + + assert spa.power.heater_power == 3584 + assert spa.power.total_power == 3659 + def _raw_json(payload: object) -> Response: """Create a JSON response from an inline payload.""" diff --git a/tests/test_models.py b/tests/test_models.py index e539512..5476c3a 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -30,6 +30,7 @@ Jet, LightZone, LogoLight, + PowerMetrics, Spa, SpaInfo, SpaLock, @@ -216,7 +217,7 @@ def test_jets_dict_keys(self) -> None: assert jets[3].jet_id == 3 def test_jet3_concurrent_and_current(self, snapshot: SnapshotAssertion) -> None: - """Test parsing Jet 3 concurrent mode and electrical current.""" + """Test parsing Jet 3 concurrent mode and single-speed configuration.""" jet = Jet.from_dict( 3, { @@ -226,20 +227,6 @@ def test_jet3_concurrent_and_current(self, snapshot: SnapshotAssertion) -> None: ) assert jet == snapshot - def test_jet_negative_runtime_overflow(self) -> None: - """Test graceful handling of negative signed integer overflow in runtime.""" - jet = Jet.from_dict( - 1, - { - "config": {"speed": "dualSpeed"}, - "status": {"speed": "off", "jet_1_ON_sec": -1568323328}, - }, - ) - assert jet.on_seconds == 10650953 - assert jet.on_hours == 2958.6 - assert jet.is_on is False - assert jet.speed_type == JetSpeedType.DUAL_SPEED - def test_jet_properties(self) -> None: """Test computed properties on Jet.""" dual_jet = Jet( @@ -247,7 +234,6 @@ def test_jet_properties(self) -> None: speed=JetSpeed.HIGH_SPEED, speed_type=JetSpeedType.DUAL_SPEED, is_enabled=True, - current=10.4, on_seconds=7200, ) assert dual_jet.is_available is True @@ -271,6 +257,7 @@ def test_jet_properties(self) -> None: assert single_jet.is_on is False assert single_jet.is_dual_speed is False assert single_jet.is_single_speed is True + assert single_jet.on_hours is None assert single_jet.supported_speeds == [JetSpeed.OFF, JetSpeed.HIGH_SPEED] disabled_jet = Jet( @@ -300,6 +287,11 @@ def test_from_dict_enabled_on(self, snapshot: SnapshotAssertion) -> None: ) assert blower == snapshot + def test_on_hours_property(self) -> None: + """Test blower on_hours returns None until runtime is populated.""" + assert Blower().on_hours is None + assert Blower(on_seconds=5400).on_hours == 1.5 + class TestLightZone: """Tests for LightZone model parsing.""" @@ -654,45 +646,75 @@ def test_from_dict( def test_from_empty_dict(self) -> None: """Test parsing diagnostics from empty dict uses defaults.""" - diag = Diagnostics.from_dict({}) - assert diag.spa_failure_state == SpaFailureState.UNKNOWN - assert diag.heater_power == "0" - - def test_from_invalid_dict(self) -> None: - """Test parsing diagnostics with invalid/null nested objects.""" - invalid_cases: list[dict[str, object]] = [ - {"debugData": None}, - {"debugData": "invalid"}, - {"debugData": {"status": None}}, - {"debugData": {"status": "invalid"}}, - {"debugData": {"status": {}}}, - ] - for invalid_data in invalid_cases: - diag = Diagnostics.from_dict(invalid_data) - assert diag.spa_failure_state == SpaFailureState.UNKNOWN - assert diag.heater_power == "0" + assert Diagnostics.from_dict({}) == Diagnostics() + + @pytest.mark.parametrize( + "invalid_data", + [ + pytest.param({"debugData": None}, id="null_debug_data"), + pytest.param({"debugData": "invalid"}, id="string_debug_data"), + pytest.param({"debugData": {"status": None}}, id="null_status"), + pytest.param({"debugData": {"status": "invalid"}}, id="string_status"), + pytest.param({"debugData": {"status": {}}}, id="empty_status"), + ], + ) + def test_from_invalid_dict(self, invalid_data: dict[str, object]) -> None: + """Test parsing diagnostics with invalid or empty nested objects.""" + assert Diagnostics.from_dict(invalid_data) == Diagnostics() + + def test_pre_sync_all_zero_normalizes_decoded_fields_to_none(self) -> None: + """Test real pre-sync /addDebugData (Spa_Ok with all zeros) returns defaults.""" + data: dict[str, object] = { + "debugData": { + "status": { + "spaFailureState": "Spa_Ok", + "heaterError": "0", + "powerFrequency": "0", + "pressureSwitchStatus": "0", + "circulationPumpFlowStatus": "0", + "regulationThermistorTempStatus": "0", + "limitThermistorStatus": "0", + "L1_N_Volts": "0", + "L2_N_Volts": "0", + "Heater_Volts": "0", + "jet3_Volts": "0", + "jet1_jet2_blowerPower": "0", + "smallLoadsPower": "0", + "heaterPower": "0", + "jet3Power": "0", + } + } + } + assert Diagnostics.from_dict(data) == Diagnostics() - def test_voltages_and_extended_keys(self) -> None: - """Test voltage computed properties and extended diagnostic keys.""" + def test_decoded_voltage_clean_cycle_and_filter_times(self) -> None: + """Test decoding shifted voltage, clean-cycle, and filter fields.""" data: dict[str, object] = { "debugData": { "status": { "spaFailureState": "Spa_Ok", "circulationPumpFlowStatus": "1", - "regulationThermistorTempStatus": "2", - "limitThermistorStatus": "3", - "L1_N_Volts": "3840", - "L2_N_Volts": "3584", - "jet3_Volts": "3840", + "regulationThermistorTempStatus": "1", + "limitThermistorStatus": "1", + "L1_N_Volts": "61441", + "L2_N_Volts": "1792", + "smallLoadsPower": "256", + "heaterPower": "90", + "jet3Power": "45", } } } - diag = Diagnostics.from_dict(data) - assert diag.circulation_pump_flow_status == "1" - assert diag.regulation_thermistor_temp_status == "2" - assert diag.limit_thermistor_status == "3" - assert diag.l1_n_volts == 120.0 - assert diag.l2_n_volts == 112.0 + assert Diagnostics.from_dict(data) == Diagnostics( + spa_failure_state=SpaFailureState.OK, + circulation_pump_flow_status="1", + regulation_thermistor_temp_status="1", + limit_thermistor_status="1", + l2_voltage_above_256v=True, + jet3_volts=240, + daily_clean_cycle=1, + filter_1_minutes=90, + filter_2_minutes=45, + ) class TestSpaTestData: @@ -707,8 +729,338 @@ def test_from_dict( def test_from_empty_dict(self) -> None: """Test parsing test data from empty dict uses defaults.""" - test_metrics = SpaTestData.from_dict({}) - assert test_metrics.small_loads_current == 0.0 + assert SpaTestData.from_dict({}) == SpaTestData() + + def test_calibration_fields_preserved_on_partial_update(self) -> None: + """Test partial SpaTestData update preserves existing calibration values.""" + existing = SpaTestData( + heater_test_status="on", temp_offset=0.5, vsense_cal=-1.2 + ) + updated = SpaTestData.from_dict( + {"status": {"heaterTestStatus": "off"}}, existing=existing + ) + assert updated == SpaTestData( + heater_test_status="off", temp_offset=0.5, vsense_cal=-1.2 + ) + + +def _power_status( + words: tuple[int, int, int, int] = (0, 0, 0, 0), + *, + heater: str = "off", + jet1: str = "off", + jet2: str = "off", + jet3: str | None = None, +) -> dict[str, object]: + """Build a minimal /status payload for power reconstruction tests.""" + j12b_cur, sl_cur, h_cur, j3_cur = words + jets: dict[str, object] = { + "JET1": {"status": {"speed": jet1}}, + "JET2": {"status": {"speed": jet2}}, + } + if jet3 is not None: + jets["JET3"] = {"config": {"JET3": "enable"}, "status": {"speed": jet3}} + return { + "heater": {"status": {"heater": heater}}, + "JET": jets, + "test_data": { + "status": { + "jet1+jet2+blowerCurrent": j12b_cur, + "smallLoadsCurrent": sl_cur, + "heaterCurrent": h_cur, + "jet3Current": j3_cur, + } + }, + } + + +def _power_debug( + *, + l2_raw: int = 0, + hv_raw: int = 0, + j3v_raw: int = 0, + j12p_raw: int = 0, + slp_raw: int = 0, +) -> dict[str, object]: + """Build a minimal synced /addDebugData payload for power reconstruction tests.""" + return { + "debugData": { + "status": { + "spaFailureState": "Spa_Ok", + "pressureSwitchStatus": "1", + "L2_N_Volts": str(l2_raw), + "Heater_Volts": str(hv_raw), + "jet3_Volts": str(j3v_raw), + "jet1_jet2_blowerPower": str(j12p_raw), + "smallLoadsPower": str(slp_raw), + } + } + } + + +class TestPowerMetrics: + """Tests for reconstructed PowerMetrics across /status and /addDebugData.""" + + def test_idle_power_from_status_alone(self) -> None: + """Test idle total_power is resolved from /status without /addDebugData.""" + spa = Spa(_power_status((0, 0, 16128, 0))) + assert spa.power == PowerMetrics( + supported=True, + small_loads_power=63, + jet1_jet2_blower_power=0, + heater_power=0, + jet3_power=0, + jet1_jet2_blower_current=0, + small_loads_current=None, + heater_current=0, + jet3_current=0, + ) + assert spa.power.total_power == 63 + + @pytest.mark.parametrize( + ("status_data", "debug_data", "expected", "expected_total"), + [ + pytest.param( + _power_status((0, 2048, 18434, 0), jet1="lowSpeed"), + _power_debug(l2_raw=256), + PowerMetrics( + supported=True, + small_loads_power=72, + jet1_jet2_blower_power=520, + heater_power=0, + jet3_power=0, + jet1_jet2_blower_current=1, + small_loads_current=0, + heater_current=0, + jet3_current=0, + ), + 592, + id="jet1_low", + ), + pytest.param( + _power_status((0, 6912, 18439, 0), jet1="highSpeed"), + _power_debug(l2_raw=1536), + PowerMetrics( + supported=True, + small_loads_power=72, + jet1_jet2_blower_power=1819, + heater_power=0, + jet3_power=0, + jet1_jet2_blower_current=6, + small_loads_current=0, + heater_current=0, + jet3_current=0, + ), + 1891, + id="jet1_high", + ), + pytest.param( + _power_status((0, 512, 15624, 0), jet2="highSpeed"), + _power_debug(l2_raw=1792), + PowerMetrics( + supported=True, + small_loads_power=61, + jet1_jet2_blower_power=2050, + heater_power=0, + jet3_power=0, + jet1_jet2_blower_current=7, + small_loads_current=0, + heater_current=0, + jet3_current=0, + ), + 2111, + id="jet2_high", + ), + pytest.param( + _power_status((0, 7680, 15631, 0), jet1="highSpeed", jet2="highSpeed"), + _power_debug(l2_raw=3584), + PowerMetrics( + supported=True, + small_loads_power=61, + jet1_jet2_blower_power=3870, + heater_power=0, + jet3_power=0, + jet1_jet2_blower_current=14, + small_loads_current=0, + heater_current=0, + jet3_current=0, + ), + 3931, + id="both_jets_high", + ), + pytest.param( + _power_status((0, 0, 16128, 30208), heater="on"), + _power_debug(j3v_raw=3840, j12p_raw=15), + PowerMetrics( + supported=True, + small_loads_power=63, + jet1_jet2_blower_power=0, + heater_power=3958, + jet3_power=0, + jet1_jet2_blower_current=0, + small_loads_current=0, + heater_current=15, + jet3_current=0, + ), + 4021, + id="heater_only", + ), + pytest.param( + _power_status((0, 3584, 18183, 16128), heater="on", jet1="highSpeed"), + _power_debug(l2_raw=1792, j3v_raw=3840, j12p_raw=15), + PowerMetrics( + supported=True, + small_loads_power=71, + jet1_jet2_blower_power=1806, + heater_power=3903, + jet3_power=0, + jet1_jet2_blower_current=7, + small_loads_current=0, + heater_current=15, + jet3_current=0, + ), + 5780, + id="heater_plus_jet1_high", + ), + pytest.param( + _power_status((2048, 0, 17920, 0), jet3="highSpeed"), + _power_debug(j12p_raw=51200, slp_raw=7), + PowerMetrics( + supported=True, + small_loads_power=70, + jet1_jet2_blower_power=0, + heater_power=0, + jet3_power=1992, + jet1_jet2_blower_current=0, + small_loads_current=0, + heater_current=0, + jet3_current=8, + ), + 2062, + id="jet3_active", + ), + ], + ) + def test_reconstructed_load_states( + self, + status_data: dict[str, object], + debug_data: dict[str, object], + expected: PowerMetrics, + expected_total: int, + ) -> None: + """Test byte-reconstructed power and current across real spa load states.""" + spa = Spa(status_data) + spa.update_diagnostics(debug_data) + assert spa.power == expected + assert spa.power.total_power == expected_total + + @pytest.mark.parametrize( + "status_data", + [ + pytest.param({}, id="empty"), + pytest.param(_power_status(heater="on"), id="non_ct_board"), + ], + ) + def test_unsupported_or_pre_sync_returns_empty_power_metrics( + self, status_data: dict[str, object] + ) -> None: + """Test boards without current sensors return unsupported PowerMetrics.""" + spa = Spa(status_data) + assert spa.power == PowerMetrics() + assert spa.power.total_power is None + assert spa.needs_diagnostics_for_power is False + + def test_heating_without_debug_data_keeps_heater_power_none(self) -> None: + """Test heater_power is None until /addDebugData arrives during heating.""" + spa = Spa(_power_status((0, 0, 16128, 30208), heater="on")) + assert spa.needs_diagnostics_for_power is True + assert spa.power.heater_power is None + assert spa.power.total_power is None + + def test_preserves_heater_power_without_byte_tearing_until_next_debug_poll( + self, + ) -> None: + """Test a new /status poll mid-heating does not tear stale high/low bytes.""" + spa = Spa(_power_status((0, 55552, 17929, 53248), heater="on", jet1="lowSpeed")) + spa.update_diagnostics(_power_debug(j3v_raw=3584, j12p_raw=14)) + assert spa.power.heater_power == 3792 + + # Next /status poll crosses 3840 W boundary (low byte 208 -> 20) + # before /addDebugData arrives; must keep 3792 instead of tearing to 3604. + spa.update_from_dict(_power_status((0, 0, 18944, 5120), heater="on")) + assert spa.power.heater_power == 3792 + + # Once the paired /addDebugData arrives with high byte 15, updates to 3860 W. + spa.update_diagnostics(_power_debug(j3v_raw=3840, j12p_raw=15)) + assert spa.power.heater_power == 3860 + assert spa.power.total_power == 3934 + + def test_heater_turning_off_immediately_zeroes_heater_power(self) -> None: + """Test heater turning off sets heater_power=0 without needing /addDebugData.""" + spa = Spa(_power_status((0, 0, 16128, 30208), heater="on")) + spa.update_diagnostics(_power_debug(j3v_raw=3840, j12p_raw=15)) + assert spa.power.heater_power == 3958 + + spa.update_from_dict({"heater": {"status": {"heater": "off"}}}) + assert spa.needs_diagnostics_for_power is False + assert spa.power.heater_power == 0 + assert spa.power.heater_current == 0 + assert spa.power.total_power == 63 + + def test_partial_jet_echo_updates_power_without_stale_debug_words(self) -> None: + """Test partial jet command echoes reset power/current without stale bytes.""" + spa = Spa(_power_status((0, 0, 16128, 30208), heater="on")) + spa.update_diagnostics(_power_debug(j3v_raw=3840, j12p_raw=15)) + assert spa.power.total_power == 4021 + + spa.update_from_dict({"JET": {"JET1": {"control": "highSpeed"}}}) + assert spa.power.jet1_jet2_blower_power is None + assert spa.power.jet1_jet2_blower_current is None + assert spa.power.total_power is None + + spa.update_from_dict({"JET": {"JET1": {"control": "off"}}}) + assert spa.power.jet1_jet2_blower_power == 0 + assert spa.power.jet1_jet2_blower_current == 0 + assert spa.power.total_power == 4021 + + def test_standalone_heater_current_echo_does_not_tear_pump_power(self) -> None: + """Test standalone heaterCurrent in partial payload does not tear pump power.""" + spa = Spa(_power_status((0, 6912, 18439, 0), jet1="highSpeed")) + assert spa.power.jet1_jet2_blower_power == 1819 + + spa.update_from_dict( + {"heater": {"status": {"heater": "off", "heaterCurrent": 16128}}} + ) + assert spa.power.small_loads_power == 72 + assert spa.power.jet1_jet2_blower_power == 1819 + + def test_unsynced_debug_data_preserves_existing_active_heater_power(self) -> None: + """Test empty/pre-sync /addDebugData while heating preserves heater_power.""" + spa = Spa(_power_status((0, 0, 16128, 30208), heater="on")) + spa.update_diagnostics(_power_debug(j3v_raw=3840, j12p_raw=15)) + assert spa.power.heater_power == 3958 + + spa.update_diagnostics({}) + assert spa.power.heater_power == 3958 + + def test_j12b_subload_change_invalidates_unpolled_metrics(self) -> None: + """Test changing pump speed/combination invalidates stale power and current.""" + spa = Spa( + _power_status((0, 7680, 15631, 0), jet1="highSpeed", jet2="highSpeed") + ) + spa.update_diagnostics(_power_debug(l2_raw=3584)) + assert spa.power.jet1_jet2_blower_power == 3870 + assert spa.power.jet1_jet2_blower_current == 14 + + # Partial command echo changing Jet 1 speed without test_data clears stale power + spa.update_from_dict({"JET": {"JET1": {"control": "lowSpeed"}}}) + assert spa.power.jet1_jet2_blower_power is None + assert spa.power.jet1_jet2_blower_current is None + + # Routine /status poll updates VA while clearing stale 14 A current + spa.update_from_dict(_power_status((0, 2048, 18434, 0), jet1="lowSpeed")) + assert spa.power.jet1_jet2_blower_power == 520 + assert spa.power.jet1_jet2_blower_current is None class TestSpaInfo: @@ -1105,6 +1457,8 @@ def test_update_from_dict_full_reparse( assert "test_metrics" in updated assert "energy_savings" in updated assert "versions" in updated + assert "power" in updated + assert "system_uptime_seconds" in updated def test_update_from_dict_non_dict_section( self, status_response: dict[str, object] @@ -1133,7 +1487,7 @@ def test_update_from_dict_multiple_sections( "blower": {"config": {"blower": "enable"}, "status": {"blower": "on"}}, } updated = spa.update_from_dict(payload) - assert updated == {"heater", "blower"} + assert updated == {"heater", "blower", "power"} assert spa.heater.is_on is False assert spa.blower.is_on is True @@ -1272,6 +1626,7 @@ def test_partial_update_single_jet( assert len(spa.jets) == 3 assert spa.jets[1].speed == JetSpeed.HIGH_SPEED initial_on_seconds = spa.jets[1].on_seconds + assert initial_on_seconds is not None assert initial_on_seconds > 0 # Simulate a command response updating JET1 to off @@ -1286,7 +1641,7 @@ def test_partial_update_single_jet( } } updated = spa.update_from_dict(partial_payload) - assert updated == {"jets"} + assert updated == {"jets", "power"} assert len(spa.jets) == 3 assert spa.jets[1].speed == JetSpeed.OFF @@ -1295,6 +1650,46 @@ def test_partial_update_single_jet( assert spa.jets[2].jet_id == 2 assert spa.jets[3].jet_id == 3 + def test_shifted_runtime_routing_and_signed_overflow(self) -> None: + """Test shifted runtime routing across sections and signed 32-bit overflow.""" + spa = Spa( + { + "heater": {"status": {"heater": "off", "heaterHours": 60475904}}, + "JET": { + "JET1": {"status": {"speed": "off", "jet_1_ON_sec": -1345838592}}, + "JET2": {"status": {"speed": "off", "jet_2_ON_sec": 921600}}, + "JET3": {"status": {"speed": "off", "jet_3_ON_sec": 460800}}, + }, + "blower": {"config": {"blower": "enable"}, "status": {"blower": "off"}}, + } + ) + assert spa.system_uptime_seconds == 11520034 + assert spa.system_uptime_hours == 3200.01 + assert spa.jets[1].on_seconds == 236234 + assert spa.jets[2].on_seconds is None + assert spa.jets[3].on_seconds == 3600 + assert spa.blower.on_seconds == 1800 + + def test_pre_sync_all_zero_runtimes_stay_none(self) -> None: + """Test pre-sync all-zero runtime counters remain None.""" + spa = Spa( + { + "heater": {"status": {"heater": "off", "heaterHours": 0}}, + "JET": { + "JET1": {"status": {"speed": "off", "jet_1_ON_sec": 0}}, + "JET2": {"status": {"speed": "off", "jet_2_ON_sec": 0}}, + "JET3": {"status": {"speed": "off", "jet_3_ON_sec": 0}}, + }, + "blower": {"status": {"blower": "disable"}}, + } + ) + assert spa.system_uptime_seconds is None + assert spa.system_uptime_hours is None + assert spa.jets[1].on_seconds is None + assert spa.jets[2].on_seconds is None + assert spa.jets[3].on_seconds is None + assert spa.blower.on_seconds is None + def test_partial_update_versions(self, status_response: dict[str, object]) -> None: """Test updating product versions partially retains cached fields.""" spa = Spa(status_response) From 849a4b5f414f9876e5159f39779bef43d027fe2a Mon Sep 17 00:00:00 2001 From: Moustachauve <2206577+Moustachauve@users.noreply.github.com> Date: Wed, 18 Nov 2026 14:38:58 -0500 Subject: [PATCH 2/6] Clarify electrical word naming and simplify power unit tests Short abbreviations for misaligned register words made the byte-reconstruction logic harder to read, and the new power and client tests duplicated assertions across multi-step scenarios and HTTP mocks. Use descriptive full-word names across models and test helpers, consolidate power and runtime cases into single-step parametrized snapshot tests, preserve cached diagnostics on empty debug polls, and skip opportunistic debug polling while the spa link is disconnected. --- src/hotspring/hotspring.py | 12 +- src/hotspring/models.py | 327 ++++++++++++--------- tests/__snapshots__/test_models.ambr | 240 ++++++++++++++++ tests/test_hotspring.py | 109 +++---- tests/test_models.py | 406 ++++++++++----------------- 5 files changed, 614 insertions(+), 480 deletions(-) diff --git a/src/hotspring/hotspring.py b/src/hotspring/hotspring.py index f834261..6c5a877 100644 --- a/src/hotspring/hotspring.py +++ b/src/hotspring/hotspring.py @@ -342,11 +342,15 @@ async def update(self, *, refresh_identity: bool = False) -> Spa: async def _refresh_power_diagnostics(self) -> None: """Fetch /addDebugData when active loads require it for power metrics.""" - if self.spa is not None and self.spa.needs_diagnostics_for_power: - debug_res = await self._safe_request(Endpoint.DEBUG_DATA) - if debug_res: + if ( + self.spa is not None + and self.spa.connection_status.spa_connected + and self.spa.needs_diagnostics_for_power + ): + debug_response = await self._safe_request(Endpoint.DEBUG_DATA) + if debug_response: with _parsing(Endpoint.DEBUG_DATA): - self.spa.update_diagnostics(debug_res) + self.spa.update_diagnostics(debug_response) async def get_device_info(self) -> SpaInfo: """Fetch lightweight device identity directly from /startup. diff --git a/src/hotspring/models.py b/src/hotspring/models.py index 40adb2b..4ddc9eb 100644 --- a/src/hotspring/models.py +++ b/src/hotspring/models.py @@ -100,8 +100,8 @@ def update_from_dict(self, data: dict[str, object]) -> set[str]: """ updated: set[str] = set() prior_active = self._active_circuit_flags - prev_power = self.power - prev_uptime = self.system_uptime_seconds + previous_power = self.power + previous_uptime = self.system_uptime_seconds for section in _SECTION_PARSERS: if section.json_key in data and isinstance(data[section.json_key], dict): @@ -152,7 +152,7 @@ def update_from_dict(self, data: dict[str, object]) -> set[str]: updated.add("versions") self._apply_shifted_runtimes(data, updated) - if self.system_uptime_seconds != prev_uptime: + if self.system_uptime_seconds != previous_uptime: updated.add("system_uptime_seconds") next_electrical = _extract_status_electrical(data) @@ -163,7 +163,7 @@ def update_from_dict(self, data: dict[str, object]) -> set[str]: prior_active=prior_active, status_fresh=next_electrical is not None, ) - if self.power != prev_power: + if self.power != previous_power: updated.add("power") return updated @@ -227,10 +227,12 @@ def update_diagnostics(self, data: dict[str, object]) -> None: data: The JSON response from GET /addDebugData. """ - self.diagnostics, debug_electrical = _parse_diagnostics_and_electrical(data) + self.diagnostics, debug_words = _parse_diagnostics_and_electrical( + data, existing=self.diagnostics + ) self._recompute_power( prior_active=self._active_circuit_flags, - debug_electrical=debug_electrical, + debug_words=debug_words, ) def update_freshwater_iq(self, data: dict[str, object]) -> None: @@ -265,39 +267,40 @@ def _apply_shifted_runtimes( tracks overall system uptime, ``jet_2_ON_sec`` tracks Jet 3 runtime, and ``jet_3_ON_sec`` tracks blower runtime. """ - raw_j1_on, raw_upt, raw_j3_on, raw_blower_on = _extract_raw_runtimes(data) - present_values = [ - v for v in (raw_j1_on, raw_upt, raw_j3_on, raw_blower_on) if v is not None - ] + runtimes = _extract_shifted_runtimes(data) + present_values = [value for value in runtimes if value is not None] if not present_values: return is_synced = ( bool(self.versions.control_box) or self.system_uptime_seconds is not None - or any(v != 0 for v in present_values) + or any(value != 0 for value in present_values) ) if not is_synced: return - if raw_upt is not None: - self.system_uptime_seconds = raw_upt + if runtimes.uptime_seconds is not None: + self.system_uptime_seconds = runtimes.uptime_seconds if ( - raw_j1_on is not None + runtimes.jet1_seconds is not None and 1 in self.jets - and self.jets[1].on_seconds != raw_j1_on + and self.jets[1].on_seconds != runtimes.jet1_seconds ): - self.jets[1] = replace(self.jets[1], on_seconds=raw_j1_on) + self.jets[1] = replace(self.jets[1], on_seconds=runtimes.jet1_seconds) updated.add("jets") if ( - raw_j3_on is not None + runtimes.jet3_seconds is not None and 3 in self.jets - and self.jets[3].on_seconds != raw_j3_on + and self.jets[3].on_seconds != runtimes.jet3_seconds ): - self.jets[3] = replace(self.jets[3], on_seconds=raw_j3_on) + self.jets[3] = replace(self.jets[3], on_seconds=runtimes.jet3_seconds) updated.add("jets") - if raw_blower_on is not None and self.blower.on_seconds != raw_blower_on: - self.blower = replace(self.blower, on_seconds=raw_blower_on) + if ( + runtimes.blower_seconds is not None + and self.blower.on_seconds != runtimes.blower_seconds + ): + self.blower = replace(self.blower, on_seconds=runtimes.blower_seconds) updated.add("blower") def _recompute_power( @@ -305,34 +308,43 @@ def _recompute_power( *, prior_active: tuple[bool, bool, tuple[JetSpeed, JetSpeed, bool]], status_fresh: bool = False, - debug_electrical: _DebugElectrical | None = None, + debug_words: _DebugElectrical | None = None, ) -> None: """Reconstruct PowerMetrics from /status and paired /addDebugData words.""" if self._status_electrical is None: self.power = PowerMetrics() return - se = self._status_electrical - small_loads_power = _reconstruct_u16(se.h_cur, se.j3_cur) + status_words = self._status_electrical + small_loads_power = _reconstruct_uint16( + status_words.heater_current_word, + status_words.jet3_current_word, + ) if small_loads_power <= 0: self.power = PowerMetrics() return - was_heating, was_jet3_on, prior_j12b_state = prior_active + was_heating, was_jet3_on, prior_pump_blower_state = prior_active jet3_is_on = self._is_jet3_on - j12b_state = self._j12b_state - j12b_is_on = j12b_state != (JetSpeed.OFF, JetSpeed.OFF, False) - same_j12b = j12b_is_on and j12b_state == prior_j12b_state - de = debug_electrical + pump_blower_state = self._pump_blower_state + pump_blower_is_on = pump_blower_state != (JetSpeed.OFF, JetSpeed.OFF, False) + pump_blower_unchanged = ( + pump_blower_is_on and pump_blower_state == prior_pump_blower_state + ) self.power = PowerMetrics( supported=True, small_loads_power=small_loads_power, jet1_jet2_blower_power=_resolve_gated_metric( - is_active=j12b_is_on, - was_active=same_j12b, + is_active=pump_blower_is_on, + was_active=pump_blower_unchanged, fresh_value=( - _reconstruct_u16(se.sl_cur, se.h_cur) if status_fresh else None + _reconstruct_uint16( + status_words.small_loads_current_word, + status_words.heater_current_word, + ) + if status_fresh + else None ), previous_value=self.power.jet1_jet2_blower_power, ), @@ -340,7 +352,12 @@ def _recompute_power( is_active=self.heater.is_on, was_active=was_heating, fresh_value=( - _reconstruct_u16(se.j3_cur, de.j12p_raw) if de is not None else None + _reconstruct_uint16( + status_words.jet3_current_word, + debug_words.jet1_jet2_blower_power_word, + ) + if debug_words is not None + else None ), previous_value=self.power.heater_power, ), @@ -348,31 +365,45 @@ def _recompute_power( is_active=jet3_is_on, was_active=was_jet3_on, fresh_value=( - _reconstruct_u16(de.j12p_raw, de.slp_raw) - if de is not None + _reconstruct_uint16( + debug_words.jet1_jet2_blower_power_word, + debug_words.small_loads_power_word, + ) + if debug_words is not None else None ), previous_value=self.power.jet3_power, ), jet1_jet2_blower_current=_resolve_gated_metric( - is_active=j12b_is_on, - was_active=same_j12b, + is_active=pump_blower_is_on, + was_active=pump_blower_unchanged, fresh_value=( - _reconstruct_u16(de.l2_raw, de.hv_raw) if de is not None else None + _reconstruct_uint16( + debug_words.l2_volts_word, + debug_words.heater_volts_word, + ) + if debug_words is not None + else None ), previous_value=self.power.jet1_jet2_blower_current, ), small_loads_current=( - _reconstruct_u16(de.hv_raw, de.j3v_raw) - if de is not None + _reconstruct_uint16( + debug_words.heater_volts_word, + debug_words.jet3_volts_word, + ) + if debug_words is not None else self.power.small_loads_current ), heater_current=_resolve_gated_metric( is_active=self.heater.is_on, was_active=was_heating, fresh_value=( - _reconstruct_u16(de.j3v_raw, se.j12b_cur) - if de is not None + _reconstruct_uint16( + debug_words.jet3_volts_word, + status_words.jet1_jet2_blower_current_word, + ) + if debug_words is not None else None ), previous_value=self.power.heater_current, @@ -381,7 +412,12 @@ def _recompute_power( is_active=jet3_is_on, was_active=was_jet3_on, fresh_value=( - _reconstruct_u16(se.j12b_cur, se.sl_cur) if status_fresh else None + _reconstruct_uint16( + status_words.jet1_jet2_blower_current_word, + status_words.small_loads_current_word, + ) + if status_fresh + else None ), previous_value=self.power.jet3_current, ), @@ -392,7 +428,7 @@ def _active_circuit_flags( self, ) -> tuple[bool, bool, tuple[JetSpeed, JetSpeed, bool]]: """Return active-state snapshot for (heater, jet3, jet1+jet2+blower).""" - return (self.heater.is_on, self._is_jet3_on, self._j12b_state) + return (self.heater.is_on, self._is_jet3_on, self._pump_blower_state) @property def _is_jet3_on(self) -> bool: @@ -400,7 +436,7 @@ def _is_jet3_on(self) -> bool: return bool((jet3 := self.jets.get(3)) and jet3.is_enabled and jet3.is_on) @property - def _j12b_state(self) -> tuple[JetSpeed, JetSpeed, bool]: + def _pump_blower_state(self) -> tuple[JetSpeed, JetSpeed, bool]: """Return normalized active state of (Jet 1, Jet 2, Blower).""" jet1 = self.jets.get(1) jet2 = self.jets.get(2) @@ -1366,20 +1402,23 @@ class Diagnostics: # pylint: disable=too-many-instance-attributes filter_2_minutes: int | None = None @staticmethod - def from_dict(data: dict[str, object]) -> Diagnostics: + def from_dict( + data: dict[str, object], existing: Diagnostics | None = None + ) -> Diagnostics: """Create a Diagnostics from API response data. Args: ---- data: The JSON response from GET /addDebugData, or an empty dict for default values. + existing: Optional existing Diagnostics instance to preserve cached fields. Returns: ------- A Diagnostics instance. """ - diagnostics, _ = _parse_diagnostics_and_electrical(data) + diagnostics, _ = _parse_diagnostics_and_electrical(data, existing=existing) return diagnostics @@ -1387,32 +1426,41 @@ def from_dict(data: dict[str, object]) -> Diagnostics: class _StatusElectrical: """Raw 16-bit electrical words carried in /status.""" - j12b_cur: int = 0 - sl_cur: int = 0 - h_cur: int = 0 - j3_cur: int = 0 + jet1_jet2_blower_current_word: int = 0 + small_loads_current_word: int = 0 + heater_current_word: int = 0 + jet3_current_word: int = 0 @dataclass(frozen=True) class _DebugElectrical: """Raw 16-bit electrical words carried in /addDebugData.""" - l2_raw: int = 0 - hv_raw: int = 0 - j3v_raw: int = 0 - j12p_raw: int = 0 - slp_raw: int = 0 + l2_volts_word: int = 0 + heater_volts_word: int = 0 + jet3_volts_word: int = 0 + jet1_jet2_blower_power_word: int = 0 + small_loads_power_word: int = 0 + + +class _ShiftedRuntimes(NamedTuple): + """Decoded 24-bit runtime counters extracted from /status.""" + jet1_seconds: int | None + uptime_seconds: int | None + jet3_seconds: int | None + blower_seconds: int | None -def _reconstruct_u16(low_word: int, high_word: int) -> int: + +def _reconstruct_uint16(low_byte_word: int, high_byte_word: int) -> int: """Reconstruct a 16-bit register split across two adjacent misaligned words. Live load testing shows an alignment bug in the HNA's JSON output where - adjacent 16-bit values are shifted by one byte: ``low_word`` holds the - register's low byte in bits 8..15, and ``high_word`` holds its high byte - in bits 0..7. + adjacent 16-bit values are shifted by one byte: ``low_byte_word`` holds the + register's low byte in bits 8..15, and ``high_byte_word`` holds its high + byte in bits 0..7. """ - return ((high_word & 0xFF) << 8) | ((low_word >> 8) & 0xFF) + return ((high_byte_word & 0xFF) << 8) | ((low_byte_word >> 8) & 0xFF) def _decode_runtime_seconds(raw: object) -> int: @@ -1422,8 +1470,8 @@ def _decode_runtime_seconds(raw: object) -> int: integers, wrapping negative past ~97.1 days. Masking with ``0xFFFFFFFF`` and shifting right by 8 recovers elapsed whole seconds. """ - raw_int: int = int(raw) - return (raw_int & 0xFFFFFFFF) >> 8 + raw_value: int = int(raw) + return (raw_value & 0xFFFFFFFF) >> 8 def _find_jet_status(jets_data: dict[str, object], jet_id: int) -> dict[str, object]: @@ -1442,39 +1490,42 @@ def _find_jet_status(jets_data: dict[str, object], jet_id: int) -> dict[str, obj return {} -def _extract_raw_runtimes( - data: dict[str, object], -) -> tuple[int | None, int | None, int | None, int | None]: +def _extract_shifted_runtimes(data: dict[str, object]) -> _ShiftedRuntimes: """Extract decoded runtime counters from /status sections when present.""" - raw_j1_on: int | None = None - raw_upt: int | None = None - raw_j3_on: int | None = None - raw_blower_on: int | None = None + jet1_seconds: int | None = None + uptime_seconds: int | None = None + jet3_seconds: int | None = None + blower_seconds: int | None = None heater = data.get("heater") if isinstance(heater, dict): - h_status = heater.get("status") - if isinstance(h_status, dict) and "heaterHours" in h_status: - raw_j1_on = _decode_runtime_seconds(h_status["heaterHours"]) + heater_status = heater.get("status") + if isinstance(heater_status, dict) and "heaterHours" in heater_status: + jet1_seconds = _decode_runtime_seconds(heater_status["heaterHours"]) jets = data.get("JET") if isinstance(jets, dict): - j1_status = _find_jet_status(jets, 1) - if "jet_1_ON_sec" in j1_status: - raw_upt = _decode_runtime_seconds(j1_status["jet_1_ON_sec"]) - - j2_status = _find_jet_status(jets, 2) - if "jet_2_ON_sec" in j2_status: - raw_j3_on = _decode_runtime_seconds(j2_status["jet_2_ON_sec"]) - - j3_status = _find_jet_status(jets, 3) - if "jet_3_ON_sec" in j3_status: - raw_blower_on = _decode_runtime_seconds(j3_status["jet_3_ON_sec"]) - - return raw_j1_on, raw_upt, raw_j3_on, raw_blower_on + jet1_status = _find_jet_status(jets, 1) + if "jet_1_ON_sec" in jet1_status: + uptime_seconds = _decode_runtime_seconds(jet1_status["jet_1_ON_sec"]) + + jet2_status = _find_jet_status(jets, 2) + if "jet_2_ON_sec" in jet2_status: + jet3_seconds = _decode_runtime_seconds(jet2_status["jet_2_ON_sec"]) + + jet3_status = _find_jet_status(jets, 3) + if "jet_3_ON_sec" in jet3_status: + blower_seconds = _decode_runtime_seconds(jet3_status["jet_3_ON_sec"]) + + return _ShiftedRuntimes( + jet1_seconds=jet1_seconds, + uptime_seconds=uptime_seconds, + jet3_seconds=jet3_seconds, + blower_seconds=blower_seconds, + ) -_TD_ELECTRICAL_KEYS: tuple[str, ...] = ( +_TEST_DATA_ELECTRICAL_KEYS: tuple[str, ...] = ( "jet1+jet2+blowerCurrent", "smallLoadsCurrent", "heaterCurrent", @@ -1492,34 +1543,34 @@ def _extract_status_electrical(data: dict[str, object]) -> _StatusElectrical | N """ heater = data.get("heater") if isinstance(heater, dict): - h_status = heater.get("status") - if isinstance(h_status, dict) and "heaterCurrent" in h_status: - int(h_status["heaterCurrent"]) + heater_status = heater.get("status") + if isinstance(heater_status, dict) and "heaterCurrent" in heater_status: + int(heater_status["heaterCurrent"]) jets = data.get("JET") if isinstance(jets, dict): - j3_status = _find_jet_status(jets, 3) - if "current" in j3_status: - int(j3_status["current"]) + jet3_status = _find_jet_status(jets, 3) + if "current" in jet3_status: + int(jet3_status["current"]) test_data = data.get("test_data") if not isinstance(test_data, dict): return None - td_status = test_data.get("status") - if not isinstance(td_status, dict) or not all( - key in td_status for key in _TD_ELECTRICAL_KEYS + test_data_status = test_data.get("status") + if not isinstance(test_data_status, dict) or not all( + key in test_data_status for key in _TEST_DATA_ELECTRICAL_KEYS ): return None return _StatusElectrical( - j12b_cur=int(td_status["jet1+jet2+blowerCurrent"]), - sl_cur=int(td_status["smallLoadsCurrent"]), - h_cur=int(td_status["heaterCurrent"]), - j3_cur=int(td_status["jet3Current"]), + jet1_jet2_blower_current_word=int(test_data_status["jet1+jet2+blowerCurrent"]), + small_loads_current_word=int(test_data_status["smallLoadsCurrent"]), + heater_current_word=int(test_data_status["heaterCurrent"]), + jet3_current_word=int(test_data_status["jet3Current"]), ) -_DEBUG_STR_KEYS: dict[str, str] = { +_DEBUG_STRING_KEYS: dict[str, str] = { "heaterError": "heater_error", "powerFrequency": "power_frequency", "pressureSwitchStatus": "pressure_switch_status", @@ -1528,7 +1579,7 @@ def _extract_status_electrical(data: dict[str, object]) -> _StatusElectrical | N "limitThermistorStatus": "limit_thermistor_status", } -_DEBUG_INT_KEYS: tuple[str, ...] = ( +_DEBUG_INTEGER_KEYS: tuple[str, ...] = ( "L1_N_Volts", "L2_N_Volts", "Heater_Volts", @@ -1557,43 +1608,49 @@ def _resolve_gated_metric( return None -def _decode_synced_diagnostics_fields(parsed_ints: dict[str, int]) -> dict[str, object]: +def _decode_synced_diagnostics_fields( + parsed_integers: dict[str, int], +) -> dict[str, object]: """Extract decoded voltage, clean-cycle, and filter fields from /addDebugData.""" decoded: dict[str, object] = {} - if "L1_N_Volts" in parsed_ints: - l1_raw = parsed_ints["L1_N_Volts"] - decoded["l2_voltage_above_256v"] = bool(l1_raw & 0xFF) - if "L2_N_Volts" in parsed_ints: - decoded["jet3_volts"] = _reconstruct_u16(l1_raw, parsed_ints["L2_N_Volts"]) - if "smallLoadsPower" in parsed_ints: - decoded["daily_clean_cycle"] = (parsed_ints["smallLoadsPower"] >> 8) & 0xFF - if "heaterPower" in parsed_ints: - decoded["filter_1_minutes"] = parsed_ints["heaterPower"] - if "jet3Power" in parsed_ints: - decoded["filter_2_minutes"] = parsed_ints["jet3Power"] + if "L1_N_Volts" in parsed_integers: + l1_volts_word = parsed_integers["L1_N_Volts"] + decoded["l2_voltage_above_256v"] = bool(l1_volts_word & 0xFF) + if "L2_N_Volts" in parsed_integers: + decoded["jet3_volts"] = _reconstruct_uint16( + l1_volts_word, + parsed_integers["L2_N_Volts"], + ) + if "smallLoadsPower" in parsed_integers: + decoded["daily_clean_cycle"] = (parsed_integers["smallLoadsPower"] >> 8) & 0xFF + if "heaterPower" in parsed_integers: + decoded["filter_1_minutes"] = parsed_integers["heaterPower"] + if "jet3Power" in parsed_integers: + decoded["filter_2_minutes"] = parsed_integers["jet3Power"] return decoded def _parse_diagnostics_and_electrical( - data: dict[str, object], + data: dict[str, object], existing: Diagnostics | None = None ) -> tuple[Diagnostics, _DebugElectrical | None]: """Parse /addDebugData into Diagnostics and raw electrical words.""" + base = existing or Diagnostics() debug_data = data.get("debugData") if not isinstance(debug_data, dict): - return Diagnostics(), None + return base, None debug = debug_data.get("status") if not isinstance(debug, dict) or not debug: - return Diagnostics(), None + return base, None - str_fields = { - attr: str(debug[json_key]) - for json_key, attr in _DEBUG_STR_KEYS.items() + string_fields = { + attribute_name: str(debug[json_key]) + for json_key, attribute_name in _DEBUG_STRING_KEYS.items() if json_key in debug } - parsed_ints = { + parsed_integers = { json_key: int(debug[json_key]) - for json_key in _DEBUG_INT_KEYS + for json_key in _DEBUG_INTEGER_KEYS if json_key in debug } @@ -1601,25 +1658,25 @@ def _parse_diagnostics_and_electrical( has_fault = raw_failure is not None and str(raw_failure) not in ("", "Spa_Ok") is_synced = ( has_fault - or any(v != "0" for v in str_fields.values()) - or any(v != 0 for v in parsed_ints.values()) + or any(value != "0" for value in string_fields.values()) + or any(value != 0 for value in parsed_integers.values()) ) if not is_synced: - return Diagnostics(), None + return base, None - kwargs: dict[str, object] = dict(str_fields) + kwargs: dict[str, object] = dict(string_fields) if "spaFailureState" in debug: kwargs["spa_failure_state"] = SpaFailureState.build(raw_failure) - kwargs.update(_decode_synced_diagnostics_fields(parsed_ints)) - - debug_elec = _DebugElectrical( - l2_raw=parsed_ints.get("L2_N_Volts", 0), - hv_raw=parsed_ints.get("Heater_Volts", 0), - j3v_raw=parsed_ints.get("jet3_Volts", 0), - j12p_raw=parsed_ints.get("jet1_jet2_blowerPower", 0), - slp_raw=parsed_ints.get("smallLoadsPower", 0), + kwargs.update(_decode_synced_diagnostics_fields(parsed_integers)) + + debug_words = _DebugElectrical( + l2_volts_word=parsed_integers.get("L2_N_Volts", 0), + heater_volts_word=parsed_integers.get("Heater_Volts", 0), + jet3_volts_word=parsed_integers.get("jet3_Volts", 0), + jet1_jet2_blower_power_word=parsed_integers.get("jet1_jet2_blowerPower", 0), + small_loads_power_word=parsed_integers.get("smallLoadsPower", 0), ) - return replace(Diagnostics(), **kwargs), debug_elec + return replace(base, **kwargs), debug_words class _SectionParser(NamedTuple): diff --git a/tests/__snapshots__/test_models.ambr b/tests/__snapshots__/test_models.ambr index 9b73341..dc3a13c 100644 --- a/tests/__snapshots__/test_models.ambr +++ b/tests/__snapshots__/test_models.ambr @@ -242,6 +242,246 @@ brightness=, ) # --- +# name: TestPowerMetrics.test_reconstructed_load_states[both_jets_high] + tuple( + PowerMetrics( + heater_current=0, + heater_power=0, + jet1_jet2_blower_current=14, + jet1_jet2_blower_power=3870, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=61, + supported=True, + ), + 3931, + ) +# --- +# name: TestPowerMetrics.test_reconstructed_load_states[heater_and_jet1_high] + tuple( + PowerMetrics( + heater_current=15, + heater_power=3903, + jet1_jet2_blower_current=7, + jet1_jet2_blower_power=1806, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=71, + supported=True, + ), + 5780, + ) +# --- +# name: TestPowerMetrics.test_reconstructed_load_states[heater_only] + tuple( + PowerMetrics( + heater_current=15, + heater_power=3958, + jet1_jet2_blower_current=0, + jet1_jet2_blower_power=0, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=63, + supported=True, + ), + 4021, + ) +# --- +# name: TestPowerMetrics.test_reconstructed_load_states[jet1_low] + tuple( + PowerMetrics( + heater_current=0, + heater_power=0, + jet1_jet2_blower_current=1, + jet1_jet2_blower_power=520, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=72, + supported=True, + ), + 592, + ) +# --- +# name: TestPowerMetrics.test_reconstructed_load_states[jet3_active] + tuple( + PowerMetrics( + heater_current=0, + heater_power=0, + jet1_jet2_blower_current=0, + jet1_jet2_blower_power=0, + jet3_current=8, + jet3_power=1992, + small_loads_current=0, + small_loads_power=70, + supported=True, + ), + 2062, + ) +# --- +# name: TestPowerMetrics.test_status_only_power_metrics[empty] + tuple( + PowerMetrics( + heater_current=None, + heater_power=None, + jet1_jet2_blower_current=None, + jet1_jet2_blower_power=None, + jet3_current=None, + jet3_power=None, + small_loads_current=None, + small_loads_power=None, + supported=False, + ), + None, + ) +# --- +# name: TestPowerMetrics.test_status_only_power_metrics[heating_awaiting_debug] + tuple( + PowerMetrics( + heater_current=None, + heater_power=None, + jet1_jet2_blower_current=0, + jet1_jet2_blower_power=0, + jet3_current=0, + jet3_power=0, + small_loads_current=None, + small_loads_power=63, + supported=True, + ), + None, + ) +# --- +# name: TestPowerMetrics.test_status_only_power_metrics[idle_supported] + tuple( + PowerMetrics( + heater_current=0, + heater_power=0, + jet1_jet2_blower_current=0, + jet1_jet2_blower_power=0, + jet3_current=0, + jet3_power=0, + small_loads_current=None, + small_loads_power=63, + supported=True, + ), + 63, + ) +# --- +# name: TestPowerMetrics.test_status_only_power_metrics[jet3_awaiting_debug] + tuple( + PowerMetrics( + heater_current=0, + heater_power=0, + jet1_jet2_blower_current=0, + jet1_jet2_blower_power=0, + jet3_current=8, + jet3_power=None, + small_loads_current=None, + small_loads_power=70, + supported=True, + ), + None, + ) +# --- +# name: TestPowerMetrics.test_status_only_power_metrics[unsupported_board] + tuple( + PowerMetrics( + heater_current=None, + heater_power=None, + jet1_jet2_blower_current=None, + jet1_jet2_blower_power=None, + jet3_current=None, + jet3_power=None, + small_loads_current=None, + small_loads_power=None, + supported=False, + ), + None, + ) +# --- +# name: TestPowerMetrics.test_status_transitions_on_active_spa[all_jets_off_echo_zeroes_pumps] + tuple( + PowerMetrics( + heater_current=14, + heater_power=3792, + jet1_jet2_blower_current=0, + jet1_jet2_blower_power=0, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=70, + supported=True, + ), + 3862, + ) +# --- +# name: TestPowerMetrics.test_status_transitions_on_active_spa[heater_off_echo_zeroes_heater] + tuple( + PowerMetrics( + heater_current=0, + heater_power=0, + jet1_jet2_blower_current=14, + jet1_jet2_blower_power=3870, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=70, + supported=True, + ), + 3940, + ) +# --- +# name: TestPowerMetrics.test_status_transitions_on_active_spa[jet_speed_change_echo_invalidates_pumps] + tuple( + PowerMetrics( + heater_current=14, + heater_power=3792, + jet1_jet2_blower_current=None, + jet1_jet2_blower_power=None, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=70, + supported=True, + ), + None, + ) +# --- +# name: TestPowerMetrics.test_status_transitions_on_active_spa[standalone_heater_current_ignored] + tuple( + PowerMetrics( + heater_current=14, + heater_power=3792, + jet1_jet2_blower_current=14, + jet1_jet2_blower_power=3870, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=70, + supported=True, + ), + 7732, + ) +# --- +# name: TestPowerMetrics.test_status_transitions_on_active_spa[unpaired_status_poll_preserves_heater_without_tearing] + tuple( + PowerMetrics( + heater_current=14, + heater_power=3792, + jet1_jet2_blower_current=None, + jet1_jet2_blower_power=8, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=74, + supported=True, + ), + 3874, + ) +# --- # name: TestSpa.test_full_status_parsing Spa( blower=Blower( diff --git a/tests/test_hotspring.py b/tests/test_hotspring.py index abaa6ef..5681c5d 100644 --- a/tests/test_hotspring.py +++ b/tests/test_hotspring.py @@ -67,6 +67,7 @@ def _add_update_mocks( # noqa: PLR0913 aresponses: ResponsesMockServer, *, status_fixture: str = "status.json", + status_payload: dict[str, object] | None = None, startup_status: int = 200, startup_fixture: str = "startup.json", connect_payload: str | None = None, @@ -75,9 +76,12 @@ def _add_update_mocks( # noqa: PLR0913 ) -> None: """Add mock responses for a full update() call.""" host = "192.168.1.100" - aresponses.add( - host, Endpoint.STATUS, HTTPMethod.GET, _json_response(status_fixture) + status_response = ( + _raw_json(status_payload) + if status_payload is not None + else _json_response(status_fixture) ) + aresponses.add(host, Endpoint.STATUS, HTTPMethod.GET, status_response) aresponses.add( host, Endpoint.STARTUP, @@ -101,7 +105,9 @@ def _add_update_mocks( # noqa: PLR0913 HTTPMethod.GET, _json_response("spamodel.json", status=spamodel_status), ) - if debug_status is not None and status_fixture == "status.json": + if debug_status is not None and ( + status_payload is not None or status_fixture == "status.json" + ): aresponses.add( host, Endpoint.DEBUG_DATA, @@ -599,22 +605,27 @@ async def test_update_diagnostics( assert diag == snapshot @pytest.mark.parametrize( - ("heater_state", "heater_current", "expected_supported", "expected_total"), + ("scenario", "expected_supported", "expected_total"), [ - pytest.param("off", 19200, True, 75, id="heater_and_jet3_off"), - pytest.param("on", 0, False, None, id="power_unsupported"), + pytest.param(("off", 19200, None), True, 75, id="heater_and_jet3_off"), + pytest.param(("on", 0, None), False, None, id="power_unsupported"), + pytest.param( + ("on", 19200, '{"spaConnectStatus": "false"}'), + True, + None, + id="spa_disconnected", + ), ], ) async def test_update_skips_debug_data_when_not_needed( self, aresponses: ResponsesMockServer, - heater_state: str, - heater_current: int, + scenario: tuple[str, int, str | None], expected_supported: bool, expected_total: int | None, ) -> None: - """Test update() skips /addDebugData when no active load needs it.""" - host = "192.168.1.100" + """Test update() skips /addDebugData when disconnected or not needed.""" + heater_state, heater_current, connect_payload = scenario status = json.loads(_load("status.json")) status["heater"]["status"]["heater"] = heater_state status["heater"]["status"]["heaterCurrent"] = heater_current @@ -623,77 +634,23 @@ async def test_update_skips_debug_data_when_not_needed( async def fail_if_called(_: aiohttp.web.Request) -> Response: pytest.fail("/addDebugData should not be requested") - aresponses.add(host, Endpoint.STATUS, HTTPMethod.GET, _raw_json(status)) - aresponses.add( - host, Endpoint.STARTUP, HTTPMethod.GET, _json_response("startup.json") + _add_update_mocks( + aresponses, + status_payload=status, + connect_payload=connect_payload, + debug_status=None, ) aresponses.add( - host, - Endpoint.SPA_CONNECT_STATUS, - HTTPMethod.GET, - _json_response("spa_connect_status.json"), + "192.168.1.100", Endpoint.DEBUG_DATA, HTTPMethod.GET, fail_if_called ) - aresponses.add( - host, Endpoint.SPA_MODEL, HTTPMethod.GET, _json_response("spamodel.json") - ) - aresponses.add(host, Endpoint.DEBUG_DATA, HTTPMethod.GET, fail_if_called) async with aiohttp.ClientSession() as session: - client = HotSpring(host=host, session=session) + client = HotSpring(host="192.168.1.100", session=session) spa = await client.update() assert spa.power.supported is expected_supported assert spa.power.total_power == expected_total - async def test_update_fetches_debug_data_when_jet3_on_and_heater_off( - self, aresponses: ResponsesMockServer - ) -> None: - """Test update() fetches /addDebugData when Jet 3 is running with heater off.""" - host = "192.168.1.100" - status = json.loads(_load("status.json")) - status["heater"]["status"]["heater"] = "off" - status["JET"]["JET3"]["config"]["JET3"] = "enable" - status["JET"]["JET3"]["status"]["speed"] = "highSpeed" - status["test_data"]["status"]["jet1+jet2+blowerCurrent"] = 2048 - - aresponses.add(host, Endpoint.STATUS, HTTPMethod.GET, _raw_json(status)) - aresponses.add( - host, Endpoint.STARTUP, HTTPMethod.GET, _json_response("startup.json") - ) - aresponses.add( - host, - Endpoint.SPA_CONNECT_STATUS, - HTTPMethod.GET, - _json_response("spa_connect_status.json"), - ) - aresponses.add( - host, Endpoint.SPA_MODEL, HTTPMethod.GET, _json_response("spamodel.json") - ) - aresponses.add( - host, - Endpoint.DEBUG_DATA, - HTTPMethod.GET, - _raw_json( - { - "debugData": { - "status": { - "spaFailureState": "Spa_Ok", - "jet1_jet2_blowerPower": "51200", - "smallLoadsPower": "7", - } - } - } - ), - ) - - async with aiohttp.ClientSession() as session: - client = HotSpring(host=host, session=session) - spa = await client.update() - - assert spa.power.jet3_current == 8 - assert spa.power.jet3_power == 1992 - assert spa.power.total_power == 2067 - async def test_update_debug_data_failure_is_non_critical( self, aresponses: ResponsesMockServer ) -> None: @@ -710,8 +667,10 @@ async def test_update_debug_data_failure_is_non_critical( async def test_routine_poll_fetches_debug_data_when_heating( self, aresponses: ResponsesMockServer ) -> None: - """Test routine update() fetches /addDebugData to populate heater_power.""" - _add_update_mocks(aresponses, debug_status=500) + """Test routine update() fetches /addDebugData once heating turns on.""" + idle_status = json.loads(_load("status.json")) + idle_status["heater"]["status"]["heater"] = "off" + _add_update_mocks(aresponses, status_payload=idle_status, debug_status=None) aresponses.add( "192.168.1.100", Endpoint.STATUS, @@ -732,9 +691,7 @@ async def test_routine_poll_fetches_debug_data_when_heating( ) async with aiohttp.ClientSession() as session: client = HotSpring(host="192.168.1.100", session=session) - spa = await client.update() - assert spa.power.heater_power is None - + await client.update() spa = await client.update() assert spa.power.heater_power == 3584 diff --git a/tests/test_models.py b/tests/test_models.py index 5476c3a..ed21d99 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -30,7 +30,6 @@ Jet, LightZone, LogoLight, - PowerMetrics, Spa, SpaInfo, SpaLock, @@ -745,7 +744,7 @@ def test_calibration_fields_preserved_on_partial_update(self) -> None: def _power_status( - words: tuple[int, int, int, int] = (0, 0, 0, 0), + electrical_words: tuple[int, int, int, int] = (0, 0, 0, 0), *, heater: str = "off", jet1: str = "off", @@ -753,7 +752,12 @@ def _power_status( jet3: str | None = None, ) -> dict[str, object]: """Build a minimal /status payload for power reconstruction tests.""" - j12b_cur, sl_cur, h_cur, j3_cur = words + ( + jet1_jet2_blower_current_word, + small_loads_current_word, + heater_current_word, + jet3_current_word, + ) = electrical_words jets: dict[str, object] = { "JET1": {"status": {"speed": jet1}}, "JET2": {"status": {"speed": jet2}}, @@ -765,10 +769,10 @@ def _power_status( "JET": jets, "test_data": { "status": { - "jet1+jet2+blowerCurrent": j12b_cur, - "smallLoadsCurrent": sl_cur, - "heaterCurrent": h_cur, - "jet3Current": j3_cur, + "jet1+jet2+blowerCurrent": jet1_jet2_blower_current_word, + "smallLoadsCurrent": small_loads_current_word, + "heaterCurrent": heater_current_word, + "jet3Current": jet3_current_word, } }, } @@ -776,11 +780,11 @@ def _power_status( def _power_debug( *, - l2_raw: int = 0, - hv_raw: int = 0, - j3v_raw: int = 0, - j12p_raw: int = 0, - slp_raw: int = 0, + l2_volts: int = 0, + heater_volts: int = 0, + jet3_volts: int = 0, + jet1_jet2_blower_power: int = 0, + small_loads_power: int = 0, ) -> dict[str, object]: """Build a minimal synced /addDebugData payload for power reconstruction tests.""" return { @@ -788,11 +792,11 @@ def _power_debug( "status": { "spaFailureState": "Spa_Ok", "pressureSwitchStatus": "1", - "L2_N_Volts": str(l2_raw), - "Heater_Volts": str(hv_raw), - "jet3_Volts": str(j3v_raw), - "jet1_jet2_blowerPower": str(j12p_raw), - "smallLoadsPower": str(slp_raw), + "L2_N_Volts": str(l2_volts), + "Heater_Volts": str(heater_volts), + "jet3_Volts": str(jet3_volts), + "jet1_jet2_blowerPower": str(jet1_jet2_blower_power), + "smallLoadsPower": str(small_loads_power), } } } @@ -801,142 +805,61 @@ def _power_debug( class TestPowerMetrics: """Tests for reconstructed PowerMetrics across /status and /addDebugData.""" - def test_idle_power_from_status_alone(self) -> None: - """Test idle total_power is resolved from /status without /addDebugData.""" - spa = Spa(_power_status((0, 0, 16128, 0))) - assert spa.power == PowerMetrics( - supported=True, - small_loads_power=63, - jet1_jet2_blower_power=0, - heater_power=0, - jet3_power=0, - jet1_jet2_blower_current=0, - small_loads_current=None, - heater_current=0, - jet3_current=0, - ) - assert spa.power.total_power == 63 - @pytest.mark.parametrize( - ("status_data", "debug_data", "expected", "expected_total"), + ("status_data", "expected_needs_diagnostics"), [ + pytest.param({}, False, id="empty"), + pytest.param(_power_status(heater="on"), False, id="unsupported_board"), + pytest.param(_power_status((0, 0, 16128, 0)), False, id="idle_supported"), pytest.param( - _power_status((0, 2048, 18434, 0), jet1="lowSpeed"), - _power_debug(l2_raw=256), - PowerMetrics( - supported=True, - small_loads_power=72, - jet1_jet2_blower_power=520, - heater_power=0, - jet3_power=0, - jet1_jet2_blower_current=1, - small_loads_current=0, - heater_current=0, - jet3_current=0, - ), - 592, - id="jet1_low", + _power_status((0, 0, 16128, 30208), heater="on"), + True, + id="heating_awaiting_debug", ), pytest.param( - _power_status((0, 6912, 18439, 0), jet1="highSpeed"), - _power_debug(l2_raw=1536), - PowerMetrics( - supported=True, - small_loads_power=72, - jet1_jet2_blower_power=1819, - heater_power=0, - jet3_power=0, - jet1_jet2_blower_current=6, - small_loads_current=0, - heater_current=0, - jet3_current=0, - ), - 1891, - id="jet1_high", + _power_status((2048, 0, 17920, 0), jet3="highSpeed"), + True, + id="jet3_awaiting_debug", ), + ], + ) + def test_status_only_power_metrics( + self, + status_data: dict[str, object], + expected_needs_diagnostics: bool, + snapshot: SnapshotAssertion, + ) -> None: + """Test power state derived from /status alone before /addDebugData.""" + spa = Spa(status_data) + assert spa.needs_diagnostics_for_power is expected_needs_diagnostics + assert (spa.power, spa.power.total_power) == snapshot + + @pytest.mark.parametrize( + ("status_data", "debug_data"), + [ pytest.param( - _power_status((0, 512, 15624, 0), jet2="highSpeed"), - _power_debug(l2_raw=1792), - PowerMetrics( - supported=True, - small_loads_power=61, - jet1_jet2_blower_power=2050, - heater_power=0, - jet3_power=0, - jet1_jet2_blower_current=7, - small_loads_current=0, - heater_current=0, - jet3_current=0, - ), - 2111, - id="jet2_high", + _power_status((0, 2048, 18434, 0), jet1="lowSpeed"), + _power_debug(l2_volts=256), + id="jet1_low", ), pytest.param( _power_status((0, 7680, 15631, 0), jet1="highSpeed", jet2="highSpeed"), - _power_debug(l2_raw=3584), - PowerMetrics( - supported=True, - small_loads_power=61, - jet1_jet2_blower_power=3870, - heater_power=0, - jet3_power=0, - jet1_jet2_blower_current=14, - small_loads_current=0, - heater_current=0, - jet3_current=0, - ), - 3931, + _power_debug(l2_volts=3584), id="both_jets_high", ), pytest.param( _power_status((0, 0, 16128, 30208), heater="on"), - _power_debug(j3v_raw=3840, j12p_raw=15), - PowerMetrics( - supported=True, - small_loads_power=63, - jet1_jet2_blower_power=0, - heater_power=3958, - jet3_power=0, - jet1_jet2_blower_current=0, - small_loads_current=0, - heater_current=15, - jet3_current=0, - ), - 4021, + _power_debug(jet3_volts=3840, jet1_jet2_blower_power=15), id="heater_only", ), pytest.param( _power_status((0, 3584, 18183, 16128), heater="on", jet1="highSpeed"), - _power_debug(l2_raw=1792, j3v_raw=3840, j12p_raw=15), - PowerMetrics( - supported=True, - small_loads_power=71, - jet1_jet2_blower_power=1806, - heater_power=3903, - jet3_power=0, - jet1_jet2_blower_current=7, - small_loads_current=0, - heater_current=15, - jet3_current=0, - ), - 5780, - id="heater_plus_jet1_high", + _power_debug(l2_volts=1792, jet3_volts=3840, jet1_jet2_blower_power=15), + id="heater_and_jet1_high", ), pytest.param( _power_status((2048, 0, 17920, 0), jet3="highSpeed"), - _power_debug(j12p_raw=51200, slp_raw=7), - PowerMetrics( - supported=True, - small_loads_power=70, - jet1_jet2_blower_power=0, - heater_power=0, - jet3_power=1992, - jet1_jet2_blower_current=0, - small_loads_current=0, - heater_current=0, - jet3_current=8, - ), - 2062, + _power_debug(jet1_jet2_blower_power=51200, small_loads_power=7), id="jet3_active", ), ], @@ -945,122 +868,66 @@ def test_reconstructed_load_states( self, status_data: dict[str, object], debug_data: dict[str, object], - expected: PowerMetrics, - expected_total: int, + snapshot: SnapshotAssertion, ) -> None: - """Test byte-reconstructed power and current across real spa load states.""" + """Test byte-reconstructed power and current across active spa circuits.""" spa = Spa(status_data) spa.update_diagnostics(debug_data) - assert spa.power == expected - assert spa.power.total_power == expected_total + assert (spa.power, spa.power.total_power) == snapshot @pytest.mark.parametrize( - "status_data", + "status_update", [ - pytest.param({}, id="empty"), - pytest.param(_power_status(heater="on"), id="non_ct_board"), + pytest.param( + {"heater": {"status": {"heater": "off"}}}, + id="heater_off_echo_zeroes_heater", + ), + pytest.param( + {"JET": {"JET1": {"control": "lowSpeed"}}}, + id="jet_speed_change_echo_invalidates_pumps", + ), + pytest.param( + {"JET": {"JET1": {"control": "off"}, "JET2": {"control": "off"}}}, + id="all_jets_off_echo_zeroes_pumps", + ), + pytest.param( + _power_status((0, 2048, 18944, 5120), heater="on", jet1="lowSpeed"), + id="unpaired_status_poll_preserves_heater_without_tearing", + ), + pytest.param( + {"heater": {"status": {"heater": "on", "heaterCurrent": 16128}}}, + id="standalone_heater_current_ignored", + ), ], ) - def test_unsupported_or_pre_sync_returns_empty_power_metrics( - self, status_data: dict[str, object] - ) -> None: - """Test boards without current sensors return unsupported PowerMetrics.""" - spa = Spa(status_data) - assert spa.power == PowerMetrics() - assert spa.power.total_power is None - assert spa.needs_diagnostics_for_power is False - - def test_heating_without_debug_data_keeps_heater_power_none(self) -> None: - """Test heater_power is None until /addDebugData arrives during heating.""" - spa = Spa(_power_status((0, 0, 16128, 30208), heater="on")) - assert spa.needs_diagnostics_for_power is True - assert spa.power.heater_power is None - assert spa.power.total_power is None - - def test_preserves_heater_power_without_byte_tearing_until_next_debug_poll( + def test_status_transitions_on_active_spa( self, + status_update: dict[str, object], + snapshot: SnapshotAssertion, ) -> None: - """Test a new /status poll mid-heating does not tear stale high/low bytes.""" - spa = Spa(_power_status((0, 55552, 17929, 53248), heater="on", jet1="lowSpeed")) - spa.update_diagnostics(_power_debug(j3v_raw=3584, j12p_raw=14)) - assert spa.power.heater_power == 3792 - - # Next /status poll crosses 3840 W boundary (low byte 208 -> 20) - # before /addDebugData arrives; must keep 3792 instead of tearing to 3604. - spa.update_from_dict(_power_status((0, 0, 18944, 5120), heater="on")) - assert spa.power.heater_power == 3792 - - # Once the paired /addDebugData arrives with high byte 15, updates to 3860 W. - spa.update_diagnostics(_power_debug(j3v_raw=3840, j12p_raw=15)) - assert spa.power.heater_power == 3860 - assert spa.power.total_power == 3934 - - def test_heater_turning_off_immediately_zeroes_heater_power(self) -> None: - """Test heater turning off sets heater_power=0 without needing /addDebugData.""" - spa = Spa(_power_status((0, 0, 16128, 30208), heater="on")) - spa.update_diagnostics(_power_debug(j3v_raw=3840, j12p_raw=15)) - assert spa.power.heater_power == 3958 - - spa.update_from_dict({"heater": {"status": {"heater": "off"}}}) - assert spa.needs_diagnostics_for_power is False - assert spa.power.heater_power == 0 - assert spa.power.heater_current == 0 - assert spa.power.total_power == 63 - - def test_partial_jet_echo_updates_power_without_stale_debug_words(self) -> None: - """Test partial jet command echoes reset power/current without stale bytes.""" - spa = Spa(_power_status((0, 0, 16128, 30208), heater="on")) - spa.update_diagnostics(_power_debug(j3v_raw=3840, j12p_raw=15)) - assert spa.power.total_power == 4021 - - spa.update_from_dict({"JET": {"JET1": {"control": "highSpeed"}}}) - assert spa.power.jet1_jet2_blower_power is None - assert spa.power.jet1_jet2_blower_current is None - assert spa.power.total_power is None - - spa.update_from_dict({"JET": {"JET1": {"control": "off"}}}) - assert spa.power.jet1_jet2_blower_power == 0 - assert spa.power.jet1_jet2_blower_current == 0 - assert spa.power.total_power == 4021 - - def test_standalone_heater_current_echo_does_not_tear_pump_power(self) -> None: - """Test standalone heaterCurrent in partial payload does not tear pump power.""" - spa = Spa(_power_status((0, 6912, 18439, 0), jet1="highSpeed")) - assert spa.power.jet1_jet2_blower_power == 1819 - - spa.update_from_dict( - {"heater": {"status": {"heater": "off", "heaterCurrent": 16128}}} + """Test follow-up status and command-echo updates on an active spa.""" + spa = Spa( + _power_status( + (0, 7680, 17935, 53248), + heater="on", + jet1="highSpeed", + jet2="highSpeed", + ) ) - assert spa.power.small_loads_power == 72 - assert spa.power.jet1_jet2_blower_power == 1819 + spa.update_diagnostics( + _power_debug(l2_volts=3584, jet3_volts=3584, jet1_jet2_blower_power=14) + ) + spa.update_from_dict(status_update) + assert (spa.power, spa.power.total_power) == snapshot - def test_unsynced_debug_data_preserves_existing_active_heater_power(self) -> None: - """Test empty/pre-sync /addDebugData while heating preserves heater_power.""" + def test_unsynced_debug_data_preserves_active_power_and_diagnostics(self) -> None: + """Test empty /addDebugData keeps cached active power and diagnostics.""" spa = Spa(_power_status((0, 0, 16128, 30208), heater="on")) - spa.update_diagnostics(_power_debug(j3v_raw=3840, j12p_raw=15)) - assert spa.power.heater_power == 3958 + spa.update_diagnostics(_power_debug(jet3_volts=3840, jet1_jet2_blower_power=15)) + expected = (spa.power, spa.diagnostics) spa.update_diagnostics({}) - assert spa.power.heater_power == 3958 - - def test_j12b_subload_change_invalidates_unpolled_metrics(self) -> None: - """Test changing pump speed/combination invalidates stale power and current.""" - spa = Spa( - _power_status((0, 7680, 15631, 0), jet1="highSpeed", jet2="highSpeed") - ) - spa.update_diagnostics(_power_debug(l2_raw=3584)) - assert spa.power.jet1_jet2_blower_power == 3870 - assert spa.power.jet1_jet2_blower_current == 14 - - # Partial command echo changing Jet 1 speed without test_data clears stale power - spa.update_from_dict({"JET": {"JET1": {"control": "lowSpeed"}}}) - assert spa.power.jet1_jet2_blower_power is None - assert spa.power.jet1_jet2_blower_current is None - - # Routine /status poll updates VA while clearing stale 14 A current - spa.update_from_dict(_power_status((0, 2048, 18434, 0), jet1="lowSpeed")) - assert spa.power.jet1_jet2_blower_power == 520 - assert spa.power.jet1_jet2_blower_current is None + assert (spa.power, spa.diagnostics) == expected class TestSpaInfo: @@ -1650,45 +1517,54 @@ def test_partial_update_single_jet( assert spa.jets[2].jet_id == 2 assert spa.jets[3].jet_id == 3 - def test_shifted_runtime_routing_and_signed_overflow(self) -> None: - """Test shifted runtime routing across sections and signed 32-bit overflow.""" + @pytest.mark.parametrize( + ("raw_runtimes", "expected_runtimes"), + [ + pytest.param( + (60475904, -1345838592, 921600, 460800), + (11520034, 3200.01, 236234, None, 3600, 1800), + id="synced_with_signed_overflow", + ), + pytest.param( + (0, 0, 0, 0), + (None, None, None, None, None, None), + id="pre_sync_all_zero", + ), + ], + ) + def test_shifted_runtime_routing( + self, + raw_runtimes: tuple[int, int, int, int], + expected_runtimes: tuple[ + int | None, + float | None, + int | None, + int | None, + int | None, + int | None, + ], + ) -> None: + """Test shifted runtime routing, signed overflow, and pre-sync zeros.""" + heater_hours, jet1_raw, jet2_raw, jet3_raw = raw_runtimes spa = Spa( { - "heater": {"status": {"heater": "off", "heaterHours": 60475904}}, + "heater": {"status": {"heater": "off", "heaterHours": heater_hours}}, "JET": { - "JET1": {"status": {"speed": "off", "jet_1_ON_sec": -1345838592}}, - "JET2": {"status": {"speed": "off", "jet_2_ON_sec": 921600}}, - "JET3": {"status": {"speed": "off", "jet_3_ON_sec": 460800}}, + "JET1": {"status": {"speed": "off", "jet_1_ON_sec": jet1_raw}}, + "JET2": {"status": {"speed": "off", "jet_2_ON_sec": jet2_raw}}, + "JET3": {"status": {"speed": "off", "jet_3_ON_sec": jet3_raw}}, }, "blower": {"config": {"blower": "enable"}, "status": {"blower": "off"}}, } ) - assert spa.system_uptime_seconds == 11520034 - assert spa.system_uptime_hours == 3200.01 - assert spa.jets[1].on_seconds == 236234 - assert spa.jets[2].on_seconds is None - assert spa.jets[3].on_seconds == 3600 - assert spa.blower.on_seconds == 1800 - - def test_pre_sync_all_zero_runtimes_stay_none(self) -> None: - """Test pre-sync all-zero runtime counters remain None.""" - spa = Spa( - { - "heater": {"status": {"heater": "off", "heaterHours": 0}}, - "JET": { - "JET1": {"status": {"speed": "off", "jet_1_ON_sec": 0}}, - "JET2": {"status": {"speed": "off", "jet_2_ON_sec": 0}}, - "JET3": {"status": {"speed": "off", "jet_3_ON_sec": 0}}, - }, - "blower": {"status": {"blower": "disable"}}, - } - ) - assert spa.system_uptime_seconds is None - assert spa.system_uptime_hours is None - assert spa.jets[1].on_seconds is None - assert spa.jets[2].on_seconds is None - assert spa.jets[3].on_seconds is None - assert spa.blower.on_seconds is None + assert ( + spa.system_uptime_seconds, + spa.system_uptime_hours, + spa.jets[1].on_seconds, + spa.jets[2].on_seconds, + spa.jets[3].on_seconds, + spa.blower.on_seconds, + ) == expected_runtimes def test_partial_update_versions(self, status_response: dict[str, object]) -> None: """Test updating product versions partially retains cached fields.""" From 70e885de2c764572fad3e2c625c17d8e53f4d791 Mon Sep 17 00:00:00 2001 From: Moustachauve <2206577+Moustachauve@users.noreply.github.com> Date: Wed, 18 Nov 2026 16:05:22 -0500 Subject: [PATCH 3/6] Poll baseline and pump currents cleanly and harden power reconstruction Current sensors stayed unpopulated while idle or running Jet 1/2/blower, and malformed optional /addDebugData responses or back-to-back diagnostic polls could fail update() or pair stale /status bytes. Fetch /addDebugData once for baseline small-loads current and while any pump or heater load is active, suppress non-critical debug parse errors during update(), guard cross-endpoint heater pairing across partial updates, and clean up dead casts and jet iteration helpers. --- demo/demo_print_data.py | 7 +- src/hotspring/hotspring.py | 11 +- src/hotspring/models.py | 232 +++++++++++++++------------ tests/__snapshots__/test_models.ambr | 34 +++- tests/test_hotspring.py | 147 +++++++++++------ tests/test_models.py | 45 +++++- 6 files changed, 319 insertions(+), 157 deletions(-) diff --git a/demo/demo_print_data.py b/demo/demo_print_data.py index 9b64f56..8f68dc3 100644 --- a/demo/demo_print_data.py +++ b/demo/demo_print_data.py @@ -45,7 +45,12 @@ def print_heater_and_jets(s: Spa) -> None: print(f"Heating Mode: {s.heater.heating_mode.value}") print(f"Heater Lock: {s.heater.heater_lock}") print(f"Heat Pump: {s.heater.heatpump_installed}") - print(f"System Uptime: {s.system_uptime_hours} hrs ({s.system_uptime_seconds} s)") + uptime = ( + f"{s.system_uptime_hours:.2f} hrs ({s.system_uptime_seconds} s)" + if s.system_uptime_hours is not None + else "N/A" + ) + print(f"System Uptime: {uptime}") print("\n" + "=" * 20) print(" JETS & BLOWER") diff --git a/src/hotspring/hotspring.py b/src/hotspring/hotspring.py index 6c5a877..ecb1c49 100644 --- a/src/hotspring/hotspring.py +++ b/src/hotspring/hotspring.py @@ -259,8 +259,8 @@ async def update(self, *, refresh_identity: bool = False) -> Spa: On subsequent routine polling cycles, it queries /status and /spaConnectStatus sequentially, avoiding redundant radio (LoRA) queries for static identity data while keeping telemetry and connection status fresh. When power monitoring is - supported and active loads (such as the heater or Jet 3) require /addDebugData - to complete power reconstruction, it is also fetched opportunistically. + supported and /addDebugData is needed for initial baseline current or active + loads, it is also fetched opportunistically. Args: ---- @@ -341,7 +341,7 @@ async def update(self, *, refresh_identity: bool = False) -> Spa: return self.spa async def _refresh_power_diagnostics(self) -> None: - """Fetch /addDebugData when active loads require it for power metrics.""" + """Fetch /addDebugData when needed for baseline current or active loads.""" if ( self.spa is not None and self.spa.connection_status.spa_connected @@ -349,7 +349,10 @@ async def _refresh_power_diagnostics(self) -> None: ): debug_response = await self._safe_request(Endpoint.DEBUG_DATA) if debug_response: - with _parsing(Endpoint.DEBUG_DATA): + with ( + contextlib.suppress(HotSpringError), + _parsing(Endpoint.DEBUG_DATA), + ): self.spa.update_diagnostics(debug_response) async def get_device_info(self) -> SpaInfo: diff --git a/src/hotspring/models.py b/src/hotspring/models.py index 4ddc9eb..28b40af 100644 --- a/src/hotspring/models.py +++ b/src/hotspring/models.py @@ -28,7 +28,7 @@ ) if TYPE_CHECKING: - from collections.abc import Callable + from collections.abc import Callable, Iterator class Spa: @@ -56,6 +56,7 @@ class Spa: power: PowerMetrics system_uptime_seconds: int | None _status_electrical: _StatusElectrical | None + _status_electrical_pairable: bool def __init__(self, data: dict[str, object]) -> None: """Initialize a Spa from the API response. @@ -83,6 +84,7 @@ def __init__(self, data: dict[str, object]) -> None: self.connection_status = ConnectionStatus() self.diagnostics = Diagnostics() self._status_electrical = None + self._status_electrical_pairable = False if data: self.update_from_dict(data) @@ -158,6 +160,9 @@ def update_from_dict(self, data: dict[str, object]) -> set[str]: next_electrical = _extract_status_electrical(data) if next_electrical is not None: self._status_electrical = next_electrical + self._status_electrical_pairable = True + elif self.heater.is_on != prior_active[0]: + self._status_electrical_pairable = False self._recompute_power( prior_active=prior_active, @@ -234,6 +239,8 @@ def update_diagnostics(self, data: dict[str, object]) -> None: prior_active=self._active_circuit_flags, debug_words=debug_words, ) + if debug_words is not None: + self._status_electrical_pairable = False def update_freshwater_iq(self, data: dict[str, object]) -> None: """Update FreshWater IQ data from /getFWIQData response. @@ -331,6 +338,12 @@ def _recompute_power( pump_blower_unchanged = ( pump_blower_is_on and pump_blower_state == prior_pump_blower_state ) + fresh = _decode_fresh_electrical( + status_words, + debug_words, + status_fresh=status_fresh, + status_pairable=self._status_electrical_pairable, + ) self.power = PowerMetrics( supported=True, @@ -338,87 +351,42 @@ def _recompute_power( jet1_jet2_blower_power=_resolve_gated_metric( is_active=pump_blower_is_on, was_active=pump_blower_unchanged, - fresh_value=( - _reconstruct_uint16( - status_words.small_loads_current_word, - status_words.heater_current_word, - ) - if status_fresh - else None - ), + fresh_value=fresh.pump_blower_power, previous_value=self.power.jet1_jet2_blower_power, ), heater_power=_resolve_gated_metric( is_active=self.heater.is_on, was_active=was_heating, - fresh_value=( - _reconstruct_uint16( - status_words.jet3_current_word, - debug_words.jet1_jet2_blower_power_word, - ) - if debug_words is not None - else None - ), + fresh_value=fresh.heater_power, previous_value=self.power.heater_power, ), jet3_power=_resolve_gated_metric( is_active=jet3_is_on, was_active=was_jet3_on, - fresh_value=( - _reconstruct_uint16( - debug_words.jet1_jet2_blower_power_word, - debug_words.small_loads_power_word, - ) - if debug_words is not None - else None - ), + fresh_value=fresh.jet3_power, previous_value=self.power.jet3_power, ), jet1_jet2_blower_current=_resolve_gated_metric( is_active=pump_blower_is_on, was_active=pump_blower_unchanged, - fresh_value=( - _reconstruct_uint16( - debug_words.l2_volts_word, - debug_words.heater_volts_word, - ) - if debug_words is not None - else None - ), + fresh_value=fresh.pump_blower_current, previous_value=self.power.jet1_jet2_blower_current, ), small_loads_current=( - _reconstruct_uint16( - debug_words.heater_volts_word, - debug_words.jet3_volts_word, - ) - if debug_words is not None + fresh.small_loads_current + if fresh.small_loads_current is not None else self.power.small_loads_current ), heater_current=_resolve_gated_metric( is_active=self.heater.is_on, was_active=was_heating, - fresh_value=( - _reconstruct_uint16( - debug_words.jet3_volts_word, - status_words.jet1_jet2_blower_current_word, - ) - if debug_words is not None - else None - ), + fresh_value=fresh.heater_current, previous_value=self.power.heater_current, ), jet3_current=_resolve_gated_metric( is_active=jet3_is_on, was_active=was_jet3_on, - fresh_value=( - _reconstruct_uint16( - status_words.jet1_jet2_blower_current_word, - status_words.small_loads_current_word, - ) - if status_fresh - else None - ), + fresh_value=fresh.jet3_current, previous_value=self.power.jet3_current, ), ) @@ -455,8 +423,15 @@ def system_uptime_hours(self) -> float | None: @property def needs_diagnostics_for_power(self) -> bool: - """Return True when /addDebugData is needed for active power readings.""" - return self.power.supported and (self.heater.is_on or self._is_jet3_on) + """Return True when /addDebugData is needed for power or current readings.""" + if not self.power.supported: + return False + return ( + self.power.small_loads_current is None + or self.heater.is_on + or self._is_jet3_on + or self._pump_blower_state != (JetSpeed.OFF, JetSpeed.OFF, False) + ) @property def is_hna(self) -> bool: @@ -744,20 +719,11 @@ def dict_from_dict( A dict of Jet instances keyed by jet ID. """ - if "control" in data and isinstance(data["control"], dict): - data = data["control"] existing_map = existing or {} - jets: dict[int, Jet] = {} - for key, value in data.items(): - if key.upper().startswith("JET") and isinstance(value, dict): - try: - jet_id = int(key[3:]) - except ValueError: - continue - jets[jet_id] = Jet.from_dict( - jet_id, value, existing=existing_map.get(jet_id) - ) - return jets + return { + jet_id: Jet.from_dict(jet_id, jet_data, existing=existing_map.get(jet_id)) + for jet_id, jet_data in _iter_jet_sections(data) + } @dataclass @@ -1452,6 +1418,77 @@ class _ShiftedRuntimes(NamedTuple): blower_seconds: int | None +class _FreshElectrical(NamedTuple): + """Freshly decoded 16-bit electrical values from the current poll(s).""" + + pump_blower_power: int | None = None + heater_power: int | None = None + jet3_power: int | None = None + pump_blower_current: int | None = None + small_loads_current: int | None = None + heater_current: int | None = None + jet3_current: int | None = None + + +def _decode_fresh_electrical( + status_words: _StatusElectrical, + debug_words: _DebugElectrical | None, + *, + status_fresh: bool, + status_pairable: bool, +) -> _FreshElectrical: + """Decode fresh 16-bit metrics available from the current poll(s).""" + pump_blower_power: int | None = None + jet3_current: int | None = None + if status_fresh: + jet3_current = _reconstruct_uint16( + status_words.jet1_jet2_blower_current_word, + status_words.small_loads_current_word, + ) + pump_blower_power = _reconstruct_uint16( + status_words.small_loads_current_word, + status_words.heater_current_word, + ) + + heater_power: int | None = None + jet3_power: int | None = None + pump_blower_current: int | None = None + small_loads_current: int | None = None + heater_current: int | None = None + if debug_words is not None: + pump_blower_current = _reconstruct_uint16( + debug_words.l2_volts_word, + debug_words.heater_volts_word, + ) + small_loads_current = _reconstruct_uint16( + debug_words.heater_volts_word, + debug_words.jet3_volts_word, + ) + if status_pairable: + heater_current = _reconstruct_uint16( + debug_words.jet3_volts_word, + status_words.jet1_jet2_blower_current_word, + ) + heater_power = _reconstruct_uint16( + status_words.jet3_current_word, + debug_words.jet1_jet2_blower_power_word, + ) + jet3_power = _reconstruct_uint16( + debug_words.jet1_jet2_blower_power_word, + debug_words.small_loads_power_word, + ) + + return _FreshElectrical( + pump_blower_power=pump_blower_power, + heater_power=heater_power, + jet3_power=jet3_power, + pump_blower_current=pump_blower_current, + small_loads_current=small_loads_current, + heater_current=heater_current, + jet3_current=jet3_current, + ) + + def _reconstruct_uint16(low_byte_word: int, high_byte_word: int) -> int: """Reconstruct a 16-bit register split across two adjacent misaligned words. @@ -1474,20 +1511,22 @@ def _decode_runtime_seconds(raw: object) -> int: return (raw_value & 0xFFFFFFFF) >> 8 -def _find_jet_status(jets_data: dict[str, object], jet_id: int) -> dict[str, object]: - """Return the status dict for ``JET`` (case-insensitive), or empty dict.""" - target = f"JET{jet_id}" +def _iter_jet_sections( + jets_data: dict[str, object], +) -> Iterator[tuple[int, dict[str, object]]]: + """Yield ``(jet_id, jet_data)`` pairs from a ``JET`` section dict.""" source = ( jets_data["control"] if "control" in jets_data and isinstance(jets_data["control"], dict) else jets_data ) for key, value in source.items(): - if key.upper() == target and isinstance(value, dict): - status = value.get("status") - if isinstance(status, dict): - return status - return {} + if key.upper().startswith("JET") and isinstance(value, dict): + try: + jet_id = int(key[3:]) + except ValueError: + continue + yield jet_id, value def _extract_shifted_runtimes(data: dict[str, object]) -> _ShiftedRuntimes: @@ -1505,17 +1544,16 @@ def _extract_shifted_runtimes(data: dict[str, object]) -> _ShiftedRuntimes: jets = data.get("JET") if isinstance(jets, dict): - jet1_status = _find_jet_status(jets, 1) - if "jet_1_ON_sec" in jet1_status: - uptime_seconds = _decode_runtime_seconds(jet1_status["jet_1_ON_sec"]) - - jet2_status = _find_jet_status(jets, 2) - if "jet_2_ON_sec" in jet2_status: - jet3_seconds = _decode_runtime_seconds(jet2_status["jet_2_ON_sec"]) - - jet3_status = _find_jet_status(jets, 3) - if "jet_3_ON_sec" in jet3_status: - blower_seconds = _decode_runtime_seconds(jet3_status["jet_3_ON_sec"]) + for jet_id, jet_data in _iter_jet_sections(jets): + status = jet_data.get("status") + if not isinstance(status, dict): + continue + if jet_id == 1 and "jet_1_ON_sec" in status: + uptime_seconds = _decode_runtime_seconds(status["jet_1_ON_sec"]) + elif jet_id == 2 and "jet_2_ON_sec" in status: + jet3_seconds = _decode_runtime_seconds(status["jet_2_ON_sec"]) + elif jet_id == 3 and "jet_3_ON_sec" in status: + blower_seconds = _decode_runtime_seconds(status["jet_3_ON_sec"]) return _ShiftedRuntimes( jet1_seconds=jet1_seconds, @@ -1536,23 +1574,9 @@ def _extract_shifted_runtimes(data: dict[str, object]) -> _ShiftedRuntimes: def _extract_status_electrical(data: dict[str, object]) -> _StatusElectrical | None: """Extract a complete 4-word electrical block from /status when present. - Standalone ``heaterCurrent`` or ``JET3.status.current`` fields in partial - command echoes are validated as integers, while ``_StatusElectrical`` is - only updated when ``test_data.status`` carries all four contiguous words so - adjacent bytes are never paired across different polls. + ``_StatusElectrical`` is only updated when ``test_data.status`` carries all + four contiguous words so adjacent bytes are never paired across polls. """ - heater = data.get("heater") - if isinstance(heater, dict): - heater_status = heater.get("status") - if isinstance(heater_status, dict) and "heaterCurrent" in heater_status: - int(heater_status["heaterCurrent"]) - - jets = data.get("JET") - if isinstance(jets, dict): - jet3_status = _find_jet_status(jets, 3) - if "current" in jet3_status: - int(jet3_status["current"]) - test_data = data.get("test_data") if not isinstance(test_data, dict): return None diff --git a/tests/__snapshots__/test_models.ambr b/tests/__snapshots__/test_models.ambr index dc3a13c..133631a 100644 --- a/tests/__snapshots__/test_models.ambr +++ b/tests/__snapshots__/test_models.ambr @@ -290,6 +290,22 @@ 4021, ) # --- +# name: TestPowerMetrics.test_reconstructed_load_states[idle_synced] + tuple( + PowerMetrics( + heater_current=0, + heater_power=0, + jet1_jet2_blower_current=0, + jet1_jet2_blower_power=0, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=63, + supported=True, + ), + 63, + ) +# --- # name: TestPowerMetrics.test_reconstructed_load_states[jet1_low] tuple( PowerMetrics( @@ -354,7 +370,7 @@ None, ) # --- -# name: TestPowerMetrics.test_status_only_power_metrics[idle_supported] +# name: TestPowerMetrics.test_status_only_power_metrics[idle_awaiting_baseline_debug] tuple( PowerMetrics( heater_current=0, @@ -370,6 +386,22 @@ 63, ) # --- +# name: TestPowerMetrics.test_status_only_power_metrics[jet1_awaiting_debug] + tuple( + PowerMetrics( + heater_current=0, + heater_power=0, + jet1_jet2_blower_current=None, + jet1_jet2_blower_power=1819, + jet3_current=0, + jet3_power=0, + small_loads_current=None, + small_loads_power=72, + supported=True, + ), + 1891, + ) +# --- # name: TestPowerMetrics.test_status_only_power_metrics[jet3_awaiting_debug] tuple( PowerMetrics( diff --git a/tests/test_hotspring.py b/tests/test_hotspring.py index 5681c5d..22a94d6 100644 --- a/tests/test_hotspring.py +++ b/tests/test_hotspring.py @@ -56,6 +56,15 @@ def _json_response(fixture_name: str, status: int = 200) -> Response: ) +def _raw_json(payload: object, status: int = 200) -> Response: + """Create a JSON response from an inline payload.""" + return Response( + status=status, + headers={"Content-Type": "application/json"}, + text=json.dumps(payload), + ) + + async def _timeout_handler(_: aiohttp.web.Request) -> Response: """Simulate a slow endpoint that exceeds request_timeout.""" await asyncio.sleep(0.2) @@ -73,6 +82,7 @@ def _add_update_mocks( # noqa: PLR0913 connect_payload: str | None = None, spamodel_status: int = 200, debug_status: int | None = 200, + debug_response: Response | None = None, ) -> None: """Add mock responses for a full update() call.""" host = "192.168.1.100" @@ -105,7 +115,9 @@ def _add_update_mocks( # noqa: PLR0913 HTTPMethod.GET, _json_response("spamodel.json", status=spamodel_status), ) - if debug_status is not None and ( + if debug_response is not None: + aresponses.add(host, Endpoint.DEBUG_DATA, HTTPMethod.GET, debug_response) + elif debug_status is not None and ( status_payload is not None or status_fixture == "status.json" ): aresponses.add( @@ -605,77 +617,130 @@ async def test_update_diagnostics( assert diag == snapshot @pytest.mark.parametrize( - ("scenario", "expected_supported", "expected_total"), + ("heater_current", "connect_payload", "expected_supported"), [ - pytest.param(("off", 19200, None), True, 75, id="heater_and_jet3_off"), - pytest.param(("on", 0, None), False, None, id="power_unsupported"), + pytest.param(0, None, False, id="power_unsupported"), pytest.param( - ("on", 19200, '{"spaConnectStatus": "false"}'), - True, - None, - id="spa_disconnected", + 19200, '{"spaConnectStatus": "false"}', True, id="spa_disconnected" ), ], ) async def test_update_skips_debug_data_when_not_needed( self, aresponses: ResponsesMockServer, - scenario: tuple[str, int, str | None], + heater_current: int, + connect_payload: str | None, expected_supported: bool, - expected_total: int | None, ) -> None: - """Test update() skips /addDebugData when disconnected or not needed.""" - heater_state, heater_current, connect_payload = scenario + """Test update() skips /addDebugData when disconnected or unsupported.""" status = json.loads(_load("status.json")) - status["heater"]["status"]["heater"] = heater_state - status["heater"]["status"]["heaterCurrent"] = heater_current status["test_data"]["status"]["heaterCurrent"] = heater_current - async def fail_if_called(_: aiohttp.web.Request) -> Response: - pytest.fail("/addDebugData should not be requested") - _add_update_mocks( aresponses, status_payload=status, connect_payload=connect_payload, debug_status=None, ) + + async with aiohttp.ClientSession() as session: + client = HotSpring(host="192.168.1.100", session=session) + spa = await client.update() + + assert spa.power.supported is expected_supported + assert spa.power.total_power is None + assert Endpoint.DEBUG_DATA not in [ + entry.request.path for entry in aresponses.history + ] + + async def test_routine_idle_poll_skips_debug_data_after_baseline( + self, aresponses: ResponsesMockServer + ) -> None: + """Test idle update() fetches /addDebugData once and skips further polls.""" + idle_status = json.loads(_load("status.json")) + idle_status["heater"]["status"]["heater"] = "off" + idle_status["JET"]["JET1"]["status"]["speed"] = "off" + + _add_update_mocks(aresponses, status_payload=idle_status) aresponses.add( - "192.168.1.100", Endpoint.DEBUG_DATA, HTTPMethod.GET, fail_if_called + "192.168.1.100", Endpoint.STATUS, HTTPMethod.GET, _raw_json(idle_status) + ) + aresponses.add( + "192.168.1.100", + Endpoint.SPA_CONNECT_STATUS, + HTTPMethod.GET, + _json_response("spa_connect_status.json"), ) async with aiohttp.ClientSession() as session: client = HotSpring(host="192.168.1.100", session=session) spa = await client.update() + assert spa.power.small_loads_current == 0 + spa = await client.update() - assert spa.power.supported is expected_supported - assert spa.power.total_power == expected_total + assert spa.power.small_loads_current == 0 + assert spa.power.total_power == 75 + assert [entry.request.path for entry in aresponses.history].count( + Endpoint.DEBUG_DATA + ) == 1 + @pytest.mark.parametrize( + "debug_response", + [ + pytest.param(Response(status=500, text="error"), id="http_500"), + pytest.param( + _raw_json({"debugData": {"status": {"L1_N_Volts": "n/a"}}}), + id="malformed_payload", + ), + ], + ) async def test_update_debug_data_failure_is_non_critical( - self, aresponses: ResponsesMockServer + self, aresponses: ResponsesMockServer, debug_response: Response ) -> None: - """Test /addDebugData HTTP error during update() does not fail update().""" - _add_update_mocks(aresponses, debug_status=500) + """Test /addDebugData HTTP or parse errors do not fail update().""" + _add_update_mocks(aresponses, debug_response=debug_response) async with aiohttp.ClientSession() as session: client = HotSpring(host="192.168.1.100", session=session) spa = await client.update() + # pylint: disable=protected-access + assert client._identity_loaded is True assert spa.power.supported is True assert spa.power.small_loads_power == 75 assert spa.power.heater_power is None - async def test_routine_poll_fetches_debug_data_when_heating( - self, aresponses: ResponsesMockServer + @pytest.mark.parametrize( + ( + "heater_state", + "jet1_speed", + "expected_heater_power", + "expected_pump_current", + ), + [ + pytest.param("on", "off", 3584, 0, id="heater_on"), + pytest.param("off", "highSpeed", 0, 15, id="jet1_high_heater_off"), + ], + ) + async def test_routine_poll_fetches_debug_data_when_load_active( + self, + aresponses: ResponsesMockServer, + heater_state: str, + jet1_speed: str, + expected_heater_power: int, + expected_pump_current: int, ) -> None: - """Test routine update() fetches /addDebugData once heating turns on.""" + """Test routine update() fetches /addDebugData when heater or pump runs.""" idle_status = json.loads(_load("status.json")) idle_status["heater"]["status"]["heater"] = "off" - _add_update_mocks(aresponses, status_payload=idle_status, debug_status=None) + idle_status["JET"]["JET1"]["status"]["speed"] = "off" + + active_status = json.loads(_load("status.json")) + active_status["heater"]["status"]["heater"] = heater_state + active_status["JET"]["JET1"]["status"]["speed"] = jet1_speed + + _add_update_mocks(aresponses, status_payload=idle_status) aresponses.add( - "192.168.1.100", - Endpoint.STATUS, - HTTPMethod.GET, - _json_response("status.json"), + "192.168.1.100", Endpoint.STATUS, HTTPMethod.GET, _raw_json(active_status) ) aresponses.add( "192.168.1.100", @@ -694,17 +759,9 @@ async def test_routine_poll_fetches_debug_data_when_heating( await client.update() spa = await client.update() - assert spa.power.heater_power == 3584 - assert spa.power.total_power == 3659 - - -def _raw_json(payload: object) -> Response: - """Create a JSON response from an inline payload.""" - return Response( - status=200, - headers={"Content-Type": "application/json"}, - text=json.dumps(payload), - ) + assert spa.power.heater_power == expected_heater_power + assert spa.power.jet1_jet2_blower_current == expected_pump_current + assert spa.power.total_power == 75 + expected_heater_power class TestMalformedResponse: @@ -714,12 +771,12 @@ class TestMalformedResponse: ("payload", "cause_type"), [ pytest.param( - {"heater": {"status": {"heaterCurrent": ""}}}, + {"heater": {"status": {"heaterHours": ""}}}, ValueError, id="empty_string_number", ), pytest.param( - {"heater": {"status": {"heaterCurrent": None}}}, + {"heater": {"status": {"heaterHours": None}}}, TypeError, id="null_number", ), @@ -850,7 +907,7 @@ async def test_malformed_command_echo( "192.168.1.100", Endpoint.SPA_MANAGER, HTTPMethod.POST, - _raw_json({"heater": {"status": {"heaterCurrent": ""}}}), + _raw_json({"heater": {"status": {"heaterHours": ""}}}), ) async with aiohttp.ClientSession() as session: client = HotSpring(host="192.168.1.100", session=session) diff --git a/tests/test_models.py b/tests/test_models.py index ed21d99..7d7d5f8 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -810,7 +810,16 @@ class TestPowerMetrics: [ pytest.param({}, False, id="empty"), pytest.param(_power_status(heater="on"), False, id="unsupported_board"), - pytest.param(_power_status((0, 0, 16128, 0)), False, id="idle_supported"), + pytest.param( + _power_status((0, 0, 16128, 0)), + True, + id="idle_awaiting_baseline_debug", + ), + pytest.param( + _power_status((0, 6912, 18439, 0), jet1="highSpeed"), + True, + id="jet1_awaiting_debug", + ), pytest.param( _power_status((0, 0, 16128, 30208), heater="on"), True, @@ -835,31 +844,42 @@ def test_status_only_power_metrics( assert (spa.power, spa.power.total_power) == snapshot @pytest.mark.parametrize( - ("status_data", "debug_data"), + ("status_data", "debug_data", "expected_needs_diagnostics"), [ + pytest.param( + _power_status((0, 0, 16128, 0)), + _power_debug(), + False, + id="idle_synced", + ), pytest.param( _power_status((0, 2048, 18434, 0), jet1="lowSpeed"), _power_debug(l2_volts=256), + True, id="jet1_low", ), pytest.param( _power_status((0, 7680, 15631, 0), jet1="highSpeed", jet2="highSpeed"), _power_debug(l2_volts=3584), + True, id="both_jets_high", ), pytest.param( _power_status((0, 0, 16128, 30208), heater="on"), _power_debug(jet3_volts=3840, jet1_jet2_blower_power=15), + True, id="heater_only", ), pytest.param( _power_status((0, 3584, 18183, 16128), heater="on", jet1="highSpeed"), _power_debug(l2_volts=1792, jet3_volts=3840, jet1_jet2_blower_power=15), + True, id="heater_and_jet1_high", ), pytest.param( _power_status((2048, 0, 17920, 0), jet3="highSpeed"), _power_debug(jet1_jet2_blower_power=51200, small_loads_power=7), + True, id="jet3_active", ), ], @@ -868,11 +888,13 @@ def test_reconstructed_load_states( self, status_data: dict[str, object], debug_data: dict[str, object], + expected_needs_diagnostics: bool, snapshot: SnapshotAssertion, ) -> None: """Test byte-reconstructed power and current across active spa circuits.""" spa = Spa(status_data) spa.update_diagnostics(debug_data) + assert spa.needs_diagnostics_for_power is expected_needs_diagnostics assert (spa.power, spa.power.total_power) == snapshot @pytest.mark.parametrize( @@ -929,6 +951,25 @@ def test_unsynced_debug_data_preserves_active_power_and_diagnostics(self) -> Non spa.update_diagnostics({}) assert (spa.power, spa.diagnostics) == expected + def test_heater_echo_before_status_prevents_stale_debug_pairing(self) -> None: + """Test heater-on echo without test_data blocks stale low-byte pairing.""" + spa = Spa(_power_status((0, 0, 16128, 0), heater="off")) + spa.update_from_dict({"heater": {"status": {"heater": "on"}}}) + spa.update_diagnostics(_power_debug(jet3_volts=3840, jet1_jet2_blower_power=15)) + + assert spa.power.small_loads_current == 0 + assert spa.power.heater_power is None + assert spa.power.heater_current is None + + def test_consecutive_debug_updates_do_not_repair_stale_status(self) -> None: + """Test repeat /addDebugData calls without /status preserve heater power.""" + spa = Spa(_power_status((0, 0, 16128, 30208), heater="on")) + spa.update_diagnostics(_power_debug(jet3_volts=3840, jet1_jet2_blower_power=14)) + expected = spa.power + + spa.update_diagnostics(_power_debug(jet3_volts=3840, jet1_jet2_blower_power=15)) + assert spa.power == expected + class TestSpaInfo: """Tests for SpaInfo model parsing.""" From b625f670b96ca0fa4eac4d3578803497a32976a1 Mon Sep 17 00:00:00 2001 From: Moustachauve <2206577+Moustachauve@users.noreply.github.com> Date: Wed, 18 Nov 2026 16:43:39 -0500 Subject: [PATCH 4/6] Simplify electrical register decoding and power gating with tables Separate word containers, decoding helpers, and per-field gating duplicated the layout of a single contiguous stream of register words and added unnecessary state flags and test boilerplate. Walk the 10-word sequence and runtime routes from mapping tables, replace separate electrical state fields with use-once pending status words, deduplicate client debug fetching and hour conversion, and streamline model and snapshot tests. --- demo/demo_print_data.py | 23 +- src/hotspring/hotspring.py | 21 +- src/hotspring/models.py | 691 ++++++++++----------------- tests/__snapshots__/test_models.ambr | 411 ++++++++-------- tests/test_hotspring.py | 91 +--- tests/test_models.py | 230 +++++---- 6 files changed, 629 insertions(+), 838 deletions(-) diff --git a/demo/demo_print_data.py b/demo/demo_print_data.py index 8f68dc3..1bb603c 100644 --- a/demo/demo_print_data.py +++ b/demo/demo_print_data.py @@ -33,6 +33,11 @@ def print_identity(s: Spa) -> None: print(f"SNA Ready: {s.info.sna_ready}") +def _format_runtime(hours: float | None, seconds: int | None) -> str: + """Format runtime hours and seconds, or N/A when unavailable.""" + return f"{hours:.2f}h ({seconds}s)" if hours is not None else "N/A" + + def print_heater_and_jets(s: Spa) -> None: """Print heater and jets info.""" print("\n" + "=" * 20) @@ -45,11 +50,7 @@ def print_heater_and_jets(s: Spa) -> None: print(f"Heating Mode: {s.heater.heating_mode.value}") print(f"Heater Lock: {s.heater.heater_lock}") print(f"Heat Pump: {s.heater.heatpump_installed}") - uptime = ( - f"{s.system_uptime_hours:.2f} hrs ({s.system_uptime_seconds} s)" - if s.system_uptime_hours is not None - else "N/A" - ) + uptime = _format_runtime(s.system_uptime_hours, s.system_uptime_seconds) print(f"System Uptime: {uptime}") print("\n" + "=" * 20) @@ -60,21 +61,13 @@ def print_heater_and_jets(s: Spa) -> None: extra = "" if jet.concurrent_mode: extra += " Concurrent=True" - runtime = ( - f"{jet.on_hours:.2f}h ({jet.on_seconds}s)" - if jet.on_hours is not None - else "N/A" - ) + runtime = _format_runtime(jet.on_hours, jet.on_seconds) print( f"Jet {jet.jet_id:1}: Available={jet.is_available!s:5} " f"SpeedType={jet.speed_type.value:11} State={jet.speed.value:10} " f"Supported=[{supported}] Runtime={runtime}{extra}" ) - blower_runtime = ( - f"{s.blower.on_hours:.2f}h ({s.blower.on_seconds}s)" - if s.blower.on_hours is not None - else "N/A" - ) + blower_runtime = _format_runtime(s.blower.on_hours, s.blower.on_seconds) print( f"Blower: Status={'ON' if s.blower.is_on else 'OFF':3} " f"Enabled={s.blower.is_enabled} Runtime={blower_runtime}" diff --git a/src/hotspring/hotspring.py b/src/hotspring/hotspring.py index ecb1c49..11ba1a3 100644 --- a/src/hotspring/hotspring.py +++ b/src/hotspring/hotspring.py @@ -316,7 +316,7 @@ async def update(self, *, refresh_identity: bool = False) -> Spa: ) raise HotSpringSNADetectedError(msg) - await self._refresh_power_diagnostics() + await self._refresh_power_diagnostics(self.spa) self._identity_loaded = True return self.spa @@ -337,23 +337,18 @@ async def update(self, *, refresh_identity: bool = False) -> Spa: ): self.spa.connection_status.spa_connected = True - await self._refresh_power_diagnostics() + await self._refresh_power_diagnostics(self.spa) return self.spa - async def _refresh_power_diagnostics(self) -> None: + async def _refresh_power_diagnostics(self, spa: Spa) -> None: """Fetch /addDebugData when needed for baseline current or active loads.""" if ( - self.spa is not None - and self.spa.connection_status.spa_connected - and self.spa.needs_diagnostics_for_power + not spa.connection_status.spa_connected + or not spa.needs_diagnostics_for_power ): - debug_response = await self._safe_request(Endpoint.DEBUG_DATA) - if debug_response: - with ( - contextlib.suppress(HotSpringError), - _parsing(Endpoint.DEBUG_DATA), - ): - self.spa.update_diagnostics(debug_response) + return + with contextlib.suppress(HotSpringError): + await self._fetch(Endpoint.DEBUG_DATA, spa.update_diagnostics) async def get_device_info(self) -> SpaInfo: """Fetch lightweight device identity directly from /startup. diff --git a/src/hotspring/models.py b/src/hotspring/models.py index 28b40af..608ec58 100644 --- a/src/hotspring/models.py +++ b/src/hotspring/models.py @@ -9,6 +9,7 @@ from __future__ import annotations import contextlib +import itertools from dataclasses import dataclass, replace from typing import TYPE_CHECKING, NamedTuple @@ -28,7 +29,15 @@ ) if TYPE_CHECKING: - from collections.abc import Callable, Iterator + from collections.abc import Callable + +type _WordBlock = tuple[int | None, ...] +type _PumpBlowerState = tuple[JetSpeed, JetSpeed, bool] | None +type _CircuitStates = tuple[bool, bool, _PumpBlowerState] + +_NO_HEAD_WORDS: _WordBlock = (None, None, None, None) +_NO_STATUS_WORDS: _WordBlock = (None, None, None, None) +_NO_TAIL_WORDS: _WordBlock = (None, None) class Spa: @@ -55,8 +64,7 @@ class Spa: test_metrics: SpaTestData power: PowerMetrics system_uptime_seconds: int | None - _status_electrical: _StatusElectrical | None - _status_electrical_pairable: bool + _pending_status_words: _WordBlock def __init__(self, data: dict[str, object]) -> None: """Initialize a Spa from the API response. @@ -83,8 +91,7 @@ def __init__(self, data: dict[str, object]) -> None: self.info = SpaInfo() self.connection_status = ConnectionStatus() self.diagnostics = Diagnostics() - self._status_electrical = None - self._status_electrical_pairable = False + self._pending_status_words = _NO_STATUS_WORDS if data: self.update_from_dict(data) @@ -101,7 +108,7 @@ def update_from_dict(self, data: dict[str, object]) -> set[str]: """ updated: set[str] = set() - prior_active = self._active_circuit_flags + prior_states = self._circuit_states previous_power = self.power previous_uptime = self.system_uptime_seconds @@ -157,22 +164,33 @@ def update_from_dict(self, data: dict[str, object]) -> set[str]: if self.system_uptime_seconds != previous_uptime: updated.add("system_uptime_seconds") - next_electrical = _extract_status_electrical(data) - if next_electrical is not None: - self._status_electrical = next_electrical - self._status_electrical_pairable = True - elif self.heater.is_on != prior_active[0]: - self._status_electrical_pairable = False - - self._recompute_power( - prior_active=prior_active, - status_fresh=next_electrical is not None, - ) + self._update_power_from_status(data, prior_states) if self.power != previous_power: updated.add("power") return updated + def _update_power_from_status( + self, data: dict[str, object], prior_states: _CircuitStates + ) -> None: + """Update power metrics and pending words from a /status or echo dict.""" + status_words = _extract_status_words(data) + if status_words is not None: + self._pending_status_words = status_words + fresh_power = _decode_registers( + _NO_HEAD_WORDS, status_words, _NO_TAIL_WORDS + ) + else: + if self._circuit_states != prior_states: + self._pending_status_words = _NO_STATUS_WORDS + fresh_power = {} + + self._apply_power_words( + fresh_power, + prior_states=prior_states, + from_status=status_words is not None, + ) + def update_info(self, data: dict[str, object]) -> None: """Update spa identity from /startup and /spamodel responses. @@ -232,15 +250,14 @@ def update_diagnostics(self, data: dict[str, object]) -> None: data: The JSON response from GET /addDebugData. """ - self.diagnostics, debug_words = _parse_diagnostics_and_electrical( - data, existing=self.diagnostics + self.diagnostics, fresh_power, synced = _parse_diagnostics_and_electrical( + data, + existing=self.diagnostics, + status_words=self._pending_status_words, ) - self._recompute_power( - prior_active=self._active_circuit_flags, - debug_words=debug_words, - ) - if debug_words is not None: - self._status_electrical_pairable = False + if synced: + self._pending_status_words = _NO_STATUS_WORDS + self._apply_power_words(fresh_power, prior_states=self._circuit_states) def update_freshwater_iq(self, data: dict[str, object]) -> None: """Update FreshWater IQ data from /getFWIQData response. @@ -267,134 +284,69 @@ def _apply_fwiq_firmware_installed(self) -> bool: def _apply_shifted_runtimes( self, data: dict[str, object], updated: set[str] ) -> None: - """Route misaligned 24-bit runtime fields to their actual components. - - Live testing shows that runtime counters in /status are shifted across - adjacent fields: ``heaterHours`` tracks Jet 1 runtime, ``jet_1_ON_sec`` - tracks overall system uptime, ``jet_2_ON_sec`` tracks Jet 3 runtime, and - ``jet_3_ON_sec`` tracks blower runtime. - """ - runtimes = _extract_shifted_runtimes(data) - present_values = [value for value in runtimes if value is not None] - if not present_values: + """Route misaligned 24-bit runtime fields to their actual components.""" + decoded = { + target: _decode_runtime_seconds(raw) + for path, target in _RUNTIME_ROUTES + if (raw := _dig(data, path)) is not _MISSING + } + if not decoded: return - - is_synced = ( - bool(self.versions.control_box) + if not ( + self.versions.control_box or self.system_uptime_seconds is not None - or any(value != 0 for value in present_values) - ) - if not is_synced: + or any(decoded.values()) + ): return - if runtimes.uptime_seconds is not None: - self.system_uptime_seconds = runtimes.uptime_seconds - if ( - runtimes.jet1_seconds is not None - and 1 in self.jets - and self.jets[1].on_seconds != runtimes.jet1_seconds + if "uptime" in decoded: + self.system_uptime_seconds = decoded["uptime"] + if (blower_seconds := decoded.get("blower")) is not None and ( + self.blower.on_seconds != blower_seconds ): - self.jets[1] = replace(self.jets[1], on_seconds=runtimes.jet1_seconds) - updated.add("jets") - if ( - runtimes.jet3_seconds is not None - and 3 in self.jets - and self.jets[3].on_seconds != runtimes.jet3_seconds - ): - self.jets[3] = replace(self.jets[3], on_seconds=runtimes.jet3_seconds) - updated.add("jets") - if ( - runtimes.blower_seconds is not None - and self.blower.on_seconds != runtimes.blower_seconds - ): - self.blower = replace(self.blower, on_seconds=runtimes.blower_seconds) + self.blower = replace(self.blower, on_seconds=blower_seconds) updated.add("blower") - - def _recompute_power( + for target, jet_id in (("jet1", 1), ("jet3", 3)): + if ( + (seconds := decoded.get(target)) is not None + and jet_id in self.jets + and self.jets[jet_id].on_seconds != seconds + ): + self.jets[jet_id] = replace(self.jets[jet_id], on_seconds=seconds) + updated.add("jets") + + def _apply_power_words( self, + fresh: dict[str, int], *, - prior_active: tuple[bool, bool, tuple[JetSpeed, JetSpeed, bool]], - status_fresh: bool = False, - debug_words: _DebugElectrical | None = None, + prior_states: _CircuitStates, + from_status: bool = False, ) -> None: - """Reconstruct PowerMetrics from /status and paired /addDebugData words.""" - if self._status_electrical is None: - self.power = PowerMetrics() - return - - status_words = self._status_electrical - small_loads_power = _reconstruct_uint16( - status_words.heater_current_word, - status_words.jet3_current_word, - ) - if small_loads_power <= 0: - self.power = PowerMetrics() - return - - was_heating, was_jet3_on, prior_pump_blower_state = prior_active - jet3_is_on = self._is_jet3_on - pump_blower_state = self._pump_blower_state - pump_blower_is_on = pump_blower_state != (JetSpeed.OFF, JetSpeed.OFF, False) - pump_blower_unchanged = ( - pump_blower_is_on and pump_blower_state == prior_pump_blower_state - ) - fresh = _decode_fresh_electrical( - status_words, - debug_words, - status_fresh=status_fresh, - status_pairable=self._status_electrical_pairable, - ) - - self.power = PowerMetrics( - supported=True, - small_loads_power=small_loads_power, - jet1_jet2_blower_power=_resolve_gated_metric( - is_active=pump_blower_is_on, - was_active=pump_blower_unchanged, - fresh_value=fresh.pump_blower_power, - previous_value=self.power.jet1_jet2_blower_power, - ), - heater_power=_resolve_gated_metric( - is_active=self.heater.is_on, - was_active=was_heating, - fresh_value=fresh.heater_power, - previous_value=self.power.heater_power, - ), - jet3_power=_resolve_gated_metric( - is_active=jet3_is_on, - was_active=was_jet3_on, - fresh_value=fresh.jet3_power, - previous_value=self.power.jet3_power, - ), - jet1_jet2_blower_current=_resolve_gated_metric( - is_active=pump_blower_is_on, - was_active=pump_blower_unchanged, - fresh_value=fresh.pump_blower_current, - previous_value=self.power.jet1_jet2_blower_current, - ), - small_loads_current=( - fresh.small_loads_current - if fresh.small_loads_current is not None - else self.power.small_loads_current - ), - heater_current=_resolve_gated_metric( - is_active=self.heater.is_on, - was_active=was_heating, - fresh_value=fresh.heater_current, - previous_value=self.power.heater_current, - ), - jet3_current=_resolve_gated_metric( - is_active=jet3_is_on, - was_active=was_jet3_on, - fresh_value=fresh.jet3_current, - previous_value=self.power.jet3_current, - ), - ) + """Merge freshly decoded power/current words and apply circuit gating.""" + if from_status: + if fresh.get("small_loads_power", 0) <= 0: + self.power = PowerMetrics() + self._pending_status_words = _NO_STATUS_WORDS + return + power = replace(self.power, supported=True, **fresh) + else: + if not self.power.supported: + return + power = replace(self.power, **fresh) + + updates: dict[str, int | None] = {} + for state, before, fields in zip( + self._circuit_states, prior_states, _CIRCUIT_FIELDS, strict=True + ): + if not state: + updates.update(dict.fromkeys(fields, 0)) + elif state != before: + for field in fields: + updates[field] = fresh.get(field) + self.power = replace(power, **updates) @property - def _active_circuit_flags( - self, - ) -> tuple[bool, bool, tuple[JetSpeed, JetSpeed, bool]]: + def _circuit_states(self) -> _CircuitStates: """Return active-state snapshot for (heater, jet3, jet1+jet2+blower).""" return (self.heater.is_on, self._is_jet3_on, self._pump_blower_state) @@ -404,33 +356,27 @@ def _is_jet3_on(self) -> bool: return bool((jet3 := self.jets.get(3)) and jet3.is_enabled and jet3.is_on) @property - def _pump_blower_state(self) -> tuple[JetSpeed, JetSpeed, bool]: - """Return normalized active state of (Jet 1, Jet 2, Blower).""" + def _pump_blower_state(self) -> _PumpBlowerState: + """Return normalized active state of (Jet 1, Jet 2, Blower), or None if off.""" jet1 = self.jets.get(1) jet2 = self.jets.get(2) - return ( + state = ( jet1.speed if jet1 is not None and jet1.is_on else JetSpeed.OFF, jet2.speed if jet2 is not None and jet2.is_on else JetSpeed.OFF, self.blower.is_on, ) + return None if state == (JetSpeed.OFF, JetSpeed.OFF, False) else state @property def system_uptime_hours(self) -> float | None: """Return system uptime in hours when available.""" - if self.system_uptime_seconds is None: - return None - return round(self.system_uptime_seconds / 3600.0, 2) + return _seconds_to_hours(self.system_uptime_seconds) @property def needs_diagnostics_for_power(self) -> bool: """Return True when /addDebugData is needed for power or current readings.""" - if not self.power.supported: - return False - return ( - self.power.small_loads_current is None - or self.heater.is_on - or self._is_jet3_on - or self._pump_blower_state != (JetSpeed.OFF, JetSpeed.OFF, False) + return self.power.supported and ( + self.power.small_loads_current is None or any(self._circuit_states) ) @property @@ -648,9 +594,7 @@ def supported_speeds(self) -> list[JetSpeed]: @property def on_hours(self) -> float | None: """Return cumulative jet runtime in hours when available.""" - if self.on_seconds is None: - return None - return round(self.on_seconds / 3600.0, 2) + return _seconds_to_hours(self.on_seconds) @staticmethod def from_dict( @@ -719,11 +663,20 @@ def dict_from_dict( A dict of Jet instances keyed by jet ID. """ + if "control" in data and isinstance(data["control"], dict): + data = data["control"] existing_map = existing or {} - return { - jet_id: Jet.from_dict(jet_id, jet_data, existing=existing_map.get(jet_id)) - for jet_id, jet_data in _iter_jet_sections(data) - } + jets: dict[int, Jet] = {} + for key, value in data.items(): + if key.upper().startswith("JET") and isinstance(value, dict): + try: + jet_id = int(key[3:]) + except ValueError: + continue + jets[jet_id] = Jet.from_dict( + jet_id, value, existing=existing_map.get(jet_id) + ) + return jets @dataclass @@ -737,9 +690,7 @@ class Blower: @property def on_hours(self) -> float | None: """Return cumulative blower runtime in hours when available.""" - if self.on_seconds is None: - return None - return round(self.on_seconds / 3600.0, 2) + return _seconds_to_hours(self.on_seconds) @staticmethod def from_dict(data: dict[str, object], existing: Blower | None = None) -> Blower: @@ -1278,9 +1229,11 @@ class PowerMetrics: # pylint: disable=too-many-instance-attributes On IQ2020/Eagle control boards equipped with current-sensing hardware, power readings reflect apparent power (``V_rms * I_rms`` in VA, equal to real Watts for the resistive heater and within ~1-25% of real Watts on - pump motors depending on power factor). On entry-level control boards - without current sensors or before initial controller sync, ``supported`` - is ``False`` and all reading fields remain ``None``. + pump motors depending on power factor), and ``*_current`` fields report + whole Amps (``A``). ``small_loads_current`` is sampled at initial baseline + and refreshed while heater or pump loads are active. On entry-level + control boards without current sensors or before initial controller sync, + ``supported`` is ``False`` and all reading fields remain ``None``. """ supported: bool = False @@ -1296,20 +1249,15 @@ class PowerMetrics: # pylint: disable=too-many-instance-attributes @property def total_power(self) -> int | None: """Return combined power across all four spa circuits when known.""" - if ( - not self.supported - or self.small_loads_power is None - or self.jet1_jet2_blower_power is None - or self.heater_power is None - or self.jet3_power is None - ): - return None - return ( - self.small_loads_power - + self.jet1_jet2_blower_power - + self.heater_power - + self.jet3_power + parts = ( + self.small_loads_power, + self.jet1_jet2_blower_power, + self.heater_power, + self.jet3_power, ) + if None in parts: + return None + return sum(part for part in parts if part is not None) @dataclass @@ -1371,135 +1319,114 @@ class Diagnostics: # pylint: disable=too-many-instance-attributes def from_dict( data: dict[str, object], existing: Diagnostics | None = None ) -> Diagnostics: - """Create a Diagnostics from API response data. - - Args: - ---- - data: The JSON response from GET /addDebugData, or an empty - dict for default values. - existing: Optional existing Diagnostics instance to preserve cached fields. - - Returns: - ------- - A Diagnostics instance. - - """ - diagnostics, _ = _parse_diagnostics_and_electrical(data, existing=existing) + """Create a Diagnostics instance from a GET /addDebugData response.""" + diagnostics, _, _ = _parse_diagnostics_and_electrical(data, existing=existing) return diagnostics -@dataclass(frozen=True) -class _StatusElectrical: - """Raw 16-bit electrical words carried in /status.""" - - jet1_jet2_blower_current_word: int = 0 - small_loads_current_word: int = 0 - heater_current_word: int = 0 - jet3_current_word: int = 0 - +_STATUS_ELECTRICAL_KEYS: tuple[str, ...] = ( + "jet1+jet2+blowerCurrent", + "smallLoadsCurrent", + "heaterCurrent", + "jet3Current", +) -@dataclass(frozen=True) -class _DebugElectrical: - """Raw 16-bit electrical words carried in /addDebugData.""" +_DEBUG_HEAD_KEYS: tuple[str, ...] = ( + "L1_N_Volts", + "L2_N_Volts", + "Heater_Volts", + "jet3_Volts", +) - l2_volts_word: int = 0 - heater_volts_word: int = 0 - jet3_volts_word: int = 0 - jet1_jet2_blower_power_word: int = 0 - small_loads_power_word: int = 0 +_DEBUG_TAIL_KEYS: tuple[str, ...] = ( + "jet1_jet2_blowerPower", + "smallLoadsPower", +) +# HNA JSON is one byte out of phase with the controller register block. +# Together, 4 debug head words + 4 /status test_data words + 2 debug tail words +# form one 10-word sequence whose adjacent pairs yield these 9 registers. +_REGISTER_NAMES: tuple[str, ...] = ( + "jet3_volts", + "jet1_jet2_blower_current", + "small_loads_current", + "heater_current", + "jet3_current", + "jet1_jet2_blower_power", + "small_loads_power", + "heater_power", + "jet3_power", +) -class _ShiftedRuntimes(NamedTuple): - """Decoded 24-bit runtime counters extracted from /status.""" +_CIRCUIT_FIELDS: tuple[tuple[str, str], ...] = ( + ("heater_power", "heater_current"), + ("jet3_power", "jet3_current"), + ("jet1_jet2_blower_power", "jet1_jet2_blower_current"), +) - jet1_seconds: int | None - uptime_seconds: int | None - jet3_seconds: int | None - blower_seconds: int | None +_RUNTIME_ROUTES: tuple[tuple[tuple[str, ...], str], ...] = ( + # HNA shifts each 24-bit runtime counter into its neighboring JSON field. + (("heater", "status", "heaterHours"), "jet1"), + (("JET", "JET1", "status", "jet_1_ON_sec"), "uptime"), + (("JET", "JET2", "status", "jet_2_ON_sec"), "jet3"), + (("JET", "JET3", "status", "jet_3_ON_sec"), "blower"), +) +_DEBUG_STRING_KEYS: dict[str, str] = { + "heaterError": "heater_error", + "powerFrequency": "power_frequency", + "pressureSwitchStatus": "pressure_switch_status", + "circulationPumpFlowStatus": "circulation_pump_flow_status", + "regulationThermistorTempStatus": "regulation_thermistor_temp_status", + "limitThermistorStatus": "limit_thermistor_status", +} -class _FreshElectrical(NamedTuple): - """Freshly decoded 16-bit electrical values from the current poll(s).""" +_DEBUG_INTEGER_KEYS: tuple[str, ...] = ( + *_DEBUG_HEAD_KEYS, + *_DEBUG_TAIL_KEYS, + "heaterPower", + "jet3Power", +) - pump_blower_power: int | None = None - heater_power: int | None = None - jet3_power: int | None = None - pump_blower_current: int | None = None - small_loads_current: int | None = None - heater_current: int | None = None - jet3_current: int | None = None +_MISSING = object() -def _decode_fresh_electrical( - status_words: _StatusElectrical, - debug_words: _DebugElectrical | None, - *, - status_fresh: bool, - status_pairable: bool, -) -> _FreshElectrical: - """Decode fresh 16-bit metrics available from the current poll(s).""" - pump_blower_power: int | None = None - jet3_current: int | None = None - if status_fresh: - jet3_current = _reconstruct_uint16( - status_words.jet1_jet2_blower_current_word, - status_words.small_loads_current_word, - ) - pump_blower_power = _reconstruct_uint16( - status_words.small_loads_current_word, - status_words.heater_current_word, - ) +def _seconds_to_hours(seconds: int | None) -> float | None: + """Convert elapsed seconds to rounded hours, preserving None.""" + if seconds is None: + return None + return round(seconds / 3600.0, 2) - heater_power: int | None = None - jet3_power: int | None = None - pump_blower_current: int | None = None - small_loads_current: int | None = None - heater_current: int | None = None - if debug_words is not None: - pump_blower_current = _reconstruct_uint16( - debug_words.l2_volts_word, - debug_words.heater_volts_word, - ) - small_loads_current = _reconstruct_uint16( - debug_words.heater_volts_word, - debug_words.jet3_volts_word, - ) - if status_pairable: - heater_current = _reconstruct_uint16( - debug_words.jet3_volts_word, - status_words.jet1_jet2_blower_current_word, - ) - heater_power = _reconstruct_uint16( - status_words.jet3_current_word, - debug_words.jet1_jet2_blower_power_word, - ) - jet3_power = _reconstruct_uint16( - debug_words.jet1_jet2_blower_power_word, - debug_words.small_loads_power_word, - ) - return _FreshElectrical( - pump_blower_power=pump_blower_power, - heater_power=heater_power, - jet3_power=jet3_power, - pump_blower_current=pump_blower_current, - small_loads_current=small_loads_current, - heater_current=heater_current, - jet3_current=jet3_current, - ) +def _dig(data: dict[str, object], path: tuple[str, ...]) -> object: + """Return nested dict value along ``path``, or ``_MISSING`` if absent.""" + cursor: object = data + for key in path: + if not isinstance(cursor, dict) or key not in cursor: + return _MISSING + cursor = cursor[key] + return cursor def _reconstruct_uint16(low_byte_word: int, high_byte_word: int) -> int: - """Reconstruct a 16-bit register split across two adjacent misaligned words. - - Live load testing shows an alignment bug in the HNA's JSON output where - adjacent 16-bit values are shifted by one byte: ``low_byte_word`` holds the - register's low byte in bits 8..15, and ``high_byte_word`` holds its high - byte in bits 0..7. - """ + """Reconstruct a 16-bit register split across two adjacent misaligned words.""" return ((high_byte_word & 0xFF) << 8) | ((low_byte_word >> 8) & 0xFF) +def _decode_registers( + head: _WordBlock, status: _WordBlock, tail: _WordBlock +) -> dict[str, int]: + """Reconstruct 16-bit registers across the contiguous 10-word API stream.""" + words = (*head, *status, *tail) + return { + name: _reconstruct_uint16(low_word, high_word) + for name, (low_word, high_word) in zip( + _REGISTER_NAMES, itertools.pairwise(words), strict=True + ) + if low_word is not None and high_word is not None + } + + def _decode_runtime_seconds(raw: object) -> int: """Decode a 24-bit runtime counter shifted by 8 bits into signed 32-bit JSON. @@ -1511,161 +1438,33 @@ def _decode_runtime_seconds(raw: object) -> int: return (raw_value & 0xFFFFFFFF) >> 8 -def _iter_jet_sections( - jets_data: dict[str, object], -) -> Iterator[tuple[int, dict[str, object]]]: - """Yield ``(jet_id, jet_data)`` pairs from a ``JET`` section dict.""" - source = ( - jets_data["control"] - if "control" in jets_data and isinstance(jets_data["control"], dict) - else jets_data - ) - for key, value in source.items(): - if key.upper().startswith("JET") and isinstance(value, dict): - try: - jet_id = int(key[3:]) - except ValueError: - continue - yield jet_id, value - - -def _extract_shifted_runtimes(data: dict[str, object]) -> _ShiftedRuntimes: - """Extract decoded runtime counters from /status sections when present.""" - jet1_seconds: int | None = None - uptime_seconds: int | None = None - jet3_seconds: int | None = None - blower_seconds: int | None = None - - heater = data.get("heater") - if isinstance(heater, dict): - heater_status = heater.get("status") - if isinstance(heater_status, dict) and "heaterHours" in heater_status: - jet1_seconds = _decode_runtime_seconds(heater_status["heaterHours"]) - - jets = data.get("JET") - if isinstance(jets, dict): - for jet_id, jet_data in _iter_jet_sections(jets): - status = jet_data.get("status") - if not isinstance(status, dict): - continue - if jet_id == 1 and "jet_1_ON_sec" in status: - uptime_seconds = _decode_runtime_seconds(status["jet_1_ON_sec"]) - elif jet_id == 2 and "jet_2_ON_sec" in status: - jet3_seconds = _decode_runtime_seconds(status["jet_2_ON_sec"]) - elif jet_id == 3 and "jet_3_ON_sec" in status: - blower_seconds = _decode_runtime_seconds(status["jet_3_ON_sec"]) - - return _ShiftedRuntimes( - jet1_seconds=jet1_seconds, - uptime_seconds=uptime_seconds, - jet3_seconds=jet3_seconds, - blower_seconds=blower_seconds, - ) - - -_TEST_DATA_ELECTRICAL_KEYS: tuple[str, ...] = ( - "jet1+jet2+blowerCurrent", - "smallLoadsCurrent", - "heaterCurrent", - "jet3Current", -) - - -def _extract_status_electrical(data: dict[str, object]) -> _StatusElectrical | None: - """Extract a complete 4-word electrical block from /status when present. - - ``_StatusElectrical`` is only updated when ``test_data.status`` carries all - four contiguous words so adjacent bytes are never paired across polls. - """ +def _extract_status_words(data: dict[str, object]) -> _WordBlock | None: + """Extract the 4 contiguous electrical words from /status when complete.""" test_data = data.get("test_data") if not isinstance(test_data, dict): return None test_data_status = test_data.get("status") if not isinstance(test_data_status, dict) or not all( - key in test_data_status for key in _TEST_DATA_ELECTRICAL_KEYS + key in test_data_status for key in _STATUS_ELECTRICAL_KEYS ): return None - - return _StatusElectrical( - jet1_jet2_blower_current_word=int(test_data_status["jet1+jet2+blowerCurrent"]), - small_loads_current_word=int(test_data_status["smallLoadsCurrent"]), - heater_current_word=int(test_data_status["heaterCurrent"]), - jet3_current_word=int(test_data_status["jet3Current"]), - ) - - -_DEBUG_STRING_KEYS: dict[str, str] = { - "heaterError": "heater_error", - "powerFrequency": "power_frequency", - "pressureSwitchStatus": "pressure_switch_status", - "circulationPumpFlowStatus": "circulation_pump_flow_status", - "regulationThermistorTempStatus": "regulation_thermistor_temp_status", - "limitThermistorStatus": "limit_thermistor_status", -} - -_DEBUG_INTEGER_KEYS: tuple[str, ...] = ( - "L1_N_Volts", - "L2_N_Volts", - "Heater_Volts", - "jet3_Volts", - "jet1_jet2_blowerPower", - "smallLoadsPower", - "heaterPower", - "jet3Power", -) - - -def _resolve_gated_metric( - *, - is_active: bool, - was_active: bool, - fresh_value: int | None, - previous_value: int | None, -) -> int | None: - """Resolve an active-gated metric without tearing across asynchronous polls.""" - if not is_active: - return 0 - if fresh_value is not None: - return fresh_value - if was_active: - return previous_value - return None - - -def _decode_synced_diagnostics_fields( - parsed_integers: dict[str, int], -) -> dict[str, object]: - """Extract decoded voltage, clean-cycle, and filter fields from /addDebugData.""" - decoded: dict[str, object] = {} - if "L1_N_Volts" in parsed_integers: - l1_volts_word = parsed_integers["L1_N_Volts"] - decoded["l2_voltage_above_256v"] = bool(l1_volts_word & 0xFF) - if "L2_N_Volts" in parsed_integers: - decoded["jet3_volts"] = _reconstruct_uint16( - l1_volts_word, - parsed_integers["L2_N_Volts"], - ) - if "smallLoadsPower" in parsed_integers: - decoded["daily_clean_cycle"] = (parsed_integers["smallLoadsPower"] >> 8) & 0xFF - if "heaterPower" in parsed_integers: - decoded["filter_1_minutes"] = parsed_integers["heaterPower"] - if "jet3Power" in parsed_integers: - decoded["filter_2_minutes"] = parsed_integers["jet3Power"] - return decoded + return tuple(int(test_data_status[key]) for key in _STATUS_ELECTRICAL_KEYS) def _parse_diagnostics_and_electrical( - data: dict[str, object], existing: Diagnostics | None = None -) -> tuple[Diagnostics, _DebugElectrical | None]: - """Parse /addDebugData into Diagnostics and raw electrical words.""" + data: dict[str, object], + existing: Diagnostics | None = None, + status_words: _WordBlock = _NO_STATUS_WORDS, +) -> tuple[Diagnostics, dict[str, int], bool]: + """Parse /addDebugData into Diagnostics, decoded electrical values, and sync.""" base = existing or Diagnostics() debug_data = data.get("debugData") if not isinstance(debug_data, dict): - return base, None + return base, {}, False debug = debug_data.get("status") if not isinstance(debug, dict) or not debug: - return base, None + return base, {}, False string_fields = { attribute_name: str(debug[json_key]) @@ -1679,28 +1478,34 @@ def _parse_diagnostics_and_electrical( } raw_failure = debug.get("spaFailureState") - has_fault = raw_failure is not None and str(raw_failure) not in ("", "Spa_Ok") - is_synced = ( - has_fault + if not ( + (raw_failure is not None and str(raw_failure) not in ("", "Spa_Ok")) or any(value != "0" for value in string_fields.values()) or any(value != 0 for value in parsed_integers.values()) + ): + return base, {}, False + + registers = _decode_registers( + tuple(parsed_integers.get(key) for key in _DEBUG_HEAD_KEYS), + status_words, + tuple(parsed_integers.get(key) for key in _DEBUG_TAIL_KEYS), ) - if not is_synced: - return base, None kwargs: dict[str, object] = dict(string_fields) if "spaFailureState" in debug: kwargs["spa_failure_state"] = SpaFailureState.build(raw_failure) - kwargs.update(_decode_synced_diagnostics_fields(parsed_integers)) - - debug_words = _DebugElectrical( - l2_volts_word=parsed_integers.get("L2_N_Volts", 0), - heater_volts_word=parsed_integers.get("Heater_Volts", 0), - jet3_volts_word=parsed_integers.get("jet3_Volts", 0), - jet1_jet2_blower_power_word=parsed_integers.get("jet1_jet2_blowerPower", 0), - small_loads_power_word=parsed_integers.get("smallLoadsPower", 0), - ) - return replace(base, **kwargs), debug_words + if (jet3_volts := registers.pop("jet3_volts", None)) is not None: + kwargs["jet3_volts"] = jet3_volts + if "L1_N_Volts" in parsed_integers: + kwargs["l2_voltage_above_256v"] = bool(parsed_integers["L1_N_Volts"] & 0xFF) + if "smallLoadsPower" in parsed_integers: + kwargs["daily_clean_cycle"] = (parsed_integers["smallLoadsPower"] >> 8) & 0xFF + if "heaterPower" in parsed_integers: + kwargs["filter_1_minutes"] = parsed_integers["heaterPower"] + if "jet3Power" in parsed_integers: + kwargs["filter_2_minutes"] = parsed_integers["jet3Power"] + + return replace(base, **kwargs), registers, True class _SectionParser(NamedTuple): diff --git a/tests/__snapshots__/test_models.ambr b/tests/__snapshots__/test_models.ambr index 133631a..5c39726 100644 --- a/tests/__snapshots__/test_models.ambr +++ b/tests/__snapshots__/test_models.ambr @@ -243,275 +243,224 @@ ) # --- # name: TestPowerMetrics.test_reconstructed_load_states[both_jets_high] - tuple( - PowerMetrics( - heater_current=0, - heater_power=0, - jet1_jet2_blower_current=14, - jet1_jet2_blower_power=3870, - jet3_current=0, - jet3_power=0, - small_loads_current=0, - small_loads_power=61, - supported=True, - ), - 3931, + PowerMetrics( + heater_current=0, + heater_power=0, + jet1_jet2_blower_current=14, + jet1_jet2_blower_power=3870, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=61, + supported=True, ) # --- # name: TestPowerMetrics.test_reconstructed_load_states[heater_and_jet1_high] - tuple( - PowerMetrics( - heater_current=15, - heater_power=3903, - jet1_jet2_blower_current=7, - jet1_jet2_blower_power=1806, - jet3_current=0, - jet3_power=0, - small_loads_current=0, - small_loads_power=71, - supported=True, - ), - 5780, + PowerMetrics( + heater_current=15, + heater_power=3903, + jet1_jet2_blower_current=7, + jet1_jet2_blower_power=1806, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=71, + supported=True, ) # --- # name: TestPowerMetrics.test_reconstructed_load_states[heater_only] - tuple( - PowerMetrics( - heater_current=15, - heater_power=3958, - jet1_jet2_blower_current=0, - jet1_jet2_blower_power=0, - jet3_current=0, - jet3_power=0, - small_loads_current=0, - small_loads_power=63, - supported=True, - ), - 4021, + PowerMetrics( + heater_current=15, + heater_power=3958, + jet1_jet2_blower_current=0, + jet1_jet2_blower_power=0, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=63, + supported=True, ) # --- # name: TestPowerMetrics.test_reconstructed_load_states[idle_synced] - tuple( - PowerMetrics( - heater_current=0, - heater_power=0, - jet1_jet2_blower_current=0, - jet1_jet2_blower_power=0, - jet3_current=0, - jet3_power=0, - small_loads_current=0, - small_loads_power=63, - supported=True, - ), - 63, + PowerMetrics( + heater_current=0, + heater_power=0, + jet1_jet2_blower_current=0, + jet1_jet2_blower_power=0, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=63, + supported=True, ) # --- # name: TestPowerMetrics.test_reconstructed_load_states[jet1_low] - tuple( - PowerMetrics( - heater_current=0, - heater_power=0, - jet1_jet2_blower_current=1, - jet1_jet2_blower_power=520, - jet3_current=0, - jet3_power=0, - small_loads_current=0, - small_loads_power=72, - supported=True, - ), - 592, + PowerMetrics( + heater_current=0, + heater_power=0, + jet1_jet2_blower_current=1, + jet1_jet2_blower_power=520, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=72, + supported=True, ) # --- # name: TestPowerMetrics.test_reconstructed_load_states[jet3_active] - tuple( - PowerMetrics( - heater_current=0, - heater_power=0, - jet1_jet2_blower_current=0, - jet1_jet2_blower_power=0, - jet3_current=8, - jet3_power=1992, - small_loads_current=0, - small_loads_power=70, - supported=True, - ), - 2062, + PowerMetrics( + heater_current=0, + heater_power=0, + jet1_jet2_blower_current=0, + jet1_jet2_blower_power=0, + jet3_current=8, + jet3_power=1992, + small_loads_current=0, + small_loads_power=70, + supported=True, ) # --- # name: TestPowerMetrics.test_status_only_power_metrics[empty] - tuple( - PowerMetrics( - heater_current=None, - heater_power=None, - jet1_jet2_blower_current=None, - jet1_jet2_blower_power=None, - jet3_current=None, - jet3_power=None, - small_loads_current=None, - small_loads_power=None, - supported=False, - ), - None, + PowerMetrics( + heater_current=None, + heater_power=None, + jet1_jet2_blower_current=None, + jet1_jet2_blower_power=None, + jet3_current=None, + jet3_power=None, + small_loads_current=None, + small_loads_power=None, + supported=False, ) # --- # name: TestPowerMetrics.test_status_only_power_metrics[heating_awaiting_debug] - tuple( - PowerMetrics( - heater_current=None, - heater_power=None, - jet1_jet2_blower_current=0, - jet1_jet2_blower_power=0, - jet3_current=0, - jet3_power=0, - small_loads_current=None, - small_loads_power=63, - supported=True, - ), - None, + PowerMetrics( + heater_current=None, + heater_power=None, + jet1_jet2_blower_current=0, + jet1_jet2_blower_power=0, + jet3_current=0, + jet3_power=0, + small_loads_current=None, + small_loads_power=63, + supported=True, ) # --- # name: TestPowerMetrics.test_status_only_power_metrics[idle_awaiting_baseline_debug] - tuple( - PowerMetrics( - heater_current=0, - heater_power=0, - jet1_jet2_blower_current=0, - jet1_jet2_blower_power=0, - jet3_current=0, - jet3_power=0, - small_loads_current=None, - small_loads_power=63, - supported=True, - ), - 63, + PowerMetrics( + heater_current=0, + heater_power=0, + jet1_jet2_blower_current=0, + jet1_jet2_blower_power=0, + jet3_current=0, + jet3_power=0, + small_loads_current=None, + small_loads_power=63, + supported=True, ) # --- # name: TestPowerMetrics.test_status_only_power_metrics[jet1_awaiting_debug] - tuple( - PowerMetrics( - heater_current=0, - heater_power=0, - jet1_jet2_blower_current=None, - jet1_jet2_blower_power=1819, - jet3_current=0, - jet3_power=0, - small_loads_current=None, - small_loads_power=72, - supported=True, - ), - 1891, + PowerMetrics( + heater_current=0, + heater_power=0, + jet1_jet2_blower_current=None, + jet1_jet2_blower_power=1819, + jet3_current=0, + jet3_power=0, + small_loads_current=None, + small_loads_power=72, + supported=True, ) # --- # name: TestPowerMetrics.test_status_only_power_metrics[jet3_awaiting_debug] - tuple( - PowerMetrics( - heater_current=0, - heater_power=0, - jet1_jet2_blower_current=0, - jet1_jet2_blower_power=0, - jet3_current=8, - jet3_power=None, - small_loads_current=None, - small_loads_power=70, - supported=True, - ), - None, + PowerMetrics( + heater_current=0, + heater_power=0, + jet1_jet2_blower_current=0, + jet1_jet2_blower_power=0, + jet3_current=8, + jet3_power=None, + small_loads_current=None, + small_loads_power=70, + supported=True, ) # --- # name: TestPowerMetrics.test_status_only_power_metrics[unsupported_board] - tuple( - PowerMetrics( - heater_current=None, - heater_power=None, - jet1_jet2_blower_current=None, - jet1_jet2_blower_power=None, - jet3_current=None, - jet3_power=None, - small_loads_current=None, - small_loads_power=None, - supported=False, - ), - None, + PowerMetrics( + heater_current=None, + heater_power=None, + jet1_jet2_blower_current=None, + jet1_jet2_blower_power=None, + jet3_current=None, + jet3_power=None, + small_loads_current=None, + small_loads_power=None, + supported=False, ) # --- # name: TestPowerMetrics.test_status_transitions_on_active_spa[all_jets_off_echo_zeroes_pumps] - tuple( - PowerMetrics( - heater_current=14, - heater_power=3792, - jet1_jet2_blower_current=0, - jet1_jet2_blower_power=0, - jet3_current=0, - jet3_power=0, - small_loads_current=0, - small_loads_power=70, - supported=True, - ), - 3862, + PowerMetrics( + heater_current=14, + heater_power=3792, + jet1_jet2_blower_current=0, + jet1_jet2_blower_power=0, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=70, + supported=True, ) # --- # name: TestPowerMetrics.test_status_transitions_on_active_spa[heater_off_echo_zeroes_heater] - tuple( - PowerMetrics( - heater_current=0, - heater_power=0, - jet1_jet2_blower_current=14, - jet1_jet2_blower_power=3870, - jet3_current=0, - jet3_power=0, - small_loads_current=0, - small_loads_power=70, - supported=True, - ), - 3940, + PowerMetrics( + heater_current=0, + heater_power=0, + jet1_jet2_blower_current=14, + jet1_jet2_blower_power=3870, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=70, + supported=True, ) # --- # name: TestPowerMetrics.test_status_transitions_on_active_spa[jet_speed_change_echo_invalidates_pumps] - tuple( - PowerMetrics( - heater_current=14, - heater_power=3792, - jet1_jet2_blower_current=None, - jet1_jet2_blower_power=None, - jet3_current=0, - jet3_power=0, - small_loads_current=0, - small_loads_power=70, - supported=True, - ), - None, + PowerMetrics( + heater_current=14, + heater_power=3792, + jet1_jet2_blower_current=None, + jet1_jet2_blower_power=None, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=70, + supported=True, ) # --- # name: TestPowerMetrics.test_status_transitions_on_active_spa[standalone_heater_current_ignored] - tuple( - PowerMetrics( - heater_current=14, - heater_power=3792, - jet1_jet2_blower_current=14, - jet1_jet2_blower_power=3870, - jet3_current=0, - jet3_power=0, - small_loads_current=0, - small_loads_power=70, - supported=True, - ), - 7732, + PowerMetrics( + heater_current=14, + heater_power=3792, + jet1_jet2_blower_current=14, + jet1_jet2_blower_power=3870, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=70, + supported=True, ) # --- # name: TestPowerMetrics.test_status_transitions_on_active_spa[unpaired_status_poll_preserves_heater_without_tearing] - tuple( - PowerMetrics( - heater_current=14, - heater_power=3792, - jet1_jet2_blower_current=None, - jet1_jet2_blower_power=8, - jet3_current=0, - jet3_power=0, - small_loads_current=0, - small_loads_power=74, - supported=True, - ), - 3874, + PowerMetrics( + heater_current=14, + heater_power=3792, + jet1_jet2_blower_current=None, + jet1_jet2_blower_power=8, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=74, + supported=True, ) # --- # name: TestSpa.test_full_status_parsing @@ -728,6 +677,26 @@ ), ) # --- +# name: TestSpa.test_shifted_runtime_routing[pre_sync_all_zero] + tuple( + None, + None, + None, + None, + None, + None, + ) +# --- +# name: TestSpa.test_shifted_runtime_routing[synced_with_signed_overflow] + tuple( + 11520034, + 3200.01, + 236234, + None, + 3600, + 1800, + ) +# --- # name: TestSpaInfo.test_from_dict SpaInfo( brand=, diff --git a/tests/test_hotspring.py b/tests/test_hotspring.py index 22a94d6..edbf9aa 100644 --- a/tests/test_hotspring.py +++ b/tests/test_hotspring.py @@ -81,7 +81,6 @@ def _add_update_mocks( # noqa: PLR0913 startup_fixture: str = "startup.json", connect_payload: str | None = None, spamodel_status: int = 200, - debug_status: int | None = 200, debug_response: Response | None = None, ) -> None: """Add mock responses for a full update() call.""" @@ -115,17 +114,12 @@ def _add_update_mocks( # noqa: PLR0913 HTTPMethod.GET, _json_response("spamodel.json", status=spamodel_status), ) - if debug_response is not None: - aresponses.add(host, Endpoint.DEBUG_DATA, HTTPMethod.GET, debug_response) - elif debug_status is not None and ( - status_payload is not None or status_fixture == "status.json" - ): - aresponses.add( - host, - Endpoint.DEBUG_DATA, - HTTPMethod.GET, - _json_response("debug_data.json", status=debug_status), - ) + aresponses.add( + host, + Endpoint.DEBUG_DATA, + HTTPMethod.GET, + debug_response or _json_response("debug_data.json"), + ) class TestUpdate: @@ -640,7 +634,6 @@ async def test_update_skips_debug_data_when_not_needed( aresponses, status_payload=status, connect_payload=connect_payload, - debug_status=None, ) async with aiohttp.ClientSession() as session: @@ -653,37 +646,6 @@ async def test_update_skips_debug_data_when_not_needed( entry.request.path for entry in aresponses.history ] - async def test_routine_idle_poll_skips_debug_data_after_baseline( - self, aresponses: ResponsesMockServer - ) -> None: - """Test idle update() fetches /addDebugData once and skips further polls.""" - idle_status = json.loads(_load("status.json")) - idle_status["heater"]["status"]["heater"] = "off" - idle_status["JET"]["JET1"]["status"]["speed"] = "off" - - _add_update_mocks(aresponses, status_payload=idle_status) - aresponses.add( - "192.168.1.100", Endpoint.STATUS, HTTPMethod.GET, _raw_json(idle_status) - ) - aresponses.add( - "192.168.1.100", - Endpoint.SPA_CONNECT_STATUS, - HTTPMethod.GET, - _json_response("spa_connect_status.json"), - ) - - async with aiohttp.ClientSession() as session: - client = HotSpring(host="192.168.1.100", session=session) - spa = await client.update() - assert spa.power.small_loads_current == 0 - spa = await client.update() - - assert spa.power.small_loads_current == 0 - assert spa.power.total_power == 75 - assert [entry.request.path for entry in aresponses.history].count( - Endpoint.DEBUG_DATA - ) == 1 - @pytest.mark.parametrize( "debug_response", [ @@ -703,44 +665,38 @@ async def test_update_debug_data_failure_is_non_critical( client = HotSpring(host="192.168.1.100", session=session) spa = await client.update() - # pylint: disable=protected-access - assert client._identity_loaded is True assert spa.power.supported is True assert spa.power.small_loads_power == 75 assert spa.power.heater_power is None @pytest.mark.parametrize( - ( - "heater_state", - "jet1_speed", - "expected_heater_power", - "expected_pump_current", - ), + ("heater_state", "jet1_speed", "expected_debug_calls", "expected_values"), [ - pytest.param("on", "off", 3584, 0, id="heater_on"), - pytest.param("off", "highSpeed", 0, 15, id="jet1_high_heater_off"), + pytest.param("off", "off", 1, (0, 0), id="idle_skips_after_baseline"), + pytest.param("on", "off", 2, (3584, 0), id="heater_on"), + pytest.param("off", "highSpeed", 2, (0, 15), id="jet1_high_heater_off"), ], ) - async def test_routine_poll_fetches_debug_data_when_load_active( + async def test_routine_poll_debug_data_behavior( self, aresponses: ResponsesMockServer, heater_state: str, jet1_speed: str, - expected_heater_power: int, - expected_pump_current: int, + expected_debug_calls: int, + expected_values: tuple[int, int], ) -> None: - """Test routine update() fetches /addDebugData when heater or pump runs.""" + """Test routine poll skips /addDebugData while idle and fetches when active.""" idle_status = json.loads(_load("status.json")) idle_status["heater"]["status"]["heater"] = "off" idle_status["JET"]["JET1"]["status"]["speed"] = "off" - active_status = json.loads(_load("status.json")) - active_status["heater"]["status"]["heater"] = heater_state - active_status["JET"]["JET1"]["status"]["speed"] = jet1_speed + next_status = json.loads(_load("status.json")) + next_status["heater"]["status"]["heater"] = heater_state + next_status["JET"]["JET1"]["status"]["speed"] = jet1_speed _add_update_mocks(aresponses, status_payload=idle_status) aresponses.add( - "192.168.1.100", Endpoint.STATUS, HTTPMethod.GET, _raw_json(active_status) + "192.168.1.100", Endpoint.STATUS, HTTPMethod.GET, _raw_json(next_status) ) aresponses.add( "192.168.1.100", @@ -754,14 +710,19 @@ async def test_routine_poll_fetches_debug_data_when_load_active( HTTPMethod.GET, _json_response("debug_data.json"), ) + async with aiohttp.ClientSession() as session: client = HotSpring(host="192.168.1.100", session=session) await client.update() spa = await client.update() - assert spa.power.heater_power == expected_heater_power - assert spa.power.jet1_jet2_blower_current == expected_pump_current - assert spa.power.total_power == 75 + expected_heater_power + assert ( + spa.power.heater_power, + spa.power.jet1_jet2_blower_current, + ) == expected_values + assert [entry.request.path for entry in aresponses.history].count( + Endpoint.DEBUG_DATA + ) == expected_debug_calls class TestMalformedResponse: diff --git a/tests/test_models.py b/tests/test_models.py index 7d7d5f8..f52ccea 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -30,6 +30,7 @@ Jet, LightZone, LogoLight, + PowerMetrics, Spa, SpaInfo, SpaLock, @@ -655,37 +656,41 @@ def test_from_empty_dict(self) -> None: pytest.param({"debugData": {"status": None}}, id="null_status"), pytest.param({"debugData": {"status": "invalid"}}, id="string_status"), pytest.param({"debugData": {"status": {}}}, id="empty_status"), + pytest.param( + { + "debugData": { + "status": { + "spaFailureState": "Spa_Ok", + **dict.fromkeys( + ( + "heaterError", + "powerFrequency", + "pressureSwitchStatus", + "circulationPumpFlowStatus", + "regulationThermistorTempStatus", + "limitThermistorStatus", + "L1_N_Volts", + "L2_N_Volts", + "Heater_Volts", + "jet3_Volts", + "jet1_jet2_blowerPower", + "smallLoadsPower", + "heaterPower", + "jet3Power", + ), + "0", + ), + } + } + }, + id="pre_sync_all_zero", + ), ], ) def test_from_invalid_dict(self, invalid_data: dict[str, object]) -> None: - """Test parsing diagnostics with invalid or empty nested objects.""" + """Test parsing diagnostics with invalid, empty, or pre-sync objects.""" assert Diagnostics.from_dict(invalid_data) == Diagnostics() - def test_pre_sync_all_zero_normalizes_decoded_fields_to_none(self) -> None: - """Test real pre-sync /addDebugData (Spa_Ok with all zeros) returns defaults.""" - data: dict[str, object] = { - "debugData": { - "status": { - "spaFailureState": "Spa_Ok", - "heaterError": "0", - "powerFrequency": "0", - "pressureSwitchStatus": "0", - "circulationPumpFlowStatus": "0", - "regulationThermistorTempStatus": "0", - "limitThermistorStatus": "0", - "L1_N_Volts": "0", - "L2_N_Volts": "0", - "Heater_Volts": "0", - "jet3_Volts": "0", - "jet1_jet2_blowerPower": "0", - "smallLoadsPower": "0", - "heaterPower": "0", - "jet3Power": "0", - } - } - } - assert Diagnostics.from_dict(data) == Diagnostics() - def test_decoded_voltage_clean_cycle_and_filter_times(self) -> None: """Test decoding shifted voltage, clean-cycle, and filter fields.""" data: dict[str, object] = { @@ -806,28 +811,24 @@ class TestPowerMetrics: """Tests for reconstructed PowerMetrics across /status and /addDebugData.""" @pytest.mark.parametrize( - ("status_data", "expected_needs_diagnostics"), + "status_data", [ - pytest.param({}, False, id="empty"), - pytest.param(_power_status(heater="on"), False, id="unsupported_board"), + pytest.param({}, id="empty"), + pytest.param(_power_status(heater="on"), id="unsupported_board"), pytest.param( _power_status((0, 0, 16128, 0)), - True, id="idle_awaiting_baseline_debug", ), pytest.param( _power_status((0, 6912, 18439, 0), jet1="highSpeed"), - True, id="jet1_awaiting_debug", ), pytest.param( _power_status((0, 0, 16128, 30208), heater="on"), - True, id="heating_awaiting_debug", ), pytest.param( _power_status((2048, 0, 17920, 0), jet3="highSpeed"), - True, id="jet3_awaiting_debug", ), ], @@ -835,51 +836,42 @@ class TestPowerMetrics: def test_status_only_power_metrics( self, status_data: dict[str, object], - expected_needs_diagnostics: bool, snapshot: SnapshotAssertion, ) -> None: """Test power state derived from /status alone before /addDebugData.""" - spa = Spa(status_data) - assert spa.needs_diagnostics_for_power is expected_needs_diagnostics - assert (spa.power, spa.power.total_power) == snapshot + assert Spa(status_data).power == snapshot @pytest.mark.parametrize( - ("status_data", "debug_data", "expected_needs_diagnostics"), + ("status_data", "debug_data"), [ pytest.param( _power_status((0, 0, 16128, 0)), _power_debug(), - False, id="idle_synced", ), pytest.param( _power_status((0, 2048, 18434, 0), jet1="lowSpeed"), _power_debug(l2_volts=256), - True, id="jet1_low", ), pytest.param( _power_status((0, 7680, 15631, 0), jet1="highSpeed", jet2="highSpeed"), _power_debug(l2_volts=3584), - True, id="both_jets_high", ), pytest.param( _power_status((0, 0, 16128, 30208), heater="on"), _power_debug(jet3_volts=3840, jet1_jet2_blower_power=15), - True, id="heater_only", ), pytest.param( _power_status((0, 3584, 18183, 16128), heater="on", jet1="highSpeed"), _power_debug(l2_volts=1792, jet3_volts=3840, jet1_jet2_blower_power=15), - True, id="heater_and_jet1_high", ), pytest.param( _power_status((2048, 0, 17920, 0), jet3="highSpeed"), _power_debug(jet1_jet2_blower_power=51200, small_loads_power=7), - True, id="jet3_active", ), ], @@ -888,14 +880,80 @@ def test_reconstructed_load_states( self, status_data: dict[str, object], debug_data: dict[str, object], - expected_needs_diagnostics: bool, snapshot: SnapshotAssertion, ) -> None: """Test byte-reconstructed power and current across active spa circuits.""" spa = Spa(status_data) spa.update_diagnostics(debug_data) - assert spa.needs_diagnostics_for_power is expected_needs_diagnostics - assert (spa.power, spa.power.total_power) == snapshot + assert spa.power == snapshot + + @pytest.mark.parametrize( + ("status_data", "debug_data", "expected"), + [ + pytest.param({}, None, False, id="empty"), + pytest.param(_power_status(heater="on"), None, False, id="unsupported"), + pytest.param( + _power_status((0, 0, 16128, 0)), None, True, id="idle_unsynced" + ), + pytest.param( + _power_status((0, 0, 16128, 0)), _power_debug(), False, id="idle_synced" + ), + pytest.param( + _power_status((0, 6912, 18439, 0), jet1="highSpeed"), + _power_debug(l2_volts=1536), + True, + id="jet1_high_synced", + ), + pytest.param( + _power_status((0, 0, 16128, 30208), heater="on"), + _power_debug(jet3_volts=3840, jet1_jet2_blower_power=15), + True, + id="heater_synced", + ), + pytest.param( + _power_status((2048, 0, 17920, 0), jet3="highSpeed"), + _power_debug(jet1_jet2_blower_power=51200, small_loads_power=7), + True, + id="jet3_synced", + ), + ], + ) + def test_needs_diagnostics_for_power( + self, + status_data: dict[str, object], + debug_data: dict[str, object] | None, + expected: bool, + ) -> None: + """Test when /addDebugData polling is required for baseline or active loads.""" + spa = Spa(status_data) + if debug_data is not None: + spa.update_diagnostics(debug_data) + assert spa.needs_diagnostics_for_power is expected + + @pytest.mark.parametrize( + ("power", "expected_total"), + [ + pytest.param( + PowerMetrics( + supported=True, + small_loads_power=63, + jet1_jet2_blower_power=1806, + heater_power=3903, + jet3_power=0, + ), + 5772, + id="all_circuits_known", + ), + pytest.param( + PowerMetrics(supported=True, small_loads_power=63), + None, + id="partial_circuits", + ), + ], + ) + def test_total_power(self, power: PowerMetrics, expected_total: int | None) -> None: + """Test derived total_power across known and incomplete circuit readings.""" + assert power.total_power == expected_total @pytest.mark.parametrize( "status_update", @@ -940,7 +998,7 @@ def test_status_transitions_on_active_spa( _power_debug(l2_volts=3584, jet3_volts=3584, jet1_jet2_blower_power=14) ) spa.update_from_dict(status_update) - assert (spa.power, spa.power.total_power) == snapshot + assert spa.power == snapshot def test_unsynced_debug_data_preserves_active_power_and_diagnostics(self) -> None: """Test empty /addDebugData keeps cached active power and diagnostics.""" @@ -951,24 +1009,46 @@ def test_unsynced_debug_data_preserves_active_power_and_diagnostics(self) -> Non spa.update_diagnostics({}) assert (spa.power, spa.diagnostics) == expected - def test_heater_echo_before_status_prevents_stale_debug_pairing(self) -> None: - """Test heater-on echo without test_data blocks stale low-byte pairing.""" - spa = Spa(_power_status((0, 0, 16128, 0), heater="off")) - spa.update_from_dict({"heater": {"status": {"heater": "on"}}}) - spa.update_diagnostics(_power_debug(jet3_volts=3840, jet1_jet2_blower_power=15)) - - assert spa.power.small_loads_current == 0 - assert spa.power.heater_power is None - assert spa.power.heater_current is None - - def test_consecutive_debug_updates_do_not_repair_stale_status(self) -> None: - """Test repeat /addDebugData calls without /status preserve heater power.""" - spa = Spa(_power_status((0, 0, 16128, 30208), heater="on")) - spa.update_diagnostics(_power_debug(jet3_volts=3840, jet1_jet2_blower_power=14)) - expected = spa.power + @pytest.mark.parametrize( + ("initial_status", "intermediate_update", "debug_updates", "expected"), + [ + pytest.param( + _power_status((0, 0, 16128, 0), heater="off"), + {"heater": {"status": {"heater": "on"}}}, + [_power_debug(jet3_volts=3840, jet1_jet2_blower_power=15)], + (0, None, None), + id="heater_echo_invalidates_pending_status", + ), + pytest.param( + _power_status((0, 0, 16128, 30208), heater="on"), + {}, + [ + _power_debug(jet3_volts=3840, jet1_jet2_blower_power=14), + _power_debug(jet3_volts=3840, jet1_jet2_blower_power=15), + ], + (0, 3702, 15), + id="consecutive_debug_consumes_pending_status", + ), + ], + ) + def test_pending_status_words_not_paired_when_stale( + self, + initial_status: dict[str, object], + intermediate_update: dict[str, object], + debug_updates: list[dict[str, object]], + expected: tuple[int | None, int | None, int | None], + ) -> None: + """Test pending /status words are invalidated on echo and used at most once.""" + spa = Spa(initial_status) + spa.update_from_dict(intermediate_update) + for debug_data in debug_updates: + spa.update_diagnostics(debug_data) - spa.update_diagnostics(_power_debug(jet3_volts=3840, jet1_jet2_blower_power=15)) - assert spa.power == expected + assert ( + spa.power.small_loads_current, + spa.power.heater_power, + spa.power.heater_current, + ) == expected class TestSpaInfo: @@ -1559,31 +1639,19 @@ def test_partial_update_single_jet( assert spa.jets[3].jet_id == 3 @pytest.mark.parametrize( - ("raw_runtimes", "expected_runtimes"), + "raw_runtimes", [ pytest.param( (60475904, -1345838592, 921600, 460800), - (11520034, 3200.01, 236234, None, 3600, 1800), id="synced_with_signed_overflow", ), - pytest.param( - (0, 0, 0, 0), - (None, None, None, None, None, None), - id="pre_sync_all_zero", - ), + pytest.param((0, 0, 0, 0), id="pre_sync_all_zero"), ], ) def test_shifted_runtime_routing( self, raw_runtimes: tuple[int, int, int, int], - expected_runtimes: tuple[ - int | None, - float | None, - int | None, - int | None, - int | None, - int | None, - ], + snapshot: SnapshotAssertion, ) -> None: """Test shifted runtime routing, signed overflow, and pre-sync zeros.""" heater_hours, jet1_raw, jet2_raw, jet3_raw = raw_runtimes @@ -1605,7 +1673,7 @@ def test_shifted_runtime_routing( spa.jets[2].on_seconds, spa.jets[3].on_seconds, spa.blower.on_seconds, - ) == expected_runtimes + ) == snapshot def test_partial_update_versions(self, status_response: dict[str, object]) -> None: """Test updating product versions partially retains cached fields.""" From a61a81687cff81d9a4000285e0dca0159a3981b3 Mon Sep 17 00:00:00 2001 From: Moustachauve <2206577+Moustachauve@users.noreply.github.com> Date: Wed, 18 Nov 2026 23:36:05 -0500 Subject: [PATCH 5/6] Remove unreliable L2 voltage flag and decouple diagnostics parsing The 8-bit indicator extracted from L1_N_Volts reflects an uncalibrated ADC threshold rather than true 256 V mains voltage, leaving it stuck True on a ~248 V residential feed while staying False elsewhere. Dropping Diagnostics.l2_voltage_above_256v avoids surfacing a misleading binary state in Home Assistant. Also simplify power reconstruction and its test suite after review: decouple _parse_diagnostics_and_electrical from /status words so register decoding happens in Spa.update_diagnostics, remove the from_status flag and _MISSING sentinel, assert default PowerMetrics inline rather than snapshotting unsupported boards, and flatten stale-word tests. --- demo/demo_print_data.py | 1 - src/hotspring/models.py | 117 ++++++++-------- tests/__snapshots__/test_hotspring.ambr | 2 - tests/__snapshots__/test_models.ambr | 31 ++--- tests/test_hotspring.py | 2 +- tests/test_models.py | 170 +++++++++--------------- 6 files changed, 125 insertions(+), 198 deletions(-) diff --git a/demo/demo_print_data.py b/demo/demo_print_data.py index 1bb603c..292c62b 100644 --- a/demo/demo_print_data.py +++ b/demo/demo_print_data.py @@ -130,7 +130,6 @@ def print_diagnostics(s: Spa) -> None: print(" DIAGNOSTICS (DEBUG)") print("=" * 20) print(f"Failure State: {s.diagnostics.spa_failure_state.value}") - print(f"L2 >= 256V: {s.diagnostics.l2_voltage_above_256v}") print(f"Jet 3 Volts: {s.diagnostics.jet3_volts} V") print( f"Filter 1 / 2: {s.diagnostics.filter_1_minutes} / {s.diagnostics.filter_2_minutes} min" diff --git a/src/hotspring/models.py b/src/hotspring/models.py index 608ec58..0c54045 100644 --- a/src/hotspring/models.py +++ b/src/hotspring/models.py @@ -35,7 +35,7 @@ type _PumpBlowerState = tuple[JetSpeed, JetSpeed, bool] | None type _CircuitStates = tuple[bool, bool, _PumpBlowerState] -_NO_HEAD_WORDS: _WordBlock = (None, None, None, None) +_NO_HEAD_WORDS: _WordBlock = (None, None, None) _NO_STATUS_WORDS: _WordBlock = (None, None, None, None) _NO_TAIL_WORDS: _WordBlock = (None, None) @@ -175,21 +175,22 @@ def _update_power_from_status( ) -> None: """Update power metrics and pending words from a /status or echo dict.""" status_words = _extract_status_words(data) - if status_words is not None: - self._pending_status_words = status_words - fresh_power = _decode_registers( - _NO_HEAD_WORDS, status_words, _NO_TAIL_WORDS - ) - else: - if self._circuit_states != prior_states: - self._pending_status_words = _NO_STATUS_WORDS - fresh_power = {} - - self._apply_power_words( - fresh_power, - prior_states=prior_states, - from_status=status_words is not None, - ) + if status_words is None: + if self._circuit_states == prior_states: + return + self._pending_status_words = _NO_STATUS_WORDS + self._apply_power_words({}, prior_states=prior_states) + return + + fresh_power = _decode_registers(_NO_HEAD_WORDS, status_words, _NO_TAIL_WORDS) + if fresh_power.get("small_loads_power", 0) <= 0: + self.power = PowerMetrics() + self._pending_status_words = _NO_STATUS_WORDS + return + + self._pending_status_words = status_words + self.power = replace(self.power, supported=True) + self._apply_power_words(fresh_power, prior_states=prior_states) def update_info(self, data: dict[str, object]) -> None: """Update spa identity from /startup and /spamodel responses. @@ -250,14 +251,19 @@ def update_diagnostics(self, data: dict[str, object]) -> None: data: The JSON response from GET /addDebugData. """ - self.diagnostics, fresh_power, synced = _parse_diagnostics_and_electrical( - data, - existing=self.diagnostics, - status_words=self._pending_status_words, + self.diagnostics, debug_integers = _parse_diagnostics_and_electrical( + data, existing=self.diagnostics ) - if synced: - self._pending_status_words = _NO_STATUS_WORDS - self._apply_power_words(fresh_power, prior_states=self._circuit_states) + if debug_integers is None: + return + status_words = self._pending_status_words + self._pending_status_words = _NO_STATUS_WORDS + fresh_power = _decode_registers( + tuple(debug_integers.get(key) for key in _DEBUG_HEAD_KEYS), + status_words, + tuple(debug_integers.get(key) for key in _DEBUG_TAIL_KEYS), + ) + self._apply_power_words(fresh_power, prior_states=self._circuit_states) def update_freshwater_iq(self, data: dict[str, object]) -> None: """Update FreshWater IQ data from /getFWIQData response. @@ -288,7 +294,7 @@ def _apply_shifted_runtimes( decoded = { target: _decode_runtime_seconds(raw) for path, target in _RUNTIME_ROUTES - if (raw := _dig(data, path)) is not _MISSING + if (raw := _dig(data, path)) is not None } if not decoded: return @@ -320,21 +326,12 @@ def _apply_power_words( fresh: dict[str, int], *, prior_states: _CircuitStates, - from_status: bool = False, ) -> None: """Merge freshly decoded power/current words and apply circuit gating.""" - if from_status: - if fresh.get("small_loads_power", 0) <= 0: - self.power = PowerMetrics() - self._pending_status_words = _NO_STATUS_WORDS - return - power = replace(self.power, supported=True, **fresh) - else: - if not self.power.supported: - return - power = replace(self.power, **fresh) + if not self.power.supported: + return - updates: dict[str, int | None] = {} + updates: dict[str, int | None] = dict(fresh) for state, before, fields in zip( self._circuit_states, prior_states, _CIRCUIT_FIELDS, strict=True ): @@ -343,7 +340,7 @@ def _apply_power_words( elif state != before: for field in fields: updates[field] = fresh.get(field) - self.power = replace(power, **updates) + self.power = replace(self.power, **updates) @property def _circuit_states(self) -> _CircuitStates: @@ -1257,6 +1254,7 @@ def total_power(self) -> int | None: ) if None in parts: return None + # Filter narrows int | None for mypy. return sum(part for part in parts if part is not None) @@ -1309,7 +1307,6 @@ class Diagnostics: # pylint: disable=too-many-instance-attributes circulation_pump_flow_status: str = "0" regulation_thermistor_temp_status: str = "0" limit_thermistor_status: str = "0" - l2_voltage_above_256v: bool | None = None jet3_volts: int | None = None daily_clean_cycle: int | None = None filter_1_minutes: int | None = None @@ -1320,7 +1317,7 @@ def from_dict( data: dict[str, object], existing: Diagnostics | None = None ) -> Diagnostics: """Create a Diagnostics instance from a GET /addDebugData response.""" - diagnostics, _, _ = _parse_diagnostics_and_electrical(data, existing=existing) + diagnostics, _ = _parse_diagnostics_and_electrical(data, existing=existing) return diagnostics @@ -1332,7 +1329,6 @@ def from_dict( ) _DEBUG_HEAD_KEYS: tuple[str, ...] = ( - "L1_N_Volts", "L2_N_Volts", "Heater_Volts", "jet3_Volts", @@ -1344,10 +1340,9 @@ def from_dict( ) # HNA JSON is one byte out of phase with the controller register block. -# Together, 4 debug head words + 4 /status test_data words + 2 debug tail words -# form one 10-word sequence whose adjacent pairs yield these 9 registers. +# Together, 3 debug head words + 4 /status test_data words + 2 debug tail words +# form one 9-word sequence whose adjacent pairs yield these 8 registers. _REGISTER_NAMES: tuple[str, ...] = ( - "jet3_volts", "jet1_jet2_blower_current", "small_loads_current", "heater_current", @@ -1382,14 +1377,13 @@ def from_dict( } _DEBUG_INTEGER_KEYS: tuple[str, ...] = ( + "L1_N_Volts", *_DEBUG_HEAD_KEYS, *_DEBUG_TAIL_KEYS, "heaterPower", "jet3Power", ) -_MISSING = object() - def _seconds_to_hours(seconds: int | None) -> float | None: """Convert elapsed seconds to rounded hours, preserving None.""" @@ -1399,11 +1393,11 @@ def _seconds_to_hours(seconds: int | None) -> float | None: def _dig(data: dict[str, object], path: tuple[str, ...]) -> object: - """Return nested dict value along ``path``, or ``_MISSING`` if absent.""" + """Return nested dict value along ``path``, or ``None`` if absent.""" cursor: object = data for key in path: if not isinstance(cursor, dict) or key not in cursor: - return _MISSING + return None cursor = cursor[key] return cursor @@ -1416,7 +1410,7 @@ def _reconstruct_uint16(low_byte_word: int, high_byte_word: int) -> int: def _decode_registers( head: _WordBlock, status: _WordBlock, tail: _WordBlock ) -> dict[str, int]: - """Reconstruct 16-bit registers across the contiguous 10-word API stream.""" + """Reconstruct 16-bit registers across the contiguous 9-word API stream.""" words = (*head, *status, *tail) return { name: _reconstruct_uint16(low_word, high_word) @@ -1454,17 +1448,16 @@ def _extract_status_words(data: dict[str, object]) -> _WordBlock | None: def _parse_diagnostics_and_electrical( data: dict[str, object], existing: Diagnostics | None = None, - status_words: _WordBlock = _NO_STATUS_WORDS, -) -> tuple[Diagnostics, dict[str, int], bool]: - """Parse /addDebugData into Diagnostics, decoded electrical values, and sync.""" +) -> tuple[Diagnostics, dict[str, int] | None]: + """Parse /addDebugData into Diagnostics and raw integer electrical words.""" base = existing or Diagnostics() debug_data = data.get("debugData") if not isinstance(debug_data, dict): - return base, {}, False + return base, None debug = debug_data.get("status") if not isinstance(debug, dict) or not debug: - return base, {}, False + return base, None string_fields = { attribute_name: str(debug[json_key]) @@ -1483,21 +1476,15 @@ def _parse_diagnostics_and_electrical( or any(value != "0" for value in string_fields.values()) or any(value != 0 for value in parsed_integers.values()) ): - return base, {}, False - - registers = _decode_registers( - tuple(parsed_integers.get(key) for key in _DEBUG_HEAD_KEYS), - status_words, - tuple(parsed_integers.get(key) for key in _DEBUG_TAIL_KEYS), - ) + return base, None kwargs: dict[str, object] = dict(string_fields) if "spaFailureState" in debug: kwargs["spa_failure_state"] = SpaFailureState.build(raw_failure) - if (jet3_volts := registers.pop("jet3_volts", None)) is not None: - kwargs["jet3_volts"] = jet3_volts - if "L1_N_Volts" in parsed_integers: - kwargs["l2_voltage_above_256v"] = bool(parsed_integers["L1_N_Volts"] & 0xFF) + if (l1_volts := parsed_integers.get("L1_N_Volts")) is not None and ( + l2_volts := parsed_integers.get("L2_N_Volts") + ) is not None: + kwargs["jet3_volts"] = _reconstruct_uint16(l1_volts, l2_volts) if "smallLoadsPower" in parsed_integers: kwargs["daily_clean_cycle"] = (parsed_integers["smallLoadsPower"] >> 8) & 0xFF if "heaterPower" in parsed_integers: @@ -1505,7 +1492,7 @@ def _parse_diagnostics_and_electrical( if "jet3Power" in parsed_integers: kwargs["filter_2_minutes"] = parsed_integers["jet3Power"] - return replace(base, **kwargs), registers, True + return replace(base, **kwargs), parsed_integers class _SectionParser(NamedTuple): diff --git a/tests/__snapshots__/test_hotspring.ambr b/tests/__snapshots__/test_hotspring.ambr index 890727f..8335d08 100644 --- a/tests/__snapshots__/test_hotspring.ambr +++ b/tests/__snapshots__/test_hotspring.ambr @@ -24,7 +24,6 @@ filter_2_minutes=30, heater_error='0', jet3_volts=0, - l2_voltage_above_256v=False, limit_thermistor_status='0', power_frequency='0', pressure_switch_status='1', @@ -221,7 +220,6 @@ filter_2_minutes=30, heater_error='0', jet3_volts=0, - l2_voltage_above_256v=False, limit_thermistor_status='0', power_frequency='0', pressure_switch_status='1', diff --git a/tests/__snapshots__/test_models.ambr b/tests/__snapshots__/test_models.ambr index 5c39726..c03883e 100644 --- a/tests/__snapshots__/test_models.ambr +++ b/tests/__snapshots__/test_models.ambr @@ -35,7 +35,6 @@ filter_2_minutes=30, heater_error='0', jet3_volts=0, - l2_voltage_above_256v=False, limit_thermistor_status='0', power_frequency='0', pressure_switch_status='1', @@ -320,17 +319,17 @@ supported=True, ) # --- -# name: TestPowerMetrics.test_status_only_power_metrics[empty] +# name: TestPowerMetrics.test_reconstructed_load_states[missing_debug_key] PowerMetrics( - heater_current=None, - heater_power=None, + heater_current=0, + heater_power=0, jet1_jet2_blower_current=None, - jet1_jet2_blower_power=None, - jet3_current=None, - jet3_power=None, + jet1_jet2_blower_power=520, + jet3_current=0, + jet3_power=0, small_loads_current=None, - small_loads_power=None, - supported=False, + small_loads_power=72, + supported=True, ) # --- # name: TestPowerMetrics.test_status_only_power_metrics[heating_awaiting_debug] @@ -385,19 +384,6 @@ supported=True, ) # --- -# name: TestPowerMetrics.test_status_only_power_metrics[unsupported_board] - PowerMetrics( - heater_current=None, - heater_power=None, - jet1_jet2_blower_current=None, - jet1_jet2_blower_power=None, - jet3_current=None, - jet3_power=None, - small_loads_current=None, - small_loads_power=None, - supported=False, - ) -# --- # name: TestPowerMetrics.test_status_transitions_on_active_spa[all_jets_off_echo_zeroes_pumps] PowerMetrics( heater_current=14, @@ -488,7 +474,6 @@ filter_2_minutes=None, heater_error='0', jet3_volts=None, - l2_voltage_above_256v=None, limit_thermistor_status='0', power_frequency='0', pressure_switch_status='0', diff --git a/tests/test_hotspring.py b/tests/test_hotspring.py index edbf9aa..66eba7c 100644 --- a/tests/test_hotspring.py +++ b/tests/test_hotspring.py @@ -737,7 +737,7 @@ class TestMalformedResponse: id="empty_string_number", ), pytest.param( - {"heater": {"status": {"heaterHours": None}}}, + {"test_data": {"status": {"tempOffset": None}}}, TypeError, id="null_number", ), diff --git a/tests/test_models.py b/tests/test_models.py index f52ccea..b3d3cd4 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -287,11 +287,6 @@ def test_from_dict_enabled_on(self, snapshot: SnapshotAssertion) -> None: ) assert blower == snapshot - def test_on_hours_property(self) -> None: - """Test blower on_hours returns None until runtime is populated.""" - assert Blower().on_hours is None - assert Blower(on_seconds=5400).on_hours == 1.5 - class TestLightZone: """Tests for LightZone model parsing.""" @@ -661,25 +656,9 @@ def test_from_empty_dict(self) -> None: "debugData": { "status": { "spaFailureState": "Spa_Ok", - **dict.fromkeys( - ( - "heaterError", - "powerFrequency", - "pressureSwitchStatus", - "circulationPumpFlowStatus", - "regulationThermistorTempStatus", - "limitThermistorStatus", - "L1_N_Volts", - "L2_N_Volts", - "Heater_Volts", - "jet3_Volts", - "jet1_jet2_blowerPower", - "smallLoadsPower", - "heaterPower", - "jet3Power", - ), - "0", - ), + "heaterError": "0", + "L1_N_Volts": "0", + "heaterPower": "0", } } }, @@ -713,7 +692,6 @@ def test_decoded_voltage_clean_cycle_and_filter_times(self) -> None: circulation_pump_flow_status="1", regulation_thermistor_temp_status="1", limit_thermistor_status="1", - l2_voltage_above_256v=True, jet3_volts=240, daily_clean_cycle=1, filter_1_minutes=90, @@ -786,22 +764,25 @@ def _power_status( def _power_debug( *, l2_volts: int = 0, - heater_volts: int = 0, + heater_volts: int | None = 0, jet3_volts: int = 0, jet1_jet2_blower_power: int = 0, small_loads_power: int = 0, ) -> dict[str, object]: """Build a minimal synced /addDebugData payload for power reconstruction tests.""" + words = { + "L2_N_Volts": l2_volts, + "Heater_Volts": heater_volts, + "jet3_Volts": jet3_volts, + "jet1_jet2_blowerPower": jet1_jet2_blower_power, + "smallLoadsPower": small_loads_power, + } return { "debugData": { "status": { "spaFailureState": "Spa_Ok", "pressureSwitchStatus": "1", - "L2_N_Volts": str(l2_volts), - "Heater_Volts": str(heater_volts), - "jet3_Volts": str(jet3_volts), - "jet1_jet2_blowerPower": str(jet1_jet2_blower_power), - "smallLoadsPower": str(small_loads_power), + **{k: str(v) for k, v in words.items() if v is not None}, } } } @@ -815,6 +796,17 @@ class TestPowerMetrics: [ pytest.param({}, id="empty"), pytest.param(_power_status(heater="on"), id="unsupported_board"), + ], + ) + def test_unsupported_status_returns_default_power_metrics( + self, status_data: dict[str, object] + ) -> None: + """Test missing or zeroed electrical status keeps PowerMetrics unsupported.""" + assert Spa(status_data).power == PowerMetrics() + + @pytest.mark.parametrize( + "status_data", + [ pytest.param( _power_status((0, 0, 16128, 0)), id="idle_awaiting_baseline_debug", @@ -874,6 +866,11 @@ def test_status_only_power_metrics( _power_debug(jet1_jet2_blower_power=51200, small_loads_power=7), id="jet3_active", ), + pytest.param( + _power_status((0, 2048, 18434, 0), jet1="lowSpeed"), + _power_debug(l2_volts=256, heater_volts=None), + id="missing_debug_key", + ), ], ) def test_reconstructed_load_states( @@ -890,20 +887,12 @@ def test_reconstructed_load_states( @pytest.mark.parametrize( ("status_data", "debug_data", "expected"), [ - pytest.param({}, None, False, id="empty"), - pytest.param(_power_status(heater="on"), None, False, id="unsupported"), - pytest.param( - _power_status((0, 0, 16128, 0)), None, True, id="idle_unsynced" - ), + pytest.param({}, {}, False, id="empty"), + pytest.param(_power_status(heater="on"), {}, False, id="unsupported"), + pytest.param(_power_status((0, 0, 16128, 0)), {}, True, id="idle_unsynced"), pytest.param( _power_status((0, 0, 16128, 0)), _power_debug(), False, id="idle_synced" ), - pytest.param( - _power_status((0, 6912, 18439, 0), jet1="highSpeed"), - _power_debug(l2_volts=1536), - True, - id="jet1_high_synced", - ), pytest.param( _power_status((0, 0, 16128, 30208), heater="on"), _power_debug(jet3_volts=3840, jet1_jet2_blower_power=15), @@ -911,49 +900,35 @@ def test_reconstructed_load_states( id="heater_synced", ), pytest.param( - _power_status((2048, 0, 17920, 0), jet3="highSpeed"), - _power_debug(jet1_jet2_blower_power=51200, small_loads_power=7), + _power_status((0, 0, 16128, 0)), + _power_debug(heater_volts=None), True, - id="jet3_synced", + id="missing_debug_key", ), ], ) def test_needs_diagnostics_for_power( self, status_data: dict[str, object], - debug_data: dict[str, object] | None, + debug_data: dict[str, object], expected: bool, ) -> None: """Test when /addDebugData polling is required for baseline or active loads.""" spa = Spa(status_data) - if debug_data is not None: - spa.update_diagnostics(debug_data) + spa.update_diagnostics(debug_data) assert spa.needs_diagnostics_for_power is expected - @pytest.mark.parametrize( - ("power", "expected_total"), - [ - pytest.param( - PowerMetrics( - supported=True, - small_loads_power=63, - jet1_jet2_blower_power=1806, - heater_power=3903, - jet3_power=0, - ), - 5772, - id="all_circuits_known", - ), - pytest.param( - PowerMetrics(supported=True, small_loads_power=63), - None, - id="partial_circuits", - ), - ], - ) - def test_total_power(self, power: PowerMetrics, expected_total: int | None) -> None: + def test_total_power(self) -> None: """Test derived total_power across known and incomplete circuit readings.""" - assert power.total_power == expected_total + full = PowerMetrics( + supported=True, + small_loads_power=63, + jet1_jet2_blower_power=1806, + heater_power=3903, + jet3_power=0, + ) + assert full.total_power == 5772 + assert PowerMetrics(supported=True, small_loads_power=63).total_power is None @pytest.mark.parametrize( "status_update", @@ -1009,46 +984,29 @@ def test_unsynced_debug_data_preserves_active_power_and_diagnostics(self) -> Non spa.update_diagnostics({}) assert (spa.power, spa.diagnostics) == expected - @pytest.mark.parametrize( - ("initial_status", "intermediate_update", "debug_updates", "expected"), - [ - pytest.param( - _power_status((0, 0, 16128, 0), heater="off"), - {"heater": {"status": {"heater": "on"}}}, - [_power_debug(jet3_volts=3840, jet1_jet2_blower_power=15)], - (0, None, None), - id="heater_echo_invalidates_pending_status", - ), - pytest.param( - _power_status((0, 0, 16128, 30208), heater="on"), - {}, - [ - _power_debug(jet3_volts=3840, jet1_jet2_blower_power=14), - _power_debug(jet3_volts=3840, jet1_jet2_blower_power=15), - ], - (0, 3702, 15), - id="consecutive_debug_consumes_pending_status", - ), - ], - ) - def test_pending_status_words_not_paired_when_stale( - self, - initial_status: dict[str, object], - intermediate_update: dict[str, object], - debug_updates: list[dict[str, object]], - expected: tuple[int | None, int | None, int | None], - ) -> None: - """Test pending /status words are invalidated on echo and used at most once.""" - spa = Spa(initial_status) - spa.update_from_dict(intermediate_update) - for debug_data in debug_updates: - spa.update_diagnostics(debug_data) + def test_echo_invalidates_pending_status_words(self) -> None: + """Test a circuit-changing echo discards pending /status electrical words.""" + spa = Spa(_power_status((0, 0, 16128, 0), heater="off")) + spa.update_from_dict({"heater": {"status": {"heater": "on"}}}) + spa.update_diagnostics(_power_debug(jet3_volts=3840, jet1_jet2_blower_power=15)) + + assert ( + spa.power.small_loads_current, + spa.power.heater_power, + spa.power.heater_current, + ) == (0, None, None) + + def test_pending_status_words_consumed_on_first_diagnostics(self) -> None: + """Test pending /status electrical words are paired with at most one poll.""" + spa = Spa(_power_status((0, 0, 16128, 30208), heater="on")) + spa.update_diagnostics(_power_debug(jet3_volts=3840, jet1_jet2_blower_power=14)) + spa.update_diagnostics(_power_debug(jet3_volts=3840, jet1_jet2_blower_power=15)) assert ( spa.power.small_loads_current, spa.power.heater_power, spa.power.heater_current, - ) == expected + ) == (0, 3702, 15) class TestSpaInfo: From ff54d867cb168013da2b4b60c98aebce8dbe5b1d Mon Sep 17 00:00:00 2001 From: Moustachauve <2206577+Moustachauve@users.noreply.github.com> Date: Thu, 19 Nov 2026 00:06:51 -0500 Subject: [PATCH 6/6] Apply final test coverage and indexing cleanups Remove the redundant dict default on small_loads_power after full /status decoding, and add test cases covering Blower.on_hours, incomplete test_data.status payloads, and parametrized total_power cases per reviewer feedback. --- src/hotspring/models.py | 2 +- tests/__snapshots__/test_models.ambr | 15 +++++++++ tests/test_models.py | 46 ++++++++++++++++++++++------ 3 files changed, 52 insertions(+), 11 deletions(-) diff --git a/src/hotspring/models.py b/src/hotspring/models.py index 0c54045..e5d5e5f 100644 --- a/src/hotspring/models.py +++ b/src/hotspring/models.py @@ -183,7 +183,7 @@ def _update_power_from_status( return fresh_power = _decode_registers(_NO_HEAD_WORDS, status_words, _NO_TAIL_WORDS) - if fresh_power.get("small_loads_power", 0) <= 0: + if fresh_power["small_loads_power"] <= 0: self.power = PowerMetrics() self._pending_status_words = _NO_STATUS_WORDS return diff --git a/tests/__snapshots__/test_models.ambr b/tests/__snapshots__/test_models.ambr index c03883e..66fa4cf 100644 --- a/tests/__snapshots__/test_models.ambr +++ b/tests/__snapshots__/test_models.ambr @@ -410,6 +410,19 @@ supported=True, ) # --- +# name: TestPowerMetrics.test_status_transitions_on_active_spa[incomplete_test_data_status_ignored] + PowerMetrics( + heater_current=14, + heater_power=3792, + jet1_jet2_blower_current=14, + jet1_jet2_blower_power=3870, + jet3_current=0, + jet3_power=0, + small_loads_current=0, + small_loads_power=70, + supported=True, + ) +# --- # name: TestPowerMetrics.test_status_transitions_on_active_spa[jet_speed_change_echo_invalidates_pumps] PowerMetrics( heater_current=14, @@ -670,6 +683,7 @@ None, None, None, + None, ) # --- # name: TestSpa.test_shifted_runtime_routing[synced_with_signed_overflow] @@ -680,6 +694,7 @@ None, 3600, 1800, + 0.5, ) # --- # name: TestSpaInfo.test_from_dict diff --git a/tests/test_models.py b/tests/test_models.py index b3d3cd4..356d1a7 100644 --- a/tests/test_models.py +++ b/tests/test_models.py @@ -918,17 +918,30 @@ def test_needs_diagnostics_for_power( spa.update_diagnostics(debug_data) assert spa.needs_diagnostics_for_power is expected - def test_total_power(self) -> None: + @pytest.mark.parametrize( + ("power", "expected_total"), + [ + pytest.param( + PowerMetrics( + supported=True, + small_loads_power=63, + jet1_jet2_blower_power=1806, + heater_power=3903, + jet3_power=0, + ), + 5772, + id="all_circuits_known", + ), + pytest.param( + PowerMetrics(supported=True, small_loads_power=63), + None, + id="partial_circuits", + ), + ], + ) + def test_total_power(self, power: PowerMetrics, expected_total: int | None) -> None: """Test derived total_power across known and incomplete circuit readings.""" - full = PowerMetrics( - supported=True, - small_loads_power=63, - jet1_jet2_blower_power=1806, - heater_power=3903, - jet3_power=0, - ) - assert full.total_power == 5772 - assert PowerMetrics(supported=True, small_loads_power=63).total_power is None + assert power.total_power == expected_total @pytest.mark.parametrize( "status_update", @@ -953,6 +966,18 @@ def test_total_power(self) -> None: {"heater": {"status": {"heater": "on", "heaterCurrent": 16128}}}, id="standalone_heater_current_ignored", ), + pytest.param( + { + "test_data": { + "status": { + "jet1+jet2+blowerCurrent": 0, + "smallLoadsCurrent": 0, + "heaterCurrent": 16128, + } + } + }, + id="incomplete_test_data_status_ignored", + ), ], ) def test_status_transitions_on_active_spa( @@ -1631,6 +1656,7 @@ def test_shifted_runtime_routing( spa.jets[2].on_seconds, spa.jets[3].on_seconds, spa.blower.on_seconds, + spa.blower.on_hours, ) == snapshot def test_partial_update_versions(self, status_response: dict[str, object]) -> None: