aioccl 2024.12.7__py3-none-any.whl → 2024.12.12__py3-none-any.whl

aioccl/device.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import logging
 import time
-from typing import Callable
+from typing import Callable, TypedDict
 
 from .sensor import CCLSensor, CCL_SENSORS
 
@@ -15,59 +15,74 @@ CCL_DEVICE_INFO_TYPES = ("serial_no", "mac_address", "model", "fw_ver")
 
 class CCLDevice:
     """Mapping for a CCL device."""
-    _binary_sensors: dict[str, CCLSensor] | None = {}
-    _device_id: str | None = None
-    _fw_ver: str | None = None
-    _last_updated_time: float | None = None
-    _mac_address: str | None = None
-    _model: str | None = None
-    _new_binary_sensor_callbacks = set()
-    _new_sensors: list[CCLSensor] | None = []
-    _new_sensor_callbacks = set()
-    _passkey = ''
-    _sensors: dict[str, CCLSensor] | None = {}
-    _serial_no: str | None = None
-    _update_callbacks = set()    
 
     def __init__(self, passkey: str):
         """Initialize a CCL device."""
-        self._passkey = passkey
+
+        class Info(TypedDict):
+            """Store device information."""
+            fw_ver: str | None
+            last_update_time: float | None
+            mac_address: str | None
+            model: str | None
+            passkey: str
+            serial_no: str | None
+
+        self._info: Info = {
+            "fw_ver": None,
+            "last_update_time": None,
+            "mac_address": None,
+            "model": None,
+            "passkey": passkey,
+            "serial_no": None,
+        }
+
+        self._binary_sensors: dict[str, CCLSensor] | None = {}
+        self._sensors: dict[str, CCLSensor] | None = {}
+        self._update_callbacks = {}
+
+        self._new_binary_sensor_callbacks = set()
+        self._new_sensors: list[CCLSensor] | None = []
+        self._new_sensor_callbacks = set()
 
     @property
     def passkey(self) -> str:
         """Return the passkey."""
-        return self._passkey
+        return self._info["passkey"]
 
     @property
     def device_id(self) -> str | None:
         """Return the device ID."""
-        try:
-            self._device_id = self._mac_address.replace(":", "").lower()[-6:]
-        except Exception:  # pylint: disable=broad-exception-caught
+        if self.mac_address is None:
             return None
-        return self._device_id
+        return self.mac_address.replace(":", "").lower()[-6:]
+
+    @property
+    def last_update_time(self) -> str | None:
+        """Return the last update time."""
+        return self._info["last_update_time"]
 
     @property
     def name(self) -> str | None:
         """Return the display name."""
-        if self._device_id is not None:
-            return self._model + " - " + self._device_id
-        return self._model
+        if self.device_id is not None:
+            return self.model + " - " + self.device_id
+        return self._info["model"]
 
     @property
     def mac_address(self) -> str | None:
         """Return the MAC address."""
-        return self._mac_address
+        return self._info["mac_address"]
 
     @property
     def model(self) -> str | None:
         """Return the model."""
-        return self._model
+        return self._info["model"]
 
     @property
     def fw_ver(self) -> str | None:
         """Return the firmware version."""
-        return self._fw_ver
+        return self._info["fw_ver"]
 
     @property
     def binary_sensors(self) -> dict[str, CCLSensor] | None:
@@ -79,45 +94,66 @@ class CCLDevice:
         """Store sensor data under this device."""
         return self._sensors
 
-    def update_info(self, info: dict[str, None | str]) -> None:
+    def update_info(self, new_info: dict[str, None | str]) -> None:
         """Add or update device info."""
-        self._mac_address = info.get("mac_address")
-        self._model = info.get("model")
-        self._fw_ver = info.get("fw_ver")
+        for key, value in new_info.items():
+            if key in self._info:
+                self._info[key] = str(value)
+        self._info["last_update_time"] = time.monotonic()
 
     def update_sensors(self, sensors: dict[str, None | str | int | float]) -> None:
         """Add or update all sensor values."""
         for key, value in sensors.items():
             if CCL_SENSORS.get(key).binary:
-                if key not in self._binary_sensors:
+                if key not in self.binary_sensors:
                     self._binary_sensors[key] = CCLSensor(key)
-                    self._new_sensors.append(self._binary_sensors[key])
+                    self._new_sensors.append(self.binary_sensors[key])
                 self._binary_sensors[key].value = value
             else:
-                if key not in self._sensors:
+                if key not in self.sensors:
                     self._sensors[key] = CCLSensor(key)
-                    self._new_sensors.append(self._sensors[key])
+                    self._new_sensors.append(self.sensors[key])
                 self._sensors[key].value = value
-        self._publish_new_sensors()
-        self._publish_updates()
-        self._last_updated_time = time.monotonic()
-        _LOGGER.debug("Sensors Updated: %s", self._last_updated_time)
 
-    def register_update_cb(self, callback: Callable[[], None]) -> None:
+        add_count = self._publish_new_sensors()
+        _LOGGER.debug(
+            "Added %s new sensors for device %s at %s.",
+            add_count,
+            self.device_id,
+            self.last_update_time,
+        )
+
+        update_count = self._publish_updates()
+        _LOGGER.debug(
+            "Updated %s sensors in total for device %s at %s.",
+            update_count,
+            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.add(callback)
+        self._update_callbacks[sensor_key] = callback
 
-    def remove_update_cb(self, callback: Callable[[], None]) -> None:
+    def remove_update_cb(self, sensor_key, callback: Callable[[], None]) -> None:
         """Remove previously registered callback."""
-        self._update_callbacks.discard(callback)
+        self._update_callbacks.pop(sensor_key, None)
 
-    def _publish_updates(self) -> None:
+    def _publish_updates(self) -> int:
         """Schedule call all registered callbacks."""
-        try:
-            for callback in self._update_callbacks:
+        count = 0
+        for sensor_key, callback in self._update_callbacks.items():
+            try:
                 callback()
-        except Exception as err:  # pylint: disable=broad-exception-caught
-            _LOGGER.warning("Error while publishing sensor updates: %s", err)
+                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."""
@@ -137,6 +173,7 @@ class CCLDevice:
 
     def _publish_new_sensors(self) -> None:
         """Schedule call all registered callbacks."""
+        count = 0
         for sensor in self._new_sensors[:]:
             try:
                 if sensor.binary:
@@ -146,5 +183,12 @@ class CCLDevice:
                     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
-                _LOGGER.warning("Error while publishing new sensors: %s", err)
+                _LOGGER.warning(
+                    "Error while adding sensor %s for device %s: %s",
+                    sensor.key,
+                    self.device_id,
+                    err,
+                )
+        return count

aioccl/server.py

@@ -23,60 +23,60 @@ class CCLServer:
     def register(device: CCLDevice) -> None:
         """Register a device with a passkey."""
         CCLServer.devices.setdefault(device.passkey, device)
-        _LOGGER.debug("Device registered: %s", device)
-    
+        _LOGGER.debug("Device registered: %s", device.passkey)
+
     @staticmethod
     async def handler(request: web.BaseRequest | web.Request) -> web.Response:
         """Handle POST requests for data updating."""
-        _body: 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
-
+        body: 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
+
+        _LOGGER.debug("Request received: %s", passkey)
         try:
-            _passkey = request.path[-8:]
-            for passkey in CCLServer.devices:
-                if passkey == _passkey:
-                    _device = CCLServer.devices[_passkey]
+            passkey = request.path[-8:]
+            for ref_passkey, ref_device in CCLServer.devices.items():
+                if passkey == ref_passkey:
+                    device = ref_device
                     break
-            assert isinstance(_device, CCLDevice), 404
+            assert isinstance(device, CCLDevice), 404
 
             assert request.content_type == "application/json", 400
             assert 0 < request.content_length <= 5000, 400
 
-            _body = await request.json()
+            body = await request.json()
 
         except Exception as err:  # pylint: disable=broad-exception-caught
-            _status = err.args[0]
-            if _status == 400:
-                _text = "400 Bad Request"
-            elif _status == 404:
-                _text = "404 Not Found"
+            status = err.args[0]
+            if status == 400:
+                text = "400 Bad Request"
+            elif status == 404:
+                text = "404 Not Found"
             else:
-                _status = 500
-                _text = "500 Internal Server Error"
+                status = 500
+                text = "500 Internal Server Error"
             _LOGGER.debug("Request exception occured: %s", err)
-            return web.Response(status=_status, text=_text)
+            return web.Response(status=status, text=text)
 
-        
-        for key, value in _body.items():
+        for key, value in body.items():
             if key in CCL_DEVICE_INFO_TYPES:
-                _info.setdefault(key, value)
+                info.setdefault(key, value)
             elif key in CCL_SENSORS:
-                _sensors.setdefault(key, value)
+                sensors.setdefault(key, value)
 
-        _device.update_info(_info)
-        _device.update_sensors(_sensors)
-        _status = 200
-        _text = "200 OK"
-        _LOGGER.debug("Request processed: %s", _passkey)
-        return web.Response(status=_status, text=_text)
+        device.update_info(info)
+        device.update_sensors(sensors)
+        status = 200
+        text = "200 OK"
+        _LOGGER.debug("Request processed: %s", passkey)
+        return web.Response(status=status, text=text)
 
     app = web.Application()
-    app.add_routes([web.get('/{passkey}', handler)])
+    app.add_routes([web.get("/{passkey}", handler)])
     runner = web.AppRunner(app)
 
     @staticmethod

{aioccl-2024.12.7.dist-info → aioccl-2024.12.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aioccl
-Version: 2024.12.7
+Version: 2024.12.12
 Summary: A Python library for CCL API server
 Home-page: https://github.com/fkiscd/aioccl
 Download-URL: https://github.com/fkiscd/aioccl
@@ -17,7 +17,6 @@ Classifier: Programming Language :: Python :: 3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>3
-Requires-Dist: aiohttp_cors>=0.7.0
 
 # aioCCL
 A Python library for CCL API server

aioccl-2024.12.12.dist-info/RECORD

@@ -0,0 +1,9 @@
+aioccl/__init__.py,sha256=XnegKtbvHvUTwVuuWNLb4LB9ZuGGar0xrZYOqk7scyg,133
+aioccl/device.py,sha256=TCp4QAP89ZHMNF3RqDMtCfTNRNqFGji_EiID3CtyJjs,6644
+aioccl/sensor.py,sha256=k89-wHjhYN2yv1bJYn8J26KqB8YHE7zlSTPpHW8CjDA,16910
+aioccl/server.py,sha256=IVBpFnpMkBndO5GK8Chl5WIArqw99LJ_Nln8cWT-4RQ,3237
+aioccl-2024.12.12.dist-info/LICENSE,sha256=PBRsTHchx7o0TQ2R2ktEAfFmn1iNHTxcOP_xaeuSAuo,11349
+aioccl-2024.12.12.dist-info/METADATA,sha256=MghnFaNkzQ9JUhwbcMM0pyLUZzEaONzQQA9eSfvri2A,734
+aioccl-2024.12.12.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+aioccl-2024.12.12.dist-info/top_level.txt,sha256=-xIJfyfXTaW_EH7XCIHyxjSSSwjLmawa2qhsrHZH1vA,7
+aioccl-2024.12.12.dist-info/RECORD,,

aioccl-2024.12.7.dist-info/RECORD

@@ -1,9 +0,0 @@
-aioccl/__init__.py,sha256=XnegKtbvHvUTwVuuWNLb4LB9ZuGGar0xrZYOqk7scyg,133
-aioccl/device.py,sha256=1BpnQSdCjHour9nvWF6sFkKillBlE-Iv96EK_niVS5w,5461
-aioccl/sensor.py,sha256=k89-wHjhYN2yv1bJYn8J26KqB8YHE7zlSTPpHW8CjDA,16910
-aioccl/server.py,sha256=a4Mjo2KNSOuCcna1YEv6SYzJx-h0a_Qq_EbyCogTHr4,3209
-aioccl-2024.12.7.dist-info/LICENSE,sha256=PBRsTHchx7o0TQ2R2ktEAfFmn1iNHTxcOP_xaeuSAuo,11349
-aioccl-2024.12.7.dist-info/METADATA,sha256=t_k46fKsOfcx0qz-Sga3cN4Ryv7pCSIfQu0sgRhxD9A,768
-aioccl-2024.12.7.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-aioccl-2024.12.7.dist-info/top_level.txt,sha256=-xIJfyfXTaW_EH7XCIHyxjSSSwjLmawa2qhsrHZH1vA,7
-aioccl-2024.12.7.dist-info/RECORD,,