aioccl 2024.12.7__tar.gz → 2024.12.12__tar.gz

{aioccl-2024.12.7 → aioccl-2024.12.12}/PKG-INFO

@@ -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/aioccl/device.py

@@ -0,0 +1,194 @@
+"""CCL device mapping."""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Callable, TypedDict
+
+from .sensor import CCLSensor, CCL_SENSORS
+
+_LOGGER = logging.getLogger(__name__)
+
+CCL_DEVICE_INFO_TYPES = ("serial_no", "mac_address", "model", "fw_ver")
+
+
+class CCLDevice:
+    """Mapping for a CCL device."""
+
+    def __init__(self, passkey: str):
+        """Initialize a CCL device."""
+
+        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._info["passkey"]
+
+    @property
+    def device_id(self) -> str | None:
+        """Return the device ID."""
+        if self.mac_address is None:
+            return None
+        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._info["model"]
+
+    @property
+    def mac_address(self) -> str | None:
+        """Return the MAC address."""
+        return self._info["mac_address"]
+
+    @property
+    def model(self) -> str | None:
+        """Return the model."""
+        return self._info["model"]
+
+    @property
+    def fw_ver(self) -> str | None:
+        """Return the firmware version."""
+        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 update_info(self, new_info: dict[str, None | str]) -> None:
+        """Add or update device info."""
+        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:
+                    self._binary_sensors[key] = CCLSensor(key)
+                    self._new_sensors.append(self.binary_sensors[key])
+                self._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
+
+        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[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 register_new_sensor_cb(self, callback: Callable[[], None]) -> None:
+        """Register callback, called when Sensor changes state."""
+        self._new_sensor_callbacks.add(callback)
+
+    def remove_new_sensor_cb(self, callback: Callable[[], None]) -> None:
+        """Remove previously registered callback."""
+        self._new_sensor_callbacks.discard(callback)
+
+    def _publish_new_sensors(self) -> None:
+        """Schedule call all registered callbacks."""
+        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)
+                self._new_sensors.remove(sensor)
+                count += 1
+            except Exception as err:  # pylint: disable=broad-exception-caught
+                _LOGGER.warning(
+                    "Error while adding sensor %s for device %s: %s",
+                    sensor.key,
+                    self.device_id,
+                    err,
+                )
+        return count

{aioccl-2024.12.7 → aioccl-2024.12.12}/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 → aioccl-2024.12.12}/aioccl.egg-info/PKG-INFO

@@ -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/aioccl.egg-info/requires.txt

@@ -0,0 +1 @@
+aiohttp>3

{aioccl-2024.12.7 → aioccl-2024.12.12}/setup.py

@@ -3,7 +3,7 @@
 from pathlib import Path
 from setuptools import find_packages, setup
 
-VERSION = "2024.12.7"
+VERSION = "2024.12.12"
 
 ROOT_DIR = Path(__file__).parent.resolve()
 
@@ -20,8 +20,7 @@ setup(
   url="https://github.com/fkiscd/aioccl",
   download_url="https://github.com/fkiscd/aioccl",
   install_requires=[
-          "aiohttp>3",
-          "aiohttp_cors>=0.7.0"
+          "aiohttp>3"
       ],
   include_package_data=True,
   classifiers=[

aioccl-2024.12.7/aioccl/device.py

@@ -1,150 +0,0 @@
-"""CCL device mapping."""
-
-from __future__ import annotations
-
-import logging
-import time
-from typing import Callable
-
-from .sensor import CCLSensor, CCL_SENSORS
-
-_LOGGER = logging.getLogger(__name__)
-
-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
-
-    @property
-    def passkey(self) -> str:
-        """Return the passkey."""
-        return self._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
-            return None
-        return self._device_id
-
-    @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
-
-    @property
-    def mac_address(self) -> str | None:
-        """Return the MAC address."""
-        return self._mac_address
-
-    @property
-    def model(self) -> str | None:
-        """Return the model."""
-        return self._model
-
-    @property
-    def fw_ver(self) -> str | None:
-        """Return the firmware version."""
-        return self._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 update_info(self, 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")
-
-    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:
-                    self._binary_sensors[key] = CCLSensor(key)
-                    self._new_sensors.append(self._binary_sensors[key])
-                self._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
-        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:
-        """Register callback, called when Sensor changes state."""
-        self._update_callbacks.add(callback)
-
-    def remove_update_cb(self, callback: Callable[[], None]) -> None:
-        """Remove previously registered callback."""
-        self._update_callbacks.discard(callback)
-
-    def _publish_updates(self) -> None:
-        """Schedule call all registered callbacks."""
-        try:
-            for callback in self._update_callbacks:
-                callback()
-        except Exception as err:  # pylint: disable=broad-exception-caught
-            _LOGGER.warning("Error while publishing sensor updates: %s", err)
-
-    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 register_new_sensor_cb(self, callback: Callable[[], None]) -> None:
-        """Register callback, called when Sensor changes state."""
-        self._new_sensor_callbacks.add(callback)
-
-    def remove_new_sensor_cb(self, callback: Callable[[], None]) -> None:
-        """Remove previously registered callback."""
-        self._new_sensor_callbacks.discard(callback)
-
-    def _publish_new_sensors(self) -> None:
-        """Schedule call all registered callbacks."""
-        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)
-                self._new_sensors.remove(sensor)
-            except Exception as err:  # pylint: disable=broad-exception-caught
-                _LOGGER.warning("Error while publishing new sensors: %s", err)

aioccl-2024.12.7/aioccl.egg-info/requires.txt

@@ -1,2 +0,0 @@
-aiohttp>3
-aiohttp_cors>=0.7.0