python-qube-heatpump 1.12.0__tar.gz → 1.13.0__tar.gz

{python_qube_heatpump-1.12.0 → python_qube_heatpump-1.13.0}/PKG-INFO

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

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

{python_qube_heatpump-1.12.0 → python_qube_heatpump-1.13.0}/src/python_qube_heatpump/client.py

@@ -18,6 +18,112 @@ from .models import QubeState
 
 _LOGGER = logging.getLogger(__name__)
 
+# Entities read by get_all_data() (used by the official HA core integration).
+# These mirror the register definitions in `const` exactly (address, scale,
+# offset) so batching cannot change any value get_all_data() returns.
+# Note: some of these intentionally differ from the corresponding entries in
+# entities/sensors.py (e.g. compressor_speed has a x60 RPM scale here but not
+# there; cop_calc is unrounded here but rounded to 1 decimal there) — reusing
+# SENSORS would silently change get_all_data()'s output, so a dedicated table
+# is kept instead.
+# Format: (key, address, input_type, data_type, scale, offset)
+_CORE_STATE_REGISTERS: tuple[
+    tuple[str, int, InputType, DataType, float | None, float | None], ...
+] = (
+    ("temp_supply", 20, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    ("temp_return", 22, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    ("temp_source_in", 24, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    ("temp_source_out", 26, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    ("temp_room", 28, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    ("temp_dhw", 30, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    ("temp_outside", 32, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    ("power_thermic", 36, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    ("power_electric", 61, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    (
+        "energy_total_electric",
+        69,
+        InputType.INPUT_REGISTER,
+        DataType.FLOAT32,
+        None,
+        None,
+    ),
+    (
+        "energy_total_thermic",
+        71,
+        InputType.INPUT_REGISTER,
+        DataType.FLOAT32,
+        None,
+        None,
+    ),
+    ("cop_calc", 34, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    ("status_code", 38, InputType.INPUT_REGISTER, DataType.UINT16, None, None),
+    ("compressor_speed", 45, InputType.INPUT_REGISTER, DataType.FLOAT32, 60, None),
+    ("flow_rate", 18, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+    (
+        "setpoint_room_heat_day",
+        27,
+        InputType.HOLDING_REGISTER,
+        DataType.FLOAT32,
+        None,
+        None,
+    ),
+    (
+        "setpoint_room_heat_night",
+        29,
+        InputType.HOLDING_REGISTER,
+        DataType.FLOAT32,
+        None,
+        None,
+    ),
+    (
+        "setpoint_room_cool_day",
+        31,
+        InputType.HOLDING_REGISTER,
+        DataType.FLOAT32,
+        None,
+        None,
+    ),
+    (
+        "setpoint_room_cool_night",
+        33,
+        InputType.HOLDING_REGISTER,
+        DataType.FLOAT32,
+        None,
+        None,
+    ),
+    ("setpoint_dhw", 173, InputType.HOLDING_REGISTER, DataType.FLOAT32, None, None),
+    (
+        "usr_pid_heatsetp",
+        101,
+        InputType.HOLDING_REGISTER,
+        DataType.FLOAT32,
+        None,
+        None,
+    ),
+    (
+        "usr_pid_coolsetp",
+        103,
+        InputType.HOLDING_REGISTER,
+        DataType.FLOAT32,
+        None,
+        None,
+    ),
+    ("modbus_roomtemp", 75, InputType.INPUT_REGISTER, DataType.FLOAT32, None, None),
+)
+
+_CORE_STATE_ENTITIES: tuple[EntityDef, ...] = tuple(
+    EntityDef(
+        key=key,
+        name=key,
+        address=address,
+        input_type=input_type,
+        data_type=data_type,
+        scale=scale,
+        offset=offset,
+    )
+    for key, address, input_type, data_type, scale, offset in _CORE_STATE_REGISTERS
+)
+
 
 class QubeClient:
     """Qube Modbus Client."""
@@ -109,53 +215,27 @@ class QubeClient:
 
         state = QubeState()
 
-        # Helper to read and assign
-        async def _read(const_def):
-            return await self.read_value(const_def)
-
-        # Fetch temperature sensors
-        state.temp_supply = await _read(const.TEMP_SUPPLY)
-        state.temp_return = await _read(const.TEMP_RETURN)
-        state.temp_source_in = await _read(const.TEMP_SOURCE_IN)
-        state.temp_source_out = await _read(const.TEMP_SOURCE_OUT)
-        state.temp_room = await _read(const.TEMP_ROOM)
-        state.temp_dhw = await _read(const.TEMP_DHW)
-        state.temp_outside = await _read(const.TEMP_OUTSIDE)
-
-        # Fetch power and energy sensors
-        state.power_thermic = await _read(const.POWER_THERMIC)
-        state.power_electric = await _read(const.POWER_ELECTRIC_CALC)
-        state.energy_total_electric = await _read(const.ENERGY_ELECTRIC_TOTAL)
-        state.energy_total_thermic = await _read(const.ENERGY_THERMIC_TOTAL)
-        state.cop_calc = await _read(const.COP_CALC)
-
-        # Fetch operation sensors
-        state.status_code = await _read(const.STATUS_CODE)
-        state.compressor_speed = await _read(const.COMPRESSOR_SPEED)
-        flow_rate = await _read(const.FLOW_RATE)
+        # Batch-read the core sensor fields plus all binary sensors together.
+        # _plan_blocks groups by input type (input/holding/discrete_input/coil)
+        # regardless of which list an entity came from, so combining both
+        # tables into a single read_entities_batched() call still yields one
+        # handful of block transactions instead of ~59 per-field reads.
+        entities = [*_CORE_STATE_ENTITIES, *BINARY_SENSORS.values()]
+        results = await self.read_entities_batched(entities)
+
+        for ent in _CORE_STATE_ENTITIES:
+            setattr(state, ent.key, results.get(ent.key))
+
+        flow_rate = state.flow_rate
         if flow_rate is not None and flow_rate < 0:
             flow_rate = 0.0
         state.flow_rate = flow_rate
 
-        # Fetch setpoints (holding registers)
-        state.setpoint_room_heat_day = await _read(const.SETPOINT_HEAT_DAY)
-        state.setpoint_room_heat_night = await _read(const.SETPOINT_HEAT_NIGHT)
-        state.setpoint_room_cool_day = await _read(const.SETPOINT_COOL_DAY)
-        state.setpoint_room_cool_night = await _read(const.SETPOINT_COOL_NIGHT)
-        state.setpoint_dhw = await _read(const.USER_DHW_SETPOINT)
-        state.usr_pid_heatsetp = await _read(const.USER_HEAT_SETPOINT)
-        state.usr_pid_coolsetp = await _read(const.USER_COOL_SETPOINT)
-
-        # LinQ thermostat room temperature (optional)
-        state.modbus_roomtemp = await _read(const.TEMP_ROOM_MODBUS)
-
         self._apply_monotonic_clamping(state)
 
-        # Fetch binary sensors
-        binary_data = await self.read_all_binary_sensors()
-        for key, value in binary_data.items():
+        for key in BINARY_SENSORS:
             if hasattr(state, key):
-                setattr(state, key, value)
+                setattr(state, key, results.get(key))
 
         # Compute unified status (status_code + anti-legionella override)
         state.status = const.resolve_status(state.status_code, state.req_antileg_1)
@@ -427,6 +507,17 @@ class QubeClient:
                     )
                 if result.isError():
                     raise OSError(f"Modbus error response for block @{start}")
+                if input_type_str in ("coil", "discrete_input"):
+                    if len(result.bits) < count:
+                        raise OSError(
+                            f"Short bit response for block {input_type_str}@{start} "
+                            f"(got {len(result.bits)}, expected {count})"
+                        )
+                elif len(result.registers) < count:
+                    raise OSError(
+                        f"Short register response for block {input_type_str}@{start} "
+                        f"(got {len(result.registers)}, expected {count})"
+                    )
             except Exception as exc:
                 self._log_read_failure(
                     f"block {input_type_str}@{start} (count {count})", exc

{python_qube_heatpump-1.12.0 → python_qube_heatpump-1.13.0}/tests/test_client.py

@@ -331,12 +331,18 @@ async def test_get_all_data_auto_reconnects(mock_modbus_client):
     client._client = mock_instance
     client._connected = False
 
-    # Mock successful register reads
-    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)
+    # Mock successful register reads. Batched block reads request a
+    # variable number of registers per block, so the mock must honor the
+    # requested `count` (a real Modbus server would too), unlike a fixed
+    # 2-register response.
+    def _resp(address, count=1, **kwargs):
+        resp = MagicMock()
+        resp.isError.return_value = False
+        resp.registers = [0] * count
+        return resp
+
+    mock_instance.read_input_registers = AsyncMock(side_effect=_resp)
+    mock_instance.read_holding_registers = AsyncMock(side_effect=_resp)
 
     state = await client.get_all_data()
     assert state is not None
@@ -424,11 +430,16 @@ async def test_get_all_data_applies_clamping(mock_modbus_client):
     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)
+    # Batched block reads request a variable `count` of registers per
+    # block, so the mock must honor it (a real Modbus server would too).
+    def _resp(address, count=1, **kwargs):
+        resp = MagicMock()
+        resp.isError.return_value = False
+        resp.registers = [0] * count
+        return resp
+
+    mock_instance.read_input_registers = AsyncMock(side_effect=_resp)
+    mock_instance.read_holding_registers = AsyncMock(side_effect=_resp)
 
     state = await client.get_all_data()
     assert state is not None

{python_qube_heatpump-1.12.0 → python_qube_heatpump-1.13.0}/tests/test_client_batching.py

@@ -143,6 +143,41 @@ async def test_batched_block_failure_falls_back_to_individual_reads(
     assert round(results["temp_return"], 1) == 25.0
 
 
+@pytest.mark.asyncio
+async def test_batched_short_successful_response_falls_back_to_individual_reads(
+    mock_modbus_client,
+):
+    """A well-formed but too-short block response degrades gracefully.
+
+    A device can return isError()==False with fewer registers/bits than the
+    requested count (a malformed-but-"successful" response). Previously this
+    slipped past the isError() check and crashed with an uncaught IndexError
+    while decoding, instead of falling back to individual reads like a failed
+    block does. Since get_all_data() is now polled by HA core every 15s via
+    this same batching path, such a response must degrade the same way a
+    failed block does, not raise.
+    """
+    client = QubeClient("1.2.3.4", 502)
+    mock_instance = mock_modbus_client.return_value
+    mock_instance.read_input_registers = AsyncMock(
+        side_effect=[
+            # Block read: isError() is False, but only 2 registers came back
+            # for a block that needs 4 (two float32 entities).
+            _register_response(_float32_regs(24.5)),
+            _register_response(_float32_regs(24.5)),  # individual read
+            _register_response(_float32_regs(25.0)),  # individual read
+        ]
+    )
+    client._client = mock_instance
+
+    entities = [SENSORS["temp_supply"], SENSORS["temp_return"]]
+    results = await client.read_entities_batched(entities)
+
+    assert mock_instance.read_input_registers.call_count == 3
+    assert round(results["temp_supply"], 1) == 24.5
+    assert round(results["temp_return"], 1) == 25.0
+
+
 @pytest.mark.asyncio
 async def test_get_all_entities_uses_batched_reads(mock_modbus_client):
     """get_all_entities reads all entities in a handful of transactions."""
@@ -172,3 +207,43 @@ async def test_get_all_entities_uses_batched_reads(mock_modbus_client):
         + mock_instance.read_holding_registers.call_count
     )
     assert total_calls <= 15
+
+
+@pytest.mark.asyncio
+async def test_get_all_data_uses_batched_reads(mock_modbus_client):
+    """get_all_data (used by HA core, polled every 15s) reads via block reads.
+
+    Previously get_all_data() performed one Modbus transaction per field
+    (~59 transactions: 23 core sensors + 37 binary sensors). It should now
+    use the same batched block-read infrastructure as get_all_entities(),
+    landing in a handful of transactions instead.
+    """
+    client = QubeClient("1.2.3.4", 502)
+    mock_instance = mock_modbus_client.return_value
+
+    def _bits(address, count=1, **kwargs):
+        return _bit_response([False] * count)
+
+    def _regs(address, count=1, **kwargs):
+        return _register_response([0] * count)
+
+    mock_instance.read_coils = AsyncMock(side_effect=_bits)
+    mock_instance.read_discrete_inputs = AsyncMock(side_effect=_bits)
+    mock_instance.read_input_registers = AsyncMock(side_effect=_regs)
+    mock_instance.read_holding_registers = AsyncMock(side_effect=_regs)
+    client._client = mock_instance
+    client._connected = True
+
+    state = await client.get_all_data()
+
+    assert state is not None
+    total_calls = (
+        mock_instance.read_coils.call_count
+        + mock_instance.read_discrete_inputs.call_count
+        + mock_instance.read_input_registers.call_count
+        + mock_instance.read_holding_registers.call_count
+    )
+    # Old per-register/per-entity path made ~59 transactions (23 core
+    # fields + 37 binary sensors). Batched block reads should collapse
+    # this into a handful of transactions.
+    assert total_calls <= 15