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

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

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

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

{python_qube_heatpump-1.2.0 → 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.0 → 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.0/src/python_qube_heatpump/client.py

@@ -1,166 +0,0 @@
-"""Qube Heat Pump Client Library."""
-
-from __future__ import annotations
-
-import asyncio
-import contextlib
-import ipaddress
-import logging
-import socket
-import struct
-from typing import Any
-
-from pymodbus.client import AsyncModbusTcpClient
-from pymodbus.exceptions import ModbusException
-from pymodbus.pdu import ExceptionResponse
-
-
-class QubeClient:
-    """Qube Heat Pump Client."""
-
-    def __init__(
-        self,
-        host: str,
-        port: int,
-        unit_id: int = 1,
-    ) -> None:
-        """Initialize the client."""
-        self._host = host
-        self._port = port
-        self._unit = unit_id
-        self._client: AsyncModbusTcpClient | None = None
-        self._io_timeout_s: float = 3.0
-
-    @property
-    def host(self) -> str:
-        """Return host."""
-        return self._host
-
-    @property
-    def port(self) -> int:
-        """Return port."""
-        return self._port
-
-    @property
-    def unit(self) -> int:
-        """Return unit ID."""
-        return self._unit
-
-    def set_unit_id(self, unit_id: int) -> None:
-        """Set unit ID."""
-        self._unit = int(unit_id)
-
-    async def connect(self) -> bool:
-        """Connect to the Modbus server."""
-        if self._client is None:
-            self._client = AsyncModbusTcpClient(self._host, port=self._port)
-
-        if self.is_connected:
-            return True
-
-        try:
-            return await asyncio.wait_for(
-                self._client.connect(), timeout=self._io_timeout_s
-            )
-        except Exception as exc:  # pylint: disable=broad-except  # noqa: BLE001
-            logging.getLogger(__name__).debug("Failed to connect: %s", exc)
-            return False
-
-    @property
-    def is_connected(self) -> bool:
-        """Return True if connected."""
-        return bool(self._client and getattr(self._client, "connected", False))
-
-    async def close(self) -> None:
-        """Close the connection."""
-        if self._client:
-            with contextlib.suppress(Exception):
-                self._client.close()
-            self._client = None
-
-    async def _call(self, method: str, **kwargs: Any) -> Any:
-        if self._client is None:
-            raise ModbusException("Client not connected")
-        func = getattr(self._client, method)
-        # Try with 'slave' then 'unit', finally without either
-        try:
-            resp = await asyncio.wait_for(
-                func(**{**kwargs, "slave": self._unit}), timeout=self._io_timeout_s
-            )
-        except TypeError:
-            try:
-                resp = await asyncio.wait_for(
-                    func(**{**kwargs, "unit": self._unit}), timeout=self._io_timeout_s
-                )
-            except TypeError:
-                resp = await asyncio.wait_for(
-                    func(**kwargs), timeout=self._io_timeout_s
-                )
-        # Normalize error checking
-        if isinstance(resp, ExceptionResponse) or (
-            hasattr(resp, "isError") and resp.isError()
-        ):
-            raise ModbusException(f"Modbus error on {method} with {kwargs}")
-        return resp
-
-    async def read_registers(
-        self, address: int, count: int, input_type: str = "holding"
-    ) -> list[int]:
-        """Read registers from the device."""
-        if input_type == "input":
-            rr = await self._call("read_input_registers", address=address, count=count)
-        else:
-            rr = await self._call(
-                "read_holding_registers", address=address, count=count
-            )
-
-        regs = getattr(rr, "registers", None)
-        if regs is None:
-            raise ModbusException("No registers returned")
-        return list(regs)
-
-    @staticmethod
-    def decode_registers(regs: list[int], data_type: str | None) -> float | int:
-        """Decode registers to a value."""
-        # All decoding assumes big-endian word and byte order.
-        if data_type == "float32":
-            raw = struct.pack(">HH", int(regs[0]) & 0xFFFF, int(regs[1]) & 0xFFFF)
-            return float(struct.unpack(">f", raw)[0])
-        if data_type == "int16":
-            v = int(regs[0]) & 0xFFFF
-            return v - 0x10000 if v & 0x8000 else v
-        if data_type == "uint16":
-            return int(regs[0]) & 0xFFFF
-        if data_type == "uint32":
-            return ((int(regs[0]) & 0xFFFF) << 16) | (int(regs[1]) & 0xFFFF)
-        if data_type == "int32":
-            u = ((int(regs[0]) & 0xFFFF) << 16) | (int(regs[1]) & 0xFFFF)
-            return u - 0x1_0000_0000 if u & 0x8000_0000 else u
-        # Fallback to first register as unsigned 16-bit
-        return int(regs[0]) & 0xFFFF
-
-    async def resolve_ip(self) -> str | None:
-        """Resolve the host to an IP address."""
-        with contextlib.suppress(ValueError):
-            return str(ipaddress.ip_address(self._host))
-
-        try:
-            infos = await asyncio.get_running_loop().getaddrinfo(
-                self._host,
-                None,
-                type=socket.SOCK_STREAM,
-            )
-        except OSError:
-            return None
-
-        for family, _, _, _, sockaddr in infos:
-            if not sockaddr:
-                continue
-            addr = sockaddr[0]
-            if not isinstance(addr, str):
-                continue
-            if family == socket.AF_INET6 and addr.startswith("::ffff:"):
-                addr = addr.removeprefix("::ffff:")
-            return addr
-
-        return None

python_qube_heatpump-1.2.0/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