Merge pull request #295 from plugwise/mdi_sed2

Streamline of loading SED nodes.

Author: dirixmjm

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## ONGOING
+
+- PR [295](https://github.com/plugwise/python-plugwise-usb/pull/295): Streamline of loading function, to allow nodes to load even if temporarily offline, especially for SED nodes.
+
 ## v0.44.8
 
 - PR [291](https://github.com/plugwise/python-plugwise-usb/pull/291): Collect send-queue depth via PriorityQueue.qsize(), this provides a more accurate result

plugwise_usb/network/__init__.py

@@ -481,15 +481,14 @@ async def _load_node(self, mac: str) -> bool:
             return False
         if self._nodes[mac].is_loaded:
             return True
-        if await self._nodes[mac].load():
-            await self._notify_node_event_subscribers(NodeEvent.LOADED, mac)
-            return True
-        return False
+        await self._nodes[mac].load()
+        await self._notify_node_event_subscribers(NodeEvent.LOADED, mac)
+        return True
 
     async def _load_stragglers(self) -> None:
         """Retry failed load operation."""
         await sleep(NODE_RETRY_LOAD_INTERVAL)
-        while not self._load_discovered_nodes():
+        while not await self._load_discovered_nodes():
             await sleep(NODE_RETRY_LOAD_INTERVAL)
 
     async def _load_discovered_nodes(self) -> bool:

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

@@ -8,14 +8,15 @@
 from datetime import UTC, datetime
 from functools import wraps
 import logging
-from typing import Any, TypeVar, cast
+from typing import Any, Final, TypeVar, cast
 
 from ..api import (
     EnergyStatistics,
     NodeEvent,
     NodeFeature,
     NodeInfo,
     NodeInfoMessage,
+    NodeType,
     PowerStatistics,
     RelayConfig,
     RelayLock,
@@ -58,6 +59,19 @@
 CACHE_RELAY_INIT = "relay_init"
 CACHE_RELAY_LOCK = "relay_lock"
 
+CIRCLE_FEATURES: Final = (
+    NodeFeature.CIRCLE,
+    NodeFeature.RELAY,
+    NodeFeature.RELAY_INIT,
+    NodeFeature.RELAY_LOCK,
+    NodeFeature.ENERGY,
+    NodeFeature.POWER,
+)
+
+
+# Default firmware if not known
+DEFAULT_FIRMWARE: Final = datetime(2008, 8, 26, 15, 46, tzinfo=UTC)
+
 FuncT = TypeVar("FuncT", bound=Callable[..., Any])
 _LOGGER = logging.getLogger(__name__)
 
@@ -81,11 +95,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()
@@ -882,10 +897,10 @@ async def clock_synchronize(self) -> bool:
             return True
         return False
 
-    async def load(self) -> bool:
+    async def load(self) -> None:
         """Load and activate Circle node features."""
         if self._loaded:
-            return True
+            return
 
         if self._cache_enabled:
             _LOGGER.debug("Loading Circle node %s from cache", self._mac_in_str)
@@ -895,37 +910,20 @@ async def load(self) -> bool:
             _LOGGER.debug("Retrieving Info For Circle node %s", self._mac_in_str)
 
             # Check if node is online
-            if not self._available and not await self.is_online():
-                _LOGGER.debug(
-                    "Failed to load Circle node %s because it is not online",
-                    self._mac_in_str,
-                )
-                return False
-
-            # Get node info
-            if await self.node_info_update() is None:
+            if (
+                not self._available and not await self.is_online()
+            ) or await self.node_info_update() is None:
                 _LOGGER.debug(
-                    "Failed to load Circle node %s because it is not responding to information request",
+                    "Failed to retrieve NodeInfo for %s, loading defaults",
                     self._mac_in_str,
                 )
-                return False
+                await self._load_defaults()
 
-            self._loaded = True
+        self._loaded = True
 
-        self._setup_protocol(
-            CIRCLE_FIRMWARE_SUPPORT,
-            (
-                NodeFeature.CIRCLE,
-                NodeFeature.RELAY,
-                NodeFeature.RELAY_INIT,
-                NodeFeature.RELAY_LOCK,
-                NodeFeature.ENERGY,
-                NodeFeature.POWER,
-            ),
-        )
+        self._setup_protocol(CIRCLE_FIRMWARE_SUPPORT, CIRCLE_FEATURES)
         await self._loaded_callback(NodeEvent.LOADED, self.mac)
         await self.initialize()
-        return True
 
     async def _load_from_cache(self) -> bool:
         """Load states from previous cached information. Returns True if successful."""
@@ -972,6 +970,15 @@ async def _load_from_cache(self) -> bool:
 
         return result
 
+    async def _load_defaults(self) -> None:
+        """Load default configuration settings."""
+        if self._node_info.model is None:
+            self._node_info.model = "Circle"
+        if self._node_info.name is None:
+            self._node_info.name = f"Circle {self._node_info.mac[-5:]}"
+        if self._node_info.firmware is None:
+            self._node_info.firmware = DEFAULT_FIRMWARE
+
     @raise_not_loaded
     async def initialize(self) -> bool:
         """Initialize node."""

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