python-qube-heatpump 1.2.1__tar.gz → 1.2.2__tar.gz

{python_qube_heatpump-1.2.1 → python_qube_heatpump-1.2.2}/PKG-INFO

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

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

{python_qube_heatpump-1.2.1 → python_qube_heatpump-1.2.2}/src/python_qube_heatpump/client.py

@@ -1,11 +1,10 @@
 """Client for Qube Heat Pump."""
 
 import logging
+import struct
 from typing import Optional
 
 from pymodbus.client import AsyncModbusTcpClient
-from pymodbus.payload import BinaryPayloadDecoder
-from pymodbus.constants import Endian
 
 from . import const
 from .models import QubeState
@@ -80,16 +79,48 @@ class QubeClient:
                 _LOGGER.warning("Error reading address %s", address)
                 return None
 
-            decoder = BinaryPayloadDecoder.fromRegisters(
-                result.registers, byteorder=Endian.Big, wordorder=Endian.Little
-            )
+            regs = result.registers
+            val = 0
+
+            # Manual decoding to avoid pymodbus.payload dependencies
+            # Assuming Little Endian Word Order for 32-bit values [LSW, MSW] per standard Modbus often used
+            # But the original code used Endian.Little WordOrder.
+            # Decoder: byteorder=Endian.Big, wordorder=Endian.Little
+            # Big Endian Bytes: [H, L]
+            # Little Endian Words: [Reg0, Reg1] -> [LSW, MSW]
+            #
+            # Example Float32: 123.456
+            # Reg0 (LSW)
+            # Reg1 (MSW)
+            # Full 32-bit int: (Reg1 << 16) | Reg0
+            # Then pack as >I (Big Endian 32-bit int) and unpack as >f (Big Endian float)?
+            #
+            # Wait, PyModbus BinaryPayloadDecoder.fromRegisters(registers, byteorder=Endian.Big, wordorder=Endian.Little)
+            # ByteOrder Big: Normal network byte order per register.
+            # WordOrder Little: The first register is the least significant word.
+            #
+            # So:
+            # 32-bit value = (regs[1] << 16) | regs[0]
+            # Then interpret that 32-bit integer as a float.
+            # To interpret int bits as float in Python: struct.unpack('!f', struct.pack('!I', int_val))[0]
 
             if data_type == const.DataType.FLOAT32:
-                val = decoder.decode_32bit_float()
+                # Combine 2 registers, Little Endian Word Order
+                int_val = (regs[1] << 16) | regs[0]
+                val = struct.unpack(">f", struct.pack(">I", int_val))[0]
             elif data_type == const.DataType.INT16:
-                val = decoder.decode_16bit_int()
+                val = regs[0]
+                # Signed 16-bit
+                if val > 32767:
+                    val -= 65536
             elif data_type == const.DataType.UINT16:
-                val = decoder.decode_16bit_uint()
+                val = regs[0]
+            elif data_type == const.DataType.UINT32:
+                val = (regs[1] << 16) | regs[0]
+            elif data_type == const.DataType.INT32:
+                val = (regs[1] << 16) | regs[0]
+                if val > 2147483647:
+                    val -= 4294967296
             else:
                 val = 0
 

{python_qube_heatpump-1.2.1 → python_qube_heatpump-1.2.2}/src/python_qube_heatpump/const.py

@@ -16,6 +16,8 @@ class DataType(str, Enum):
     FLOAT32 = "float32"
     INT16 = "int16"
     UINT16 = "uint16"
+    INT32 = "int32"
+    UINT32 = "uint32"
 
 
 # Register definitions (Address, Type, Data Type, Scale, Offset)

python_qube_heatpump-1.2.2/tests/test_client.py

@@ -0,0 +1,73 @@
+"""Test the Qube Heat Pump client."""
+
+from unittest.mock import AsyncMock, MagicMock
+import pytest
+from python_qube_heatpump import QubeClient
+
+
+@pytest.mark.asyncio
+async def test_connect(mock_modbus_client):
+    """Test connection."""
+    client = QubeClient("1.2.3.4", 502)
+    mock_instance = mock_modbus_client.return_value
+    mock_instance.connect.return_value = True
+    mock_instance.connected = False
+    assert await client.connect() is True
+    mock_modbus_client.assert_called_with("1.2.3.4", port=502)
+
+
+@pytest.mark.asyncio
+async def test_read_value(mock_modbus_client):
+    """Test reading values."""
+    client = QubeClient("1.2.3.4", 502)
+    mock_instance = mock_modbus_client.return_value
+    mock_instance.connected = True
+
+    # Mock response for reading holding registers (FLOAT32)
+    # 24.5 = 0x41C40000 -> 16836 (0x41C4), 0 (0x0000) (Big Endian)
+    # Our decoder expects [0, 16836] for Little Endian Word Order?
+    # Logic in client.py: int_val = (regs[1] << 16) | regs[0]
+    # To get 0x41C40000: regs[1]=0x41C4, regs[0]=0x0000
+    mock_resp = MagicMock()
+    mock_resp.isError.return_value = False
+    mock_resp.registers = [0, 16836]
+
+    mock_instance.read_holding_registers = AsyncMock(return_value=mock_resp)
+    client._client = mock_instance
+
+    # Test reading a FLOAT32 holding register
+    # definition = (address, reg_type, data_type, scale, offset)
+    # We use a dummy definition
+    from python_qube_heatpump import const
+
+    definition = (10, const.ModbusType.HOLDING, const.DataType.FLOAT32, None, None)
+
+    result = await client.read_value(definition)
+
+    # Verify result is approximately 24.5
+    assert result is not None
+    assert round(result, 1) == 24.5
+
+    mock_instance.read_holding_registers.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_read_value_int16(mock_modbus_client):
+    """Test reading INT16 value."""
+    client = QubeClient("1.2.3.4", 502)
+    mock_instance = mock_modbus_client.return_value
+
+    # Mock response for -10 (0xFFF6 = 65526)
+    mock_resp = MagicMock()
+    mock_resp.isError.return_value = False
+    mock_resp.registers = [65526]
+
+    mock_instance.read_input_registers = AsyncMock(return_value=mock_resp)
+    client._client = mock_instance
+
+    from python_qube_heatpump import const
+
+    definition = (20, const.ModbusType.INPUT, const.DataType.INT16, None, None)
+
+    result = await client.read_value(definition)
+    assert result == -10

python_qube_heatpump-1.2.1/tests/test_client.py

@@ -1,49 +0,0 @@
-"""Test the Qube Heat Pump client."""
-
-from unittest.mock import AsyncMock, MagicMock
-import pytest
-from python_qube_heatpump import QubeClient
-
-
-@pytest.mark.asyncio
-async def test_connect(mock_modbus_client):
-    """Test connection."""
-    client = QubeClient("1.2.3.4", 502)
-    mock_instance = mock_modbus_client.return_value
-    mock_instance.connect.return_value = True
-    mock_instance.connected = False
-    assert await client.connect() is True
-    mock_modbus_client.assert_called_with("1.2.3.4", port=502)
-
-
-@pytest.mark.asyncio
-async def test_read_registers(mock_modbus_client):
-    """Test reading registers."""
-    client = QubeClient("1.2.3.4", 502)
-    mock_instance = mock_modbus_client.return_value
-    mock_instance.connected = True
-    # Mock response
-    mock_resp = MagicMock()
-    mock_resp.isError.return_value = False
-    mock_resp.registers = [123]
-    # Setup the read_holding_registers method on the mock
-    mock_instance.read_holding_registers = AsyncMock(return_value=mock_resp)
-    # We need to manually set the client on the wrapper if we bypass connect
-    client._client = mock_instance
-    result = await client.read_registers(10, 1)
-    assert result == [123]
-    mock_instance.read_holding_registers.assert_called_once()
-
-
-@pytest.mark.asyncio
-async def test_decode_registers():
-    """Test Register Decoding."""
-    # float32: 24.5 = 0x41C40000 -> 16836, 0 (Big Endian)
-    # struct.unpack('>f', struct.pack('>HH', 16836, 0)) -> 24.5
-    regs = [16836, 0]
-    val = QubeClient.decode_registers(regs, "float32")
-    assert round(val, 1) == 24.5
-    # int16 (negative): -10 = 0xFFF6 = 65526
-    regs = [65526]
-    val = QubeClient.decode_registers(regs, "int16")
-    assert val == -10