aioccl 2024.12__tar.gz → 2024.12.2__tar.gz

{aioccl-2024.12 → aioccl-2024.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aioccl
-Version: 2024.12
+Version: 2024.12.2
 Summary: A Python library for CCL API server
 Home-page: https://github.com/fkiscd/aioccl
 Download-URL: https://github.com/fkiscd/aioccl

{aioccl-2024.12 → aioccl-2024.12.2}/aioccl/device.py

@@ -1,4 +1,5 @@
 """CCL device mapping."""
+
 from __future__ import annotations
 
 import logging
@@ -11,72 +12,73 @@ _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 = {}
+    _fw_ver: str | None
+    _last_updated_time: float | None
+    _mac_address: str | None
+    _model: str | None
+    _new_binary_sensor_callbacks = set()
+    _new_sensors: list[CCLSensor] | None = []
+    _new_sensor_callbacks = set()
+    _sensors: dict[str, CCLSensor] | None = {}
+    _serial_no: str | None
+    _update_callbacks = set()
+    
+
     def __init__(self, passkey: str):
         """Initialize a CCL device."""
-        _LOGGER.debug('Initializing CCL Device: %s', self)
+        _LOGGER.debug("Initializing CCL Device: %s", self)
         self._passkey = passkey
-        
-        self._serial_no: str | None
-        self._mac_address: str | None
-        self._model: str | None
-        self._fw_ver: str | None
-        self._binary_sensors: dict[str, CCLSensor] | None = {}
-        self._sensors: dict[str, CCLSensor] | None = {}
-        self._last_updated_time: float | None
-
-        self._new_sensors: list[CCLSensor] | None = []
-        
-        self._update_callbacks = set() 
-        self._new_binary_sensor_callbacks = set()
-        self._new_sensor_callbacks = set()
-    
+
     @property
     def passkey(self) -> str:
         """Return the passkey."""
         return self._passkey
-    
+
     @property
     def device_id(self) -> str | None:
         """Return the device ID."""
         return self._mac_address.replace(":", "").lower()[-6:]
-    
+
     @property
     def name(self) -> str | None:
         """Return the display name."""
         return self._model + " - " + self.device_id
-    
+
     @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')
-    
+        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():
@@ -108,7 +110,7 @@ class CCLDevice:
         try:
             for callback in self._update_callbacks:
                 callback()
-        except Exception as err: # pylint: disable=broad-exception-caught
+        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:
@@ -139,5 +141,5 @@ class CCLDevice:
                     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)
+            except Exception as err:  # pylint: disable=broad-exception-caught
+                _LOGGER.warning("Error while publishing new sensors: %s", err)

{aioccl-2024.12 → aioccl-2024.12.2}/aioccl/server.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import logging
+from typing import Callable
 
 from aiohttp import web
 
@@ -20,47 +21,38 @@ class CCLServer:
     devices: dict[str, CCLDevice] = {}
 
     @staticmethod
-    def add_copy(device: CCLDevice) -> None:
-        """Attach a device copy to the server."""
+    def register(device: CCLDevice) -> None:
+        """Register a device with a passkey."""
         CCLServer.devices.setdefault(device.passkey, device)
-        _LOGGER.debug(CCLServer.devices)
-
-    # routes = web.RouteTableDef()
+        _LOGGER.debug("Device registered: %s", CCLServer.devices)
 
+    @staticmethod
+    def get_handler() -> Callable[[web.BaseRequest], web.Response]:
+        """Get the handler."""
+        return CCLServer._handler
+    
     @staticmethod
     async def _handler(request: web.BaseRequest) -> web.Response:
         """Handle POST requests for data updating."""
-
-        class HandlerStorage:
-            """Store data for a single request."""
-
-            body: dict[str, None | str | int | float]
-            info: dict[str, None | str]
-            sensors: dict[str, None | str | int | float]
-
-        _LOGGER.debug("Request received.")
-
-        # Resetting variables
+        _body: dict[str, None | str | int | float] = {}
         _device: CCLDevice = None
-
-        HandlerStorage.body = {}
-        HandlerStorage.info = {}
-        HandlerStorage.sensors = {}
-
+        _info: dict[str, None | str] = {}
+        _passkey: str = ''
+        _sensors: dict[str, None | str | int | float] = {}
         _status: None | int = None
         _text: None | str = None
 
         try:
             for passkey, _device in CCLServer.devices.items():
                 if passkey == request.match_info["passkey"]:
+                    _passkey = passkey
                     break
             assert _device, 404
 
             assert request.content_type == "application/json", 400
             assert 0 < request.content_length <= 5000, 400
 
-            HandlerStorage.body = await request.json()
-            _LOGGER.debug(HandlerStorage.body)
+            _body = await request.json()
 
         except Exception as err:  # pylint: disable=broad-exception-caught
             _status = err.args[0]
@@ -74,30 +66,29 @@ class CCLServer:
             _LOGGER.debug("Request exception occured: %s", err)
             return web.Response(status=_status, text=_text)
 
-        else:
-            for key, value in HandlerStorage.body.items():
-                if key in CCL_DEVICE_INFO_TYPES:
-                    HandlerStorage.info.setdefault(key, value)
-                elif key in CCL_SENSORS:
-                    HandlerStorage.sensors.setdefault(key, value)
-
-            _device.update_info(HandlerStorage.info)
-            _device.update_sensors(HandlerStorage.sensors)
-            _status = 200
-            _text = "200 OK"
-            _LOGGER.debug("Request processed.")
-            return web.Response(status=_status, text=_text)
+        
+        for key, value in _body.items():
+            if key in CCL_DEVICE_INFO_TYPES:
+                _info.setdefault(key, value)
+            elif key in CCL_SENSORS:
+                _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)
 
     app = web.Application()
-    
     app.add_routes([web.get('/{passkey}', _handler)])
+    runner = web.AppRunner(app)
 
     @staticmethod
     async def run() -> None:
-        """Try to run the API server in case none is available."""
+        """Try to run the API server."""
         try:
             _LOGGER.debug("Trying to start the API server.")
-            CCLServer.runner = web.AppRunner(CCLServer.app)
             await CCLServer.runner.setup()
             site = web.TCPSite(CCLServer.runner, port=CCLServer.LISTEN_PORT)
             await site.start()

{aioccl-2024.12 → aioccl-2024.12.2}/aioccl.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aioccl
-Version: 2024.12
+Version: 2024.12.2
 Summary: A Python library for CCL API server
 Home-page: https://github.com/fkiscd/aioccl
 Download-URL: https://github.com/fkiscd/aioccl

{aioccl-2024.12 → aioccl-2024.12.2}/setup.py

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