aioccl 2025.3.1__tar.gz → 2025.4__tar.gz

{aioccl-2025.3.1 → aioccl-2025.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioccl
-Version: 2025.3.1
+Version: 2025.4
 Summary: A Python library for CCL API server
 Home-page: https://github.com/CCL-Electronics-Ltd/aioccl
 Download-URL: https://github.com/CCL-Electronics-Ltd/aioccl

{aioccl-2025.3.1 → aioccl-2025.4}/aioccl/device.py

@@ -27,6 +27,11 @@ class CCLDevice:
             model: str | None
             passkey: str
             serial_no: str | None
+            
+        class Data(TypedDict):
+            """Store sensor data."""
+            binary_sensors: dict[str, CCLSensor]
+            sensors: dict[str, CCLSensor]
 
         self._info: Info = {
             "fw_ver": None,
@@ -36,10 +41,13 @@ class CCLDevice:
             "passkey": passkey,
             "serial_no": None,
         }
-
-        self._binary_sensors: dict[str, CCLSensor] | None = {}
-        self._sensors: dict[str, CCLSensor] | None = {}
-        self._update_callbacks = {}
+        
+        self._data: Data = {
+            "binary_sensors": {},
+            "sensors": {}
+        }
+        
+        self._update_callback = {}
 
         self._new_binary_sensor_callbacks = set()
         self._new_sensors: list[CCLSensor] | None = []
@@ -85,14 +93,9 @@ class CCLDevice:
         return self._info["fw_ver"]
 
     @property
-    def binary_sensors(self) -> dict[str, CCLSensor] | None:
-        """Store binary sensor data under this device."""
-        return self._binary_sensors
-
-    @property
-    def sensors(self) -> dict[str, CCLSensor] | None:
-        """Store sensor data under this device."""
-        return self._sensors
+    def get_data(self) -> dict[str, dict[str, CCLSensor]]:
+        """Get all types of sensor data under this device."""
+        return self._data
 
     def update_info(self, new_info: dict[str, None | str]) -> None:
         """Add or update device info."""
@@ -101,19 +104,19 @@ class CCLDevice:
                 self._info[key] = str(value)
         self._info["last_update_time"] = time.monotonic()
 
-    def update_sensors(self, sensors: dict[str, None | str | int | float]) -> None:
+    def process_data(self, data: dict[str, None | str | int | float]) -> None:
         """Add or update all sensor values."""
-        for key, value in sensors.items():
+        for key, value in data.items():
             if CCL_SENSORS.get(key).binary:
-                if key not in self.binary_sensors:
-                    self._binary_sensors[key] = CCLSensor(key)
-                    self._new_sensors.append(self.binary_sensors[key])
-                self._binary_sensors[key].value = value
+                if key not in self._data["binary_sensors"]:
+                    self._data["binary_sensors"][key] = CCLSensor(key)
+                    self._new_sensors.append(self._data["binary_sensors"][key])
+                self._data["binary_sensors"][key].value = value
             else:
-                if key not in self.sensors:
-                    self._sensors[key] = CCLSensor(key)
-                    self._new_sensors.append(self.sensors[key])
-                self._sensors[key].value = value
+                if key not in self._data["sensors"]:
+                    self._data["sensors"][key] = CCLSensor(key)
+                    self._new_sensors.append(self._data["sensors"][key])
+                self._data["sensors"][key].value = value
 
         add_count = self._publish_new_sensors()
         _LOGGER.debug(
@@ -123,65 +126,43 @@ class CCLDevice:
             self.last_update_time,
         )
 
-        update_count = self._publish_updates()
+        self._publish_updates()
         _LOGGER.debug(
-            "Updated %s sensors in total for device %s at %s.",
-            update_count,
+            "Updating sensor data for device %s at %s.",
             self.device_id,
             self.last_update_time,
         )
 
-    def register_update_cb(self, sensor_key, callback: Callable[[], None]) -> None:
-        """Register callback, called when Sensor changes state."""
-        self._update_callbacks[sensor_key] = callback
-
-    def remove_update_cb(self, sensor_key, callback: Callable[[], None]) -> None:
-        """Remove previously registered callback."""
-        self._update_callbacks.pop(sensor_key, None)
-
-    def _publish_updates(self) -> int:
-        """Schedule call all registered callbacks."""
-        count = 0
-        for sensor_key, callback in self._update_callbacks.items():
-            try:
-                callback()
-                count += 1
-            except Exception as err:  # pylint: disable=broad-exception-caught
-                _LOGGER.warning(
-                    "Error while updating sensor %s for device %s: %s",
-                    sensor_key,
-                    self.device_id,
-                    err,
-                )
-        return count
-
-    def register_new_binary_sensor_cb(self, callback: Callable[[], None]) -> None:
-        """Register callback, called when Sensor changes state."""
-        self._new_binary_sensor_callbacks.add(callback)
-
-    def remove_new_binary_sensor_cb(self, callback: Callable[[], None]) -> None:
-        """Remove previously registered callback."""
-        self._new_binary_sensor_callbacks.discard(callback)
+    def set_update_callback(self, callback: Callable[[], None]) -> None:
+        """Set the callback function to update sensor data."""
+        self._update_callback = callback
+
+    def _publish_updates(self) -> None:
+        """Call the function to update sensor data."""
+        try:
+            self._update_callback(self._data)
+        except Exception as err:  # pylint: disable=broad-exception-caught
+            _LOGGER.warning(
+                "Error while updating sensors for device %s: %s",
+                self.device_id,
+                err,
+            )
 
     def register_new_sensor_cb(self, callback: Callable[[], None]) -> None:
-        """Register callback, called when Sensor changes state."""
+        """Register callback of adding a new sensor."""
         self._new_sensor_callbacks.add(callback)
 
     def remove_new_sensor_cb(self, callback: Callable[[], None]) -> None:
-        """Remove previously registered callback."""
+        """Remove a registered callback."""
         self._new_sensor_callbacks.discard(callback)
 
     def _publish_new_sensors(self) -> None:
-        """Schedule call all registered callbacks."""
+        """Schedule all registered callbacks to add new sensors."""
         count = 0
         for sensor in self._new_sensors[:]:
             try:
-                if sensor.binary:
-                    for callback in self._new_binary_sensor_callbacks:
-                        callback(sensor)
-                else:
-                    for callback in self._new_sensor_callbacks:
-                        callback(sensor)
+                for callback in self._new_sensor_callbacks:
+                    callback(sensor)
                 self._new_sensors.remove(sensor)
                 count += 1
             except Exception as err:  # pylint: disable=broad-exception-caught

{aioccl-2025.3.1 → aioccl-2025.4}/aioccl/sensor.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 import enum
-
+from typing import Any
 
 class CCLSensor:
     """Class that represents a CCLSensor object in the aioCCL API."""
@@ -48,11 +48,6 @@ class CCLSensor:
         """Return the intrinsic sensor value."""
         if self.sensor_type.name in CCL_SENSOR_VALUES:
             return CCL_SENSOR_VALUES[self.sensor_type.name].get(self._value)
-        if self.sensor_type == CCLSensorTypes.BATTERY_BINARY:
-            try:
-                return int(self._value) - 1
-            except ValueError:
-                pass
         return self._value
 
     @value.setter
@@ -108,16 +103,24 @@ class CCLDeviceCompartment(enum.Enum):
     STATUS = "Status"
 
 
-CCL_SENSOR_VALUES: dict[str, dict[str, str]] = {
+CCL_SENSOR_VALUES: dict[str, dict[int, Any]] = {
     "CH_SENSOR_TYPE": {
-        2: "thermo-hygro",
-        3: "pool",
-        4: "soil",
+        2: "Thermo-Hygro",
+        3: "Pool",
+        4: "Soil",
     },
-    "LEAKAGE": {
-        0: "no_leak",
-        1: "leaking",
+    "BATTERY_BINARY": {
+        0: 1,
+        1: 0,
     },
+    "BATTERY": {
+        0: 0,
+        1: 0.2,
+        2: 0.4,
+        3: 0.6,
+        4: 0.8,
+        5: 1,
+    }
 }
 
 CCL_SENSORS: dict[str, CCLSensorPreset] = {
@@ -280,25 +283,25 @@ CCL_SENSORS: dict[str, CCLSensorPreset] = {
         "CH7 Type", CCLSensorTypes.CH_SENSOR_TYPE, CCLDeviceCompartment.OTHER
     ),
     "t6c1wls": CCLSensorPreset(
-        "Leakage CH1", CCLSensorTypes.LEAKAGE, CCLDeviceCompartment.OTHER
+        "Leakage CH1", CCLSensorTypes.LEAKAGE, CCLDeviceCompartment.OTHER, True
     ),
     "t6c2wls": CCLSensorPreset(
-        "Leakage CH2", CCLSensorTypes.LEAKAGE, CCLDeviceCompartment.OTHER
+        "Leakage CH2", CCLSensorTypes.LEAKAGE, CCLDeviceCompartment.OTHER, True
     ),
     "t6c3wls": CCLSensorPreset(
-        "Leakage CH3", CCLSensorTypes.LEAKAGE, CCLDeviceCompartment.OTHER
+        "Leakage CH3", CCLSensorTypes.LEAKAGE, CCLDeviceCompartment.OTHER, True
     ),
     "t6c4wls": CCLSensorPreset(
-        "Leakage CH4", CCLSensorTypes.LEAKAGE, CCLDeviceCompartment.OTHER
+        "Leakage CH4", CCLSensorTypes.LEAKAGE, CCLDeviceCompartment.OTHER, True
     ),
     "t6c5wls": CCLSensorPreset(
-        "Leakage CH5", CCLSensorTypes.LEAKAGE, CCLDeviceCompartment.OTHER
+        "Leakage CH5", CCLSensorTypes.LEAKAGE, CCLDeviceCompartment.OTHER, True
     ),
     "t6c6wls": CCLSensorPreset(
-        "Leakage CH6", CCLSensorTypes.LEAKAGE, CCLDeviceCompartment.OTHER
+        "Leakage CH6", CCLSensorTypes.LEAKAGE, CCLDeviceCompartment.OTHER, True
     ),
     "t6c7wls": CCLSensorPreset(
-        "Leakage CH7", CCLSensorTypes.LEAKAGE, CCLDeviceCompartment.OTHER
+        "Leakage CH7", CCLSensorTypes.LEAKAGE, CCLDeviceCompartment.OTHER, True
     ),
     "t5lskm": CCLSensorPreset(
         "Lightning Distance",

{aioccl-2025.3.1 → aioccl-2025.4}/aioccl/server.py

@@ -29,10 +29,10 @@ class CCLServer:
     async def handler(request: web.BaseRequest | web.Request) -> web.Response:
         """Handle POST requests for data updating."""
         body: dict[str, None | str | int | float] = {}
+        data: dict[str, None | str | int | float] = {}
         device: CCLDevice = None
         info: dict[str, None | str] = {}
         passkey: str = ""
-        sensors: dict[str, None | str | int | float] = {}
         status: None | int = None
         text: None | str = None
 
@@ -66,10 +66,10 @@ class CCLServer:
             if key in CCL_DEVICE_INFO_TYPES:
                 info.setdefault(key, value)
             elif key in CCL_SENSORS:
-                sensors.setdefault(key, value)
+                data.setdefault(key, value)
 
         device.update_info(info)
-        device.update_sensors(sensors)
+        device.process_data(data)
         status = 200
         text = "200 OK"
         _LOGGER.debug("Request processed: %s", passkey)

{aioccl-2025.3.1 → aioccl-2025.4}/aioccl.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioccl
-Version: 2025.3.1
+Version: 2025.4
 Summary: A Python library for CCL API server
 Home-page: https://github.com/CCL-Electronics-Ltd/aioccl
 Download-URL: https://github.com/CCL-Electronics-Ltd/aioccl

{aioccl-2025.3.1 → aioccl-2025.4}/setup.py

@@ -3,7 +3,7 @@
 from pathlib import Path
 from setuptools import find_packages, setup
 
-VERSION = "2025.3.1"
+VERSION = "2025.4"
 
 ROOT_DIR = Path(__file__).parent.resolve()