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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-qube-heatpump
-Version: 1.6.2
+Version: 1.7.0
 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.7.0}/pyproject.toml

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

{python_qube_heatpump-1.6.2 → python_qube_heatpump-1.7.0}/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._monotonic_cache: dict[str, float] = {}
 
     async def connect(self) -> bool:
         """Connect to the Modbus server."""
@@ -117,8 +120,54 @@ 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
 
+    @property
+    def monotonic_cache(self) -> dict[str, float]:
+        """Return the monotonic clamping cache.
+
+        Can be used to persist/restore the cache across restarts.
+        """
+        return self._monotonic_cache
+
+    @monotonic_cache.setter
+    def monotonic_cache(self, value: dict[str, float]) -> None:
+        """Set the monotonic clamping cache (e.g. restored from disk)."""
+        self._monotonic_cache = dict(value)
+
+    def clamp_monotonic(self, key: str, value: float | None) -> float | None:
+        """Clamp a value to prevent decreases for total_increasing counters.
+
+        Returns the clamped value. If the new value is lower than the
+        previously seen value for this key, the previous value is returned.
+        None and non-finite values pass through unchanged.
+
+        Args:
+            key: Identifier for this counter (e.g. entity unique_id).
+            value: The current reading.
+
+        Returns:
+            The clamped value, or None if input was None/non-finite.
+        """
+        if value is None or not math.isfinite(value):
+            return value
+        previous = self._monotonic_cache.get(key)
+        if previous is not None and value < previous:
+            return previous
+        self._monotonic_cache[key] = value
+        return value
+
+    _MONOTONIC_KEYS = frozenset({"energy_total_electric", "energy_total_thermic"})
+
+    def _apply_monotonic_clamping(self, state: QubeState) -> None:
+        """Apply monotonic clamping to energy counters in a QubeState."""
+        for key in self._MONOTONIC_KEYS:
+            current = getattr(state, key, None)
+            clamped = self.clamp_monotonic(key, current)
+            if clamped is not current:
+                setattr(state, key, clamped)
+
     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.7.0}/tests/test_client.py

@@ -342,3 +342,96 @@ 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_clamp_monotonic_basic(mock_modbus_client):
+    """Test clamp_monotonic prevents decreases."""
+    client = QubeClient("1.2.3.4", 502)
+
+    # First value establishes baseline
+    assert client.clamp_monotonic("energy", 100.0) == 100.0
+    # Increase passes through
+    assert client.clamp_monotonic("energy", 150.0) == 150.0
+    # Decrease gets clamped to previous
+    assert client.clamp_monotonic("energy", 50.0) == 150.0
+    # Recovery passes through
+    assert client.clamp_monotonic("energy", 160.0) == 160.0
+
+
+@pytest.mark.asyncio
+async def test_clamp_monotonic_none_and_nan(mock_modbus_client):
+    """Test clamp_monotonic passes through None and NaN."""
+    client = QubeClient("1.2.3.4", 502)
+
+    # None passes through
+    assert client.clamp_monotonic("energy", None) is None
+
+    # Establish baseline
+    assert client.clamp_monotonic("energy", 100.0) == 100.0
+
+    # None doesn't update cache
+    assert client.clamp_monotonic("energy", None) is None
+    assert client.monotonic_cache["energy"] == 100.0
+
+    # NaN doesn't update cache
+    result = client.clamp_monotonic("energy", float("nan"))
+    assert result != result  # NaN != NaN
+    assert client.monotonic_cache["energy"] == 100.0
+
+
+@pytest.mark.asyncio
+async def test_clamp_monotonic_independent_keys(mock_modbus_client):
+    """Test clamp_monotonic tracks keys independently."""
+    client = QubeClient("1.2.3.4", 502)
+
+    client.clamp_monotonic("electric", 100.0)
+    client.clamp_monotonic("thermic", 200.0)
+
+    # Decrease in one doesn't affect the other
+    assert client.clamp_monotonic("electric", 50.0) == 100.0
+    assert client.clamp_monotonic("thermic", 250.0) == 250.0
+
+
+@pytest.mark.asyncio
+async def test_monotonic_cache_property(mock_modbus_client):
+    """Test monotonic_cache can be get/set for persistence."""
+    client = QubeClient("1.2.3.4", 502)
+
+    # Cache starts empty
+    assert client.monotonic_cache == {}
+
+    # Set cache (e.g. restored from disk)
+    client.monotonic_cache = {"energy": 100.0, "thermic": 200.0}
+    assert client.monotonic_cache == {"energy": 100.0, "thermic": 200.0}
+
+    # Clamping uses the restored cache
+    assert client.clamp_monotonic("energy", 50.0) == 100.0
+    assert client.clamp_monotonic("thermic", 250.0) == 250.0
+
+    # Setting cache makes a copy
+    original = {"energy": 300.0}
+    client.monotonic_cache = original
+    original["energy"] = 999.0
+    assert client.monotonic_cache["energy"] == 300.0
+
+
+@pytest.mark.asyncio
+async def test_get_all_data_applies_clamping(mock_modbus_client):
+    """Test get_all_data uses clamp_monotonic for energy counters."""
+    client = QubeClient("1.2.3.4", 502)
+    mock_instance = mock_modbus_client.return_value
+    client._client = mock_instance
+    client._connected = True
+
+    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)
+
+    state = await client.get_all_data()
+    assert state is not None
+    # Energy values stored in cache
+    assert client.monotonic_cache.get("energy_total_electric") == 0.0
+    assert client.monotonic_cache.get("energy_total_thermic") == 0.0