python-qube-heatpump 1.6.2__tar.gz → 1.6.3__tar.gz

{python_qube_heatpump-1.6.2 → python_qube_heatpump-1.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-qube-heatpump
-Version: 1.6.2
+Version: 1.6.3
 Summary: Async Modbus client for Qube Heat Pumps
 Project-URL: Homepage, https://github.com/MattieGit/python-qube-heatpump
 Project-URL: Bug Tracker, https://github.com/MattieGit/python-qube-heatpump/issues

{python_qube_heatpump-1.6.2 → python_qube_heatpump-1.6.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "python-qube-heatpump"
-version = "1.6.2"
+version = "1.6.3"
 authors = [
   { name="MattieGit", email="6250046+MattieGit@users.noreply.github.com" },
 ]

{python_qube_heatpump-1.6.2 → python_qube_heatpump-1.6.3}/src/python_qube_heatpump/client.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import logging
+import math
 import struct
 import time
 from typing import Any
@@ -31,6 +32,8 @@ class QubeClient:
         self._backoff_seconds: float = 0.0
         self._backoff_max: float = 60.0
         self._next_connect_at: float = 0.0
+        # Monotonic clamping for total_increasing counters
+        self._previous_values: dict[str, float] = {}
 
     async def connect(self) -> bool:
         """Connect to the Modbus server."""
@@ -117,8 +120,28 @@ class QubeClient:
         state.setpoint_room_cool_night = await _read(const.SETPOINT_COOL_NIGHT)
         state.setpoint_dhw = await _read(const.USER_DHW_SETPOINT)
 
+        self._apply_monotonic_clamping(state)
         return state
 
+    _MONOTONIC_KEYS = frozenset({"energy_total_electric", "energy_total_thermic"})
+
+    def _apply_monotonic_clamping(self, state: QubeState) -> None:
+        """Prevent total_increasing counters from reporting decreased values.
+
+        Communication glitches can cause energy counters to temporarily read
+        lower than their actual value. This clamps them to the last known
+        good value to avoid corrupting long-term statistics.
+        """
+        for key in self._MONOTONIC_KEYS:
+            current = getattr(state, key, None)
+            if current is None or not math.isfinite(current):
+                continue
+            previous = self._previous_values.get(key)
+            if previous is not None and current < previous:
+                setattr(state, key, previous)
+            else:
+                self._previous_values[key] = current
+
     async def async_get_software_version(self) -> str | None:
         """Read the software version from the device.
 

{python_qube_heatpump-1.6.2 → python_qube_heatpump-1.6.3}/tests/test_client.py

@@ -342,3 +342,126 @@ async def test_get_all_data_auto_reconnects(mock_modbus_client):
     assert state is not None
     # Verify connect was called (auto-reconnect happened)
     mock_instance.connect.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_monotonic_clamping_prevents_decrease(mock_modbus_client):
+    """Test energy counters are clamped when they decrease."""
+    client = QubeClient("1.2.3.4", 502)
+    mock_instance = mock_modbus_client.return_value
+    client._client = mock_instance
+    client._connected = True
+
+    # Helper to create mock responses returning specific float values
+    def make_resp(value_pairs):
+        """Create mock responses for a sequence of register reads."""
+        import struct as s
+        responses = []
+        for val in value_pairs:
+            resp = MagicMock()
+            resp.isError.return_value = False
+            if val is not None:
+                packed = s.pack(">f", float(val))
+                int_val = s.unpack(">I", packed)[0]
+                resp.registers = [(int_val >> 16) & 0xFFFF, int_val & 0xFFFF]
+            else:
+                resp.registers = [0, 0]
+            responses.append(resp)
+        return responses
+
+    # First call: set initial energy values (100.0 electric, 200.0 thermic)
+    mock_resp = MagicMock()
+    mock_resp.isError.return_value = False
+    mock_resp.registers = [0, 0]
+    mock_instance.read_input_registers = AsyncMock(return_value=mock_resp)
+    mock_instance.read_holding_registers = AsyncMock(return_value=mock_resp)
+
+    state1 = await client.get_all_data()
+    assert state1 is not None
+    # Both should be 0.0 initially (all zeros)
+    assert state1.energy_total_electric == 0.0
+    assert state1.energy_total_thermic == 0.0
+    # Previous values should be stored
+    assert client._previous_values.get("energy_total_electric") == 0.0
+    assert client._previous_values.get("energy_total_thermic") == 0.0
+
+
+@pytest.mark.asyncio
+async def test_monotonic_clamping_unit(mock_modbus_client):
+    """Test _apply_monotonic_clamping directly."""
+    from python_qube_heatpump.models import QubeState
+
+    client = QubeClient("1.2.3.4", 502)
+
+    # First reading: establish baseline
+    state1 = QubeState()
+    state1.energy_total_electric = 100.0
+    state1.energy_total_thermic = 200.0
+    client._apply_monotonic_clamping(state1)
+    assert state1.energy_total_electric == 100.0
+    assert state1.energy_total_thermic == 200.0
+
+    # Second reading: values increase — should pass through
+    state2 = QubeState()
+    state2.energy_total_electric = 150.0
+    state2.energy_total_thermic = 250.0
+    client._apply_monotonic_clamping(state2)
+    assert state2.energy_total_electric == 150.0
+    assert state2.energy_total_thermic == 250.0
+
+    # Third reading: values decrease (glitch) — should clamp to previous
+    state3 = QubeState()
+    state3.energy_total_electric = 50.0  # Glitch: dropped below 150
+    state3.energy_total_thermic = 100.0  # Glitch: dropped below 250
+    client._apply_monotonic_clamping(state3)
+    assert state3.energy_total_electric == 150.0  # Clamped
+    assert state3.energy_total_thermic == 250.0  # Clamped
+
+    # Fourth reading: values recover — should pass through
+    state4 = QubeState()
+    state4.energy_total_electric = 160.0
+    state4.energy_total_thermic = 260.0
+    client._apply_monotonic_clamping(state4)
+    assert state4.energy_total_electric == 160.0
+    assert state4.energy_total_thermic == 260.0
+
+
+@pytest.mark.asyncio
+async def test_monotonic_clamping_skips_none(mock_modbus_client):
+    """Test clamping skips None values."""
+    from python_qube_heatpump.models import QubeState
+
+    client = QubeClient("1.2.3.4", 502)
+
+    # Establish baseline
+    state1 = QubeState()
+    state1.energy_total_electric = 100.0
+    state1.energy_total_thermic = 200.0
+    client._apply_monotonic_clamping(state1)
+
+    # None value should be skipped (not clamped, not stored)
+    state2 = QubeState()
+    state2.energy_total_electric = None
+    state2.energy_total_thermic = 200.0
+    client._apply_monotonic_clamping(state2)
+    assert state2.energy_total_electric is None  # Unchanged
+    assert client._previous_values["energy_total_electric"] == 100.0  # Not updated
+
+
+@pytest.mark.asyncio
+async def test_monotonic_clamping_skips_nan(mock_modbus_client):
+    """Test clamping skips NaN values."""
+    from python_qube_heatpump.models import QubeState
+
+    client = QubeClient("1.2.3.4", 502)
+
+    # Establish baseline
+    state1 = QubeState()
+    state1.energy_total_electric = 100.0
+    client._apply_monotonic_clamping(state1)
+
+    # NaN should be skipped
+    state2 = QubeState()
+    state2.energy_total_electric = float("nan")
+    client._apply_monotonic_clamping(state2)
+    assert client._previous_values["energy_total_electric"] == 100.0