python-qube-heatpump 1.3.0__tar.gz → 1.4.0__tar.gz

{python_qube_heatpump-1.3.0 → python_qube_heatpump-1.4.0}/PKG-INFO

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

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

{python_qube_heatpump-1.3.0 → python_qube_heatpump-1.4.0}/src/python_qube_heatpump/client.py

@@ -33,17 +33,21 @@ class QubeClient:
             self._connected = await self._client.connect()
         return self._connected
 
+    @property
+    def is_connected(self) -> bool:
+        """Return True if connected."""
+        return self._connected
+
     async def close(self) -> None:
         """Close connection."""
         self._client.close()
         self._connected = False
 
     async def get_all_data(self) -> QubeState:
-        """Fetch all definition data and return a state object."""
-        # Note: In a real implementation you might want to optimize this
-        # by reading contiguous blocks instead of one-by-one.
-        # For now, we wrap the individual reads for abstraction.
+        """Fetch all definition data and return a state object.
 
+        This fetches core sensors for the official HA integration.
+        """
         state = QubeState()
 
         # Helper to read and assign
@@ -80,6 +84,43 @@ class QubeClient:
 
         return state
 
+    async def get_all_entities(self) -> dict[str, Any]:
+        """Fetch all entity values from library definitions.
+
+        This reads all sensors, binary sensors, and switches defined in the
+        library's entity definitions. Used by the HACS integration.
+
+        Returns:
+            Dictionary mapping entity keys to their values.
+        """
+        results: dict[str, Any] = {}
+
+        # Read all sensors
+        for key, entity in SENSORS.items():
+            try:
+                results[key] = await self.read_entity(entity)
+            except Exception as exc:
+                _LOGGER.debug("Error reading sensor %s: %s", key, exc)
+                results[key] = None
+
+        # Read all binary sensors
+        for key, entity in BINARY_SENSORS.items():
+            try:
+                results[key] = await self.read_entity(entity)
+            except Exception as exc:
+                _LOGGER.debug("Error reading binary sensor %s: %s", key, exc)
+                results[key] = None
+
+        # Read all switches
+        for key, entity in SWITCHES.items():
+            try:
+                results[key] = await self.read_entity(entity)
+            except Exception as exc:
+                _LOGGER.debug("Error reading switch %s: %s", key, exc)
+                results[key] = None
+
+        return results
+
     async def read_value(self, definition: tuple) -> float | None:
         """Read a single value based on the constant definition."""
         address, reg_type, data_type, scale, offset = definition
@@ -94,11 +135,11 @@ class QubeClient:
         try:
             if reg_type == const.ModbusType.INPUT:
                 result = await self._client.read_input_registers(
-                    address, count, slave=self.unit
+                    address, count, device_id=self.unit
                 )
             else:
                 result = await self._client.read_holding_registers(
-                    address, count, slave=self.unit
+                    address, count, device_id=self.unit
                 )
 
             if result.isError():
@@ -180,7 +221,7 @@ class QubeClient:
             # Read based on input type
             if entity.input_type == InputType.COIL:
                 result = await self._client.read_coils(
-                    entity.address, count=1, slave=self.unit
+                    entity.address, count=1, device_id=self.unit
                 )
                 if result.isError():
                     _LOGGER.warning("Error reading coil %s", entity.address)
@@ -189,7 +230,7 @@ class QubeClient:
 
             if entity.input_type == InputType.DISCRETE_INPUT:
                 result = await self._client.read_discrete_inputs(
-                    entity.address, count=1, slave=self.unit
+                    entity.address, count=1, device_id=self.unit
                 )
                 if result.isError():
                     _LOGGER.warning("Error reading discrete input %s", entity.address)
@@ -198,11 +239,11 @@ class QubeClient:
 
             if entity.input_type == InputType.INPUT_REGISTER:
                 result = await self._client.read_input_registers(
-                    entity.address, count, slave=self.unit
+                    entity.address, count, device_id=self.unit
                 )
             else:  # HOLDING_REGISTER
                 result = await self._client.read_holding_registers(
-                    entity.address, count, slave=self.unit
+                    entity.address, count, device_id=self.unit
                 )
 
             if result.isError():
@@ -340,7 +381,7 @@ class QubeClient:
 
         try:
             result = await self._client.write_coil(
-                entity.address, value, slave=self.unit
+                entity.address, value, device_id=self.unit
             )
             if result.isError():
                 _LOGGER.warning("Error writing switch %s", key)
@@ -388,17 +429,17 @@ class QubeClient:
                 int_val = struct.unpack(">I", packed)[0]
                 regs = [int_val & 0xFFFF, (int_val >> 16) & 0xFFFF]
                 result = await self._client.write_registers(
-                    entity.address, regs, slave=self.unit
+                    entity.address, regs, device_id=self.unit
                 )
             elif entity.data_type == DataType.INT16:
                 if write_value < 0:
                     write_value = int(write_value) + 65536
                 result = await self._client.write_register(
-                    entity.address, int(write_value), slave=self.unit
+                    entity.address, int(write_value), device_id=self.unit
                 )
             elif entity.data_type == DataType.UINT16:
                 result = await self._client.write_register(
-                    entity.address, int(write_value), slave=self.unit
+                    entity.address, int(write_value), device_id=self.unit
                 )
             else:
                 _LOGGER.warning("Unsupported data type for writing: %s", entity.data_type)