Propagate NodeType to node on init

Unify loading of SED nodes
Setup proper defaults if cache is missing or lacking and requests updates when nodes are awake
Fix testing.

Author: dirixmjm

plugwise_usb/nodes/__init__.py

@@ -26,41 +26,47 @@ def get_plugwise_node(  # noqa: PLR0911
         return PlugwiseCirclePlus(
             mac,
             address,
+            node_type,
             controller,
             loaded_callback,
         )
     if node_type == NodeType.CIRCLE:
         return PlugwiseCircle(
             mac,
             address,
+            node_type,
             controller,
             loaded_callback,
         )
     if node_type == NodeType.SWITCH:
         return PlugwiseSwitch(
             mac,
             address,
+            node_type,
             controller,
             loaded_callback,
         )
     if node_type == NodeType.SENSE:
         return PlugwiseSense(
             mac,
             address,
+            node_type,
             controller,
             loaded_callback,
         )
     if node_type == NodeType.SCAN:
         return PlugwiseScan(
             mac,
             address,
+            node_type,
             controller,
             loaded_callback,
         )
     if node_type == NodeType.STEALTH:
         return PlugwiseStealth(
             mac,
             address,
+            node_type,
             controller,
             loaded_callback,
         )

plugwise_usb/nodes/circle.py

@@ -16,6 +16,7 @@
     NodeFeature,
     NodeInfo,
     NodeInfoMessage,
+    NodeType,
     PowerStatistics,
     RelayConfig,
     RelayLock,
@@ -81,11 +82,12 @@ def __init__(
         self,
         mac: str,
         address: int,
+        node_type: NodeType,
         controller: StickController,
         loaded_callback: Callable[[NodeEvent, str], Awaitable[None]],
     ):
         """Initialize base class for Sleeping End Device."""
-        super().__init__(mac, address, controller, loaded_callback)
+        super().__init__(mac, address, node_type, controller, loaded_callback)
 
         # Relay
         self._relay_lock: RelayLock = RelayLock()

plugwise_usb/nodes/node.py

@@ -48,7 +48,6 @@
 )
 
 CACHE_FIRMWARE = "firmware"
-CACHE_NODE_TYPE = "node_type"
 CACHE_HARDWARE = "hardware"
 CACHE_NODE_INFO_TIMESTAMP = "node_info_timestamp"
 CACHE_RELAY = "relay"
@@ -61,16 +60,22 @@ def __init__(
         self,
         mac: str,
         address: int,
+        node_type: NodeType,
         controller: StickController,
         loaded_callback: Callable[[NodeEvent, str], Awaitable[None]],
     ):
         """Initialize Plugwise base node class."""
         super().__init__()
+        self.node_type = node_type
         self._loaded_callback = loaded_callback
         self._message_subscribe = controller.subscribe_to_messages
         self._features: tuple[NodeFeature, ...] = NODE_FEATURES
         self._last_seen = datetime.now(tz=UTC)
-        self._node_info = NodeInfo(mac, address)
+        self._node_info = NodeInfo(
+            mac=mac,
+            zigbee_address=address,
+            node_type=self.node_type,
+        )
         self._ping = NetworkStatistics()
         self._mac_in_bytes = bytes(mac, encoding=UTF8)
         self._mac_in_str = mac
@@ -462,7 +467,6 @@ async def node_info_update(
             _LOGGER.debug("No response for node_info_update() for %s", self.mac)
             await self._available_update_state(False)
             return self._node_info
-
         await self._available_update_state(True, node_info.timestamp)
         await self.update_node_details(node_info)
         return self._node_info
@@ -475,16 +479,13 @@ async def _node_info_load_from_cache(self) -> bool:
 
         firmware = self._get_cache_as_datetime(CACHE_FIRMWARE)
         hardware = self._get_cache(CACHE_HARDWARE)
-        node_type: NodeType | None = None
-        if (node_type_str := self._get_cache(CACHE_NODE_TYPE)) is not None:
-            node_type = NodeType(int(node_type_str))
         relay_state = self._get_cache(CACHE_RELAY) == "True"
         timestamp = self._get_cache_as_datetime(CACHE_NODE_INFO_TIMESTAMP)
         node_info = NodeInfoMessage(
             current_logaddress_pointer=None,
             firmware=firmware,
             hardware=hardware,
-            node_type=node_type,
+            node_type=self.node_type,
             relay_state=relay_state,
             timestamp=timestamp,
         )
@@ -509,9 +510,6 @@ async def update_node_details(
         complete = True
         if node_info.node_type is None:
             complete = False
-        else:
-            self._node_info.node_type = NodeType(node_info.node_type)
-            self._set_cache(CACHE_NODE_TYPE, self._node_info.node_type.value)
 
         if node_info.firmware is None:
             complete = False

plugwise_usb/nodes/scan.py

@@ -9,7 +9,14 @@
 import logging
 from typing import Any, Final
 
-from ..api import MotionConfig, MotionSensitivity, MotionState, NodeEvent, NodeFeature
+from ..api import (
+    MotionConfig,
+    MotionSensitivity,
+    MotionState,
+    NodeEvent,
+    NodeFeature,
+    NodeType,
+)
 from ..connection import StickController
 from ..constants import MAX_UINT_2
 from ..exceptions import MessageError, NodeError, NodeTimeout
@@ -48,11 +55,20 @@
 # Light override
 SCAN_DEFAULT_DAYLIGHT_MODE: Final = False
 
+# Default firmware if not known
+DEFAULT_FIRMWARE: Final = datetime(2010, 11, 4, 16, 58, 46, tzinfo=UTC)
+
 # Sensitivity values for motion sensor configuration
 SENSITIVITY_HIGH_VALUE = 20  # 0x14
 SENSITIVITY_MEDIUM_VALUE = 30  # 0x1E
 SENSITIVITY_OFF_VALUE = 255  # 0xFF
 
+# Scan Features
+SCAN_FEATURES: Final = (
+    NodeFeature.MOTION,
+    NodeFeature.MOTION_CONFIG,
+)
+
 # endregion
 
 
@@ -63,11 +79,12 @@ def __init__(
         self,
         mac: str,
         address: int,
+        node_type: NodeType,
         controller: StickController,
         loaded_callback: Callable[[NodeEvent, str], Awaitable[None]],
     ):
         """Initialize Scan Device."""
-        super().__init__(mac, address, controller, loaded_callback)
+        super().__init__(mac, address, node_type, controller, loaded_callback)
         self._unsubscribe_switch_group: Callable[[], None] | None = None
         self._reset_timer_motion_on: datetime | None = None
         self._scan_subscription: Callable[[], None] | None = None
@@ -89,26 +106,17 @@ async def load(self) -> bool:
         """Load and activate Scan node features."""
         if self._loaded:
             return True
-        if self._cache_enabled:
-            _LOGGER.debug("Load Scan node %s from cache", self._node_info.mac)
-            await self._load_from_cache()
-        else:
-            self._load_defaults()
-        self._loaded = True
-        self._setup_protocol(
-            SCAN_FIRMWARE_SUPPORT,
-            (
-                NodeFeature.BATTERY,
-                NodeFeature.INFO,
-                NodeFeature.PING,
-                NodeFeature.MOTION,
-                NodeFeature.MOTION_CONFIG,
-            ),
-        )
+
+        _LOGGER.debug("Loading Scan node %s", self._node_info.mac)
+        if not await super().load():
+            _LOGGER.warning("Load Scan base node failed")
+            return False
+
+        self._setup_protocol(SCAN_FIRMWARE_SUPPORT, SCAN_FEATURES)
         if await self.initialize():
             await self._loaded_callback(NodeEvent.LOADED, self.mac)
             return True
-        _LOGGER.debug("Load of Scan node %s failed", self._node_info.mac)
+        _LOGGER.warning("Load Scan node %s failed", self._node_info.mac)
         return False
 
     @raise_not_loaded
@@ -132,9 +140,9 @@ async def unload(self) -> None:
         await super().unload()
 
     # region Caching
-    def _load_defaults(self) -> None:
+    async def _load_defaults(self) -> None:
         """Load default configuration settings."""
-        super()._load_defaults()
+        await super()._load_defaults()
         self._motion_state = MotionState(
             state=SCAN_DEFAULT_MOTION_STATE,
             timestamp=None,
@@ -144,11 +152,28 @@ def _load_defaults(self) -> None:
             daylight_mode=SCAN_DEFAULT_DAYLIGHT_MODE,
             sensitivity_level=SCAN_DEFAULT_SENSITIVITY,
         )
+        if self._node_info.model is None:
+            self._node_info.model = "Scan"
+            self.node_info_default = True
+        if self._node_info.name is None:
+            self._node_info.name = f"Scan {self._node_info.mac[-5:]}"
+            self.node_info_default = True
+        if self._node_info.name is None:
+            self._node_info.name = f"Scan {self._node_info.mac[-5:]}"
+            self.node_info_default = True
+        if self._node_info.firmware is None:
+            self._node_info.firmware = DEFAULT_FIRMWARE
+            self.node_info_default = True
+        self._new_reset_timer = SCAN_DEFAULT_MOTION_RESET_TIMER
+        self._new_daylight_mode = SCAN_DEFAULT_DAYLIGHT_MODE
+        self._new_sensitivity_level = SCAN_DEFAULT_SENSITIVITY
+        await self.schedule_task_when_awake(self._configure_scan_task())
+        self._scan_config_task_scheduled = True
 
     async def _load_from_cache(self) -> bool:
         """Load states from previous cached information. Returns True if successful."""
         if not await super()._load_from_cache():
-            self._load_defaults()
+            await self._load_defaults()
             return False
         self._motion_state = MotionState(
             state=self._motion_from_cache(),

plugwise_usb/nodes/sed.py

@@ -17,7 +17,7 @@
 import logging
 from typing import Any, Final
 
-from ..api import BatteryConfig, NodeEvent, NodeFeature, NodeInfo
+from ..api import BatteryConfig, NodeEvent, NodeFeature, NodeInfo, NodeType
 from ..connection import StickController
 from ..constants import MAX_UINT_2, MAX_UINT_4
 from ..exceptions import MessageError, NodeError
@@ -64,6 +64,12 @@
 # Time in minutes the SED will sleep
 SED_DEFAULT_SLEEP_DURATION: Final = 60
 
+# Default firmware if not known
+DEFAULT_FIRMWARE: Final = None
+
+# SED BaseNode Features
+SED_FEATURES: Final = (NodeFeature.BATTERY,)
+
 # Value limits
 MAX_MINUTE_INTERVAL: Final = 1440
 
@@ -83,11 +89,12 @@ def __init__(
         self,
         mac: str,
         address: int,
+        node_type: NodeType,
         controller: StickController,
         loaded_callback: Callable[[NodeEvent, str], Awaitable[None]],
     ):
         """Initialize base class for Sleeping End Device."""
-        super().__init__(mac, address, controller, loaded_callback)
+        super().__init__(mac, address, node_type, controller, loaded_callback)
         self._loop = get_running_loop()
         self._node_info.is_battery_powered = True
 
@@ -117,12 +124,8 @@ async def load(self) -> bool:
         else:
             self._load_defaults()
         self._loaded = True
-        self._features += (NodeFeature.BATTERY,)
-        if await self.initialize():
-            await self._loaded_callback(NodeEvent.LOADED, self.mac)
-            return True
-        _LOGGER.debug("Load of SED node %s failed", self._node_info.mac)
-        return False
+        self._features += SED_FEATURES
+        return True
 
     async def unload(self) -> None:
         """Deactivate and unload node features."""
@@ -156,7 +159,7 @@ async def initialize(self) -> bool:
         await super().initialize()
         return True
 
-    def _load_defaults(self) -> None:
+    async def _load_defaults(self) -> None:
         """Load default configuration settings."""
         self._battery_config = BatteryConfig(
             awake_duration=SED_DEFAULT_AWAKE_DURATION,
@@ -165,11 +168,15 @@ def _load_defaults(self) -> None:
             maintenance_interval=SED_DEFAULT_MAINTENANCE_INTERVAL,
             sleep_duration=SED_DEFAULT_SLEEP_DURATION,
         )
+        await self.schedule_task_when_awake(self.node_info_update(None))
+        self._sed_config_task_scheduled = True
+        self._new_battery_config = self._battery_config
+        await self.schedule_task_when_awake(self._configure_sed_task())
 
     async def _load_from_cache(self) -> bool:
         """Load states from previous cached information. Returns True if successful."""
         if not await super()._load_from_cache():
-            self._load_defaults()
+            await self._load_defaults()
             return False
         self._battery_config = BatteryConfig(
             awake_duration=self._awake_duration_from_cache(),
@@ -240,9 +247,6 @@ async def set_awake_duration(self, seconds: int) -> bool:
                 f"Invalid awake duration ({seconds}). It must be between 1 and 255 seconds."
             )
 
-        if self._battery_config.awake_duration == seconds:
-            return False
-
         self._new_battery_config = replace(
             self._new_battery_config, awake_duration=seconds
         )
@@ -491,7 +495,7 @@ async def node_info_update(
         self, node_info: NodeInfoResponse | None = None
     ) -> NodeInfo | None:
         """Update Node (hardware) information."""
-        if node_info is None and self.skip_update(self._node_info, 86400):
+        if node_info is not None and self.skip_update(self._node_info, 86400):
             return self._node_info
         return await super().node_info_update(node_info)
 
@@ -643,7 +647,6 @@ async def _send_tasks(self) -> None:
         """Send all tasks in queue."""
         if len(self._send_task_queue) == 0:
             return
-
         async with self._send_task_lock:
             task_result = await gather(*self._send_task_queue)
             if not all(task_result):