Apply ruff and cleanup code

Author: Frank

plugwise_usb/__init__.py

@@ -7,14 +7,14 @@
 from __future__ import annotations
 
 from asyncio import get_running_loop
-from collections.abc import Awaitable, Callable
+from collections.abc import Callable, Coroutine
 from functools import wraps
 import logging
 from typing import Any, TypeVar, cast
 
 from .api import NodeEvent, StickEvent
 from .connection import StickController
-from .exceptions import StickError
+from .exceptions import StickError, SubscriptionError
 from .network import StickNetwork
 from .nodes import PlugwiseNode
 
@@ -198,7 +198,7 @@ async def clear_cache(self) -> None:
 
     def subscribe_to_stick_events(
         self,
-        stick_event_callback: Callable[[StickEvent], Awaitable[None]],
+        stick_event_callback: Callable[[StickEvent], Coroutine[Any, Any, None]],
         events: tuple[StickEvent],
     ) -> Callable[[], None]:
         """Subscribe callback when specified StickEvent occurs.
@@ -213,13 +213,15 @@ def subscribe_to_stick_events(
     @raise_not_initialized
     def subscribe_to_node_events(
         self,
-        node_event_callback: Callable[[NodeEvent, str], Awaitable[None]],
-        events: tuple[NodeEvent],
+        node_event_callback: Callable[[NodeEvent, str], Coroutine[Any, Any, None]],
+        events: tuple[NodeEvent, ...],
     ) -> Callable[[], None]:
         """Subscribe callback to be called when specific NodeEvent occurs.
 
         Returns the function to be called to unsubscribe later.
         """
+        if self._network is None:
+            raise SubscriptionError("Unable to subscribe to node events without network connection initialized")
         return self._network.subscribe_to_node_events(
             node_event_callback,
             events,

plugwise_usb/api.py

@@ -15,6 +15,14 @@ class StickEvent(Enum):
     NETWORK_ONLINE = auto()
 
 
+class MotionSensitivity(Enum):
+    """Motion sensitivity levels for Scan devices."""
+
+    HIGH = auto()
+    MEDIUM = auto()
+    OFF = auto()
+
+
 class NodeEvent(Enum):
     """Plugwise Node events for callback subscription."""
 
@@ -46,6 +54,7 @@ class NodeFeature(str, Enum):
     """USB Stick Node feature."""
 
     AVAILABLE = "available"
+    BATTERY = "battery"
     ENERGY = "energy"
     HUMIDITY = "humidity"
     INFO = "info"
@@ -66,6 +75,28 @@ class NodeFeature(str, Enum):
 )
 
 
+@dataclass
+class BatteryConfig:
+    """Battery related configuration settings."""
+
+    # Duration in minutes the node synchronize its clock
+    clock_interval: int | None = None
+
+    # Enable/disable clock sync
+    clock_sync: bool | None = None
+
+    # Minimal interval in minutes the node will wake up
+    # and able to receive (maintenance) commands
+    maintenance_interval: int | None = None
+
+    # Duration in seconds the SED will be awake for receiving commands
+    stay_active: int | None = None
+
+    #  Duration in minutes the SED will be in sleeping mode
+    #  and not able to respond any command
+    sleep_for: int | None = None
+
+
 @dataclass
 class NodeInfo:
     """Node hardware information."""
@@ -116,6 +147,8 @@ class MotionState:
 
     motion: bool | None = None
     timestamp: datetime | None = None
+    reset_timer: int | None = None
+    daylight_mode: bool | None = None
 
 
 @dataclass

plugwise_usb/connection/__init__.py

@@ -2,9 +2,9 @@
 
 from __future__ import annotations
 
-from collections.abc import Awaitable, Callable
-from concurrent import futures
+from collections.abc import Awaitable, Callable, Coroutine
 import logging
+from typing import Any
 
 from ..api import StickEvent
 from ..exceptions import NodeError, StickError
@@ -26,7 +26,6 @@ def __init__(self) -> None:
         self._unsubscribe_stick_event: Callable[[], None] | None = None
 
         self._init_sequence_id: bytes | None = None
-        self._init_future: futures.Future | None = None
 
         self._is_initialized = False
         self._mac_stick: str | None = None
@@ -115,7 +114,7 @@ async def connect_to_stick(self, serial_path: str) -> None:
     def subscribe_to_stick_events(
         self,
         stick_event_callback: Callable[[StickEvent], Awaitable[None]],
-        events: tuple[StickEvent],
+        events: tuple[StickEvent, ...],
     ) -> Callable[[], None]:
         """Subscribe callback when specified StickEvent occurs.
 
@@ -130,7 +129,7 @@ def subscribe_to_stick_events(
 
     def subscribe_to_node_responses(
         self,
-        node_response_callback: Callable[[PlugwiseResponse], Awaitable[None]],
+        node_response_callback: Callable[[PlugwiseResponse], Coroutine[Any, Any, bool]],
         mac: bytes | None = None,
         message_ids: tuple[bytes] | None = None,
     ) -> Callable[[], None]:
@@ -165,15 +164,20 @@ async def initialize_stick(self) -> None:
             raise StickError("Cannot initialize, queue manager not running")
 
         try:
-            init_response: StickInitResponse = await self._queue.submit(
-                StickInitRequest()
-            )
+            request = StickInitRequest(self.send)
+            init_response: StickInitResponse | None = await request.send()
         except StickError as err:
             raise StickError(
                 "No response from USB-Stick to initialization request." +
                 " Validate USB-stick is connected to port " +
                 f"' {self._manager.serial_path}'"
             ) from err
+        if init_response is None:
+            raise StickError(
+                "No response from USB-Stick to initialization request." +
+                " Validate USB-stick is connected to port " +
+                f"' {self._manager.serial_path}'"
+            )
         self._mac_stick = init_response.mac_decoded
         self._network_online = init_response.network_online
 

plugwise_usb/connection/manager.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from asyncio import Future, gather, get_event_loop, wait_for
-from collections.abc import Awaitable, Callable
+from collections.abc import Awaitable, Callable, Coroutine
 import logging
 from typing import Any
 
@@ -32,18 +32,26 @@ def __init__(self) -> None:
         self._connected: bool = False
         self._stick_event_subscribers: dict[
             Callable[[], None],
-            tuple[Callable[[StickEvent], Awaitable[None]], StickEvent | None]
+            tuple[Callable[[StickEvent], Awaitable[None]], tuple[StickEvent, ...]],
         ] = {}
         self._unsubscribe_stick_events: Callable[[], None] | None = None
 
     @property
     def reduce_receive_logging(self) -> bool:
         """Return if logging must reduced."""
+        if self._receiver is None:
+            raise StickError(
+                "Unable to return log settings when connection is not active."
+            )
         return self._receiver.reduce_logging
 
     @reduce_receive_logging.setter
     def reduce_receive_logging(self, state: bool) -> None:
         """Reduce logging of unhandled received messages."""
+        if self._receiver is None:
+            raise StickError(
+                "Unable to set log settings when connection is not active."
+            )
         self._receiver.reduce_logging = state
 
     @property
@@ -62,14 +70,12 @@ def is_connected(self) -> bool:
 
     def _subscribe_to_stick_events(self) -> None:
         """Subscribe to handle stick events by manager."""
-        if not self.is_connected:
+        if not self.is_connected or self._receiver is None:
             raise StickError("Unable to subscribe to events")
         if self._unsubscribe_stick_events is None:
-            self._unsubscribe_stick_events = (
-                self._receiver.subscribe_to_stick_events(
-                    self._handle_stick_event,
-                    (StickEvent.CONNECTED, StickEvent.DISCONNECTED)
-                )
+            self._unsubscribe_stick_events = self._receiver.subscribe_to_stick_events(
+                self._handle_stick_event,
+                (StickEvent.CONNECTED, StickEvent.DISCONNECTED),
             )
 
     async def _handle_stick_event(
@@ -79,47 +85,47 @@ async def _handle_stick_event(
         """Call callback for stick event subscribers."""
         if len(self._stick_event_subscribers) == 0:
             return
-        callback_list: list[Callable] = []
-        for callback, filtered_events in list(
-            self._stick_event_subscribers.values()
-        ):
-            if event in filtered_events:
+        callback_list: list[Awaitable[None]] = []
+        for callback, stick_events in self._stick_event_subscribers.values():
+            if event in stick_events:
                 callback_list.append(callback(event))
         if len(callback_list) > 0:
             await gather(*callback_list)
 
     def subscribe_to_stick_events(
         self,
         stick_event_callback: Callable[[StickEvent], Awaitable[None]],
-        events: tuple[StickEvent],
+        events: tuple[StickEvent, ...],
     ) -> Callable[[], None]:
         """Subscribe callback when specified StickEvent occurs.
 
         Returns the function to be called to unsubscribe later.
         """
+
         def remove_subscription() -> None:
             """Remove stick event subscription."""
             self._stick_event_subscribers.pop(remove_subscription)
-        self._stick_event_subscribers[remove_subscription] = (stick_event_callback, events)
+
+        self._stick_event_subscribers[remove_subscription] = (
+            stick_event_callback,
+            events,
+        )
         return remove_subscription
 
     def subscribe_to_stick_replies(
         self,
-        callback: Callable[
-            [StickResponse], Awaitable[None]
-        ],
+        callback: Callable[[StickResponse], Coroutine[Any, Any, None]],
     ) -> Callable[[], None]:
         """Subscribe to response messages from stick."""
         if self._receiver is None or not self._receiver.is_connected:
             raise StickError(
-                "Unable to subscribe to stick response when receiver " +
-                "is not loaded"
+                "Unable to subscribe to stick response when receiver " + "is not loaded"
             )
         return self._receiver.subscribe_to_stick_responses(callback)
 
     def subscribe_to_node_responses(
         self,
-        node_response_callback: Callable[[PlugwiseResponse], Awaitable[None]],
+        node_response_callback: Callable[[PlugwiseResponse], Coroutine[Any, Any, bool]],
         mac: bytes | None = None,
         message_ids: tuple[bytes] | None = None,
     ) -> Callable[[], None]:
@@ -129,21 +135,18 @@ def subscribe_to_node_responses(
         """
         if self._receiver is None or not self._receiver.is_connected:
             raise StickError(
-                "Unable to subscribe to node response when receiver " +
-                "is not loaded"
+                "Unable to subscribe to node response when receiver " + "is not loaded"
             )
         return self._receiver.subscribe_to_node_responses(
             node_response_callback, mac, message_ids
         )
 
-    async def setup_connection_to_stick(
-        self, serial_path: str
-    ) -> None:
+    async def setup_connection_to_stick(self, serial_path: str) -> None:
         """Create serial connection to USB-stick."""
         if self._connected:
             raise StickError("Cannot setup connection, already connected")
         loop = get_event_loop()
-        connected_future: Future[Any] = Future()
+        connected_future: Future[bool] = Future()
         self._receiver = StickReceiver(connected_future)
         self._port = serial_path
 
@@ -187,14 +190,14 @@ async def write_to_stick(self, request: PlugwiseRequest) -> None:
         _LOGGER.debug("Write to USB-stick: %s", request)
         if not request.resend:
             raise StickError(
-                f"Failed to send {request.__class__.__name__} " +
-                f"to node {request.mac_decoded}, maximum number " +
-                f"of retries ({request.max_retries}) has been reached"
+                f"Failed to send {request.__class__.__name__} "
+                + f"to node {request.mac_decoded}, maximum number "
+                + f"of retries ({request.max_retries}) has been reached"
             )
         if self._sender is None:
             raise StickError(
-                f"Failed to send {request.__class__.__name__}" +
-                "because USB-Stick connection is not setup"
+                f"Failed to send {request.__class__.__name__}"
+                + "because USB-Stick connection is not setup"
             )
         await self._sender.write_request_to_port(request)
 

plugwise_usb/connection/queue.py

@@ -8,7 +8,8 @@
 
 from ..api import StickEvent
 from ..exceptions import NodeTimeout, StickError, StickTimeout
-from ..messages.requests import NodePingRequest, PlugwiseRequest, Priority
+from ..messages import Priority
+from ..messages.requests import NodePingRequest, PlugwiseCancelRequest, PlugwiseRequest
 from ..messages.responses import PlugwiseResponse
 from .manager import StickConnectionManager
 
@@ -31,7 +32,7 @@ def __init__(self) -> None:
         self._stick: StickConnectionManager | None = None
         self._loop = get_running_loop()
         self._submit_queue: PriorityQueue[PlugwiseRequest] = PriorityQueue()
-        self._submit_worker_task: Task | None = None
+        self._submit_worker_task: Task[None] | None = None
         self._unsubscribe_connection_events: Callable[[], None] | None = None
         self._running = False
 
@@ -71,8 +72,7 @@ async def stop(self) -> None:
             self._unsubscribe_connection_events()
         self._running = False
         if self._submit_worker_task is not None and not self._submit_worker_task.done():
-            cancel_request = PlugwiseRequest(b"0000", None)
-            cancel_request.priority = Priority.CANCEL
+            cancel_request = PlugwiseCancelRequest()
             await self._submit_queue.put(cancel_request)
             await self._submit_worker_task
         self._submit_worker_task = None
@@ -97,10 +97,10 @@ async def submit(
                 if isinstance(request, NodePingRequest):
                     # For ping requests it is expected to receive timeouts, so lower log level
                     _LOGGER.debug("%s, cancel because timeout is expected for NodePingRequests", e)
-                elif request.resend:
+                if request.resend:
                     _LOGGER.info("%s, retrying", e)
                 else:
-                    _LOGGER.warning("%s, cancel request", e)
+                    _LOGGER.warning("%s, cancel request", e)  # type: ignore[unreachable]
             except StickError as exception:
                 _LOGGER.error(exception)
                 raise StickError(
@@ -134,7 +134,7 @@ async def _add_request_to_queue(self, request: PlugwiseRequest) -> None:
     async def _send_queue_worker(self) -> None:
         """Send messages from queue at the order of priority."""
         _LOGGER.debug("Send_queue_worker started")
-        while self._running:
+        while self._running and self._stick is not None:
             request = await self._submit_queue.get()
             _LOGGER.debug("Send from send queue %s", request)
             if request.priority == Priority.CANCEL: