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

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

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

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

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

@@ -33,7 +33,7 @@ class QubeClient:
         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] = {}
+        self._monotonic_cache: dict[str, float] = {}
 
     async def connect(self) -> bool:
         """Connect to the Modbus server."""
@@ -123,24 +123,50 @@ class QubeClient:
         self._apply_monotonic_clamping(state)
         return state
 
-    _MONOTONIC_KEYS = frozenset({"energy_total_electric", "energy_total_thermic"})
+    @property
+    def monotonic_cache(self) -> dict[str, float]:
+        """Return the monotonic clamping cache.
 
-    def _apply_monotonic_clamping(self, state: QubeState) -> None:
-        """Prevent total_increasing counters from reporting decreased values.
+        Can be used to persist/restore the cache across restarts.
+        """
+        return self._monotonic_cache
 
-        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.
+    @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)
-            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
+            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.3 → python_qube_heatpump-1.7.0}/tests/test_client.py

@@ -345,123 +345,93 @@ async def test_get_all_data_auto_reconnects(mock_modbus_client):
 
 
 @pytest.mark.asyncio
-async def test_monotonic_clamping_prevents_decrease(mock_modbus_client):
-    """Test energy counters are clamped when they decrease."""
+async def test_clamp_monotonic_basic(mock_modbus_client):
+    """Test clamp_monotonic prevents decreases."""
     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
+    # 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_monotonic_clamping_unit(mock_modbus_client):
-    """Test _apply_monotonic_clamping directly."""
-    from python_qube_heatpump.models import QubeState
-
+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)
 
-    # 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
+    # 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_monotonic_clamping_skips_none(mock_modbus_client):
-    """Test clamping skips None values."""
-    from python_qube_heatpump.models import QubeState
 
+@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)
 
-    # Establish baseline
-    state1 = QubeState()
-    state1.energy_total_electric = 100.0
-    state1.energy_total_thermic = 200.0
-    client._apply_monotonic_clamping(state1)
+    client.clamp_monotonic("electric", 100.0)
+    client.clamp_monotonic("thermic", 200.0)
 
-    # 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
+    # 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_clamping_skips_nan(mock_modbus_client):
-    """Test clamping skips NaN values."""
-    from python_qube_heatpump.models import QubeState
+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
 
-    # 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
+    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