Change load() to return None in all cases

Author: dirixmjm

plugwise_usb/network/__init__.py

@@ -481,10 +481,9 @@ 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."""

plugwise_usb/nodes/circle.py

@@ -8,7 +8,7 @@
 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,
@@ -59,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__)
 
@@ -877,10 +890,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)
@@ -890,34 +903,18 @@ 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
@@ -967,6 +964,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/scan.py

@@ -102,34 +102,30 @@ def __init__(
 
     # region Load & Initialize
 
-    async def load(self) -> bool:
+    async def load(self) -> None:
         """Load and activate Scan node features."""
         if self._loaded:
-            return True
+            return
 
         _LOGGER.debug("Loading Scan node %s", self._node_info.mac)
         await super().load()
 
         self._setup_protocol(SCAN_FIRMWARE_SUPPORT, SCAN_FEATURES)
-        if await self.initialize():
-            await self._loaded_callback(NodeEvent.LOADED, self.mac)
-            return True
-        _LOGGER.warning("Load Scan node %s failed", self._node_info.mac)
-        return False
+        await self.initialize()
+        await self._loaded_callback(NodeEvent.LOADED, self.mac)
 
     @raise_not_loaded
-    async def initialize(self) -> bool:
+    async def initialize(self) -> None:
         """Initialize Scan node."""
         if self._initialized:
-            return True
+            return
 
         self._unsubscribe_switch_group = await self._message_subscribe(
             self._switch_group,
             self._mac_in_bytes,
             (NODE_SWITCH_GROUP_ID,),
         )
         await super().initialize()
-        return True
 
     async def unload(self) -> None:
         """Unload node."""

plugwise_usb/nodes/sed.py

@@ -114,10 +114,11 @@ def __init__(
         self._maintenance_last_awake: datetime | None = None
         self._maintenance_interval_restored_from_cache = False
 
-    async def load(self) -> None:
+    async def load(self) -> bool:
         """Load and activate SED node features."""
         if self._loaded:
-            return
+            return True
+
         _LOGGER.debug("Load SED node %s from cache", self._node_info.mac)
         if await self._load_from_cache():
             self._loaded = True
@@ -126,6 +127,7 @@ async def load(self) -> None:
             await self._load_defaults()
         self._loaded = True
         self._features += SED_FEATURES
+        return self._loaded
 
     async def unload(self) -> None:
         """Deactivate and unload node features."""
@@ -146,18 +148,17 @@ async def unload(self) -> None:
         await super().unload()
 
     @raise_not_loaded
-    async def initialize(self) -> bool:
+    async def initialize(self) -> None:
         """Initialize SED node."""
         if self._initialized:
-            return True
+            return
 
         self._awake_subscription = await self._message_subscribe(
             self._awake_response,
             self._mac_in_bytes,
             (NODE_AWAKE_RESPONSE_ID,),
         )
         await super().initialize()
-        return True
 
     async def _load_defaults(self) -> None:
         """Load default configuration settings."""

plugwise_usb/nodes/sense.py

@@ -53,35 +53,30 @@ def __init__(
 
         self._sense_subscription: Callable[[], None] | None = None
 
-    async def load(self) -> bool:
+    async def load(self) -> None:
         """Load and activate Sense node features."""
         if self._loaded:
-            return True
+            return
 
         _LOGGER.debug("Loading Sense node %s", self._node_info.mac)
         await super().load()
 
         self._setup_protocol(SENSE_FIRMWARE_SUPPORT, SENSE_FEATURES)
-        if await self.initialize():
-            await self._loaded_callback(NodeEvent.LOADED, self.mac)
-            return True
-
-        _LOGGER.warning("Load Sense node %s failed", self._node_info.mac)
-        return False
+        await self.initialize()
+        await self._loaded_callback(NodeEvent.LOADED, self.mac)
 
     @raise_not_loaded
-    async def initialize(self) -> bool:
+    async def initialize(self) -> None:
         """Initialize Sense node."""
         if self._initialized:
-            return True
+            return
 
         self._sense_subscription = await self._message_subscribe(
             self._sense_report,
             self._mac_in_bytes,
             (SENSE_REPORT_ID,),
         )
         await super().initialize()
-        return True
 
     async def unload(self) -> None:
         """Unload node."""

plugwise_usb/nodes/switch.py

@@ -46,35 +46,30 @@ def __init__(
         self._switch_subscription: Callable[[], None] | None = None
         self._switch = SwitchGroup()
 
-    async def load(self) -> bool:
+    async def load(self) -> None:
         """Load and activate Switch node features."""
         if self._loaded:
-            return True
+            return
 
         _LOGGER.debug("Loading Switch node %s", self._node_info.mac)
         await super().load()
 
         self._setup_protocol(SWITCH_FIRMWARE_SUPPORT, SWITCH_FEATURES)
-        if await self.initialize():
-            await self._loaded_callback(NodeEvent.LOADED, self.mac)
-            return True
-
-        _LOGGER.warning("Load Switch node %s failed", self._node_info.mac)
-        return False
+        await self.initialize()
+        await self._loaded_callback(NodeEvent.LOADED, self.mac)
 
     @raise_not_loaded
-    async def initialize(self) -> bool:
+    async def initialize(self) -> None:
         """Initialize Switch node."""
         if self._initialized:
-            return True
+            return
 
         self._switch_subscription = await self._message_subscribe(
             self._switch_response,
             self._mac_in_bytes,
             (NODE_SWITCH_GROUP_ID,),
         )
         await super().initialize()
-        return True
 
     async def unload(self) -> None:
         """Unload node."""

tests/test_usb.py

@@ -575,7 +575,7 @@ async def test_stick_node_discovered_subscription(
         assert mac_awake_node == "5555555555555555"
         unsub_awake()
 
-        assert await stick.nodes["5555555555555555"].load()
+        assert await stick.nodes["5555555555555555"].load() is None
         assert stick.nodes["5555555555555555"].node_info.firmware == dt(
             2011, 6, 27, 8, 55, 44, tzinfo=UTC
         )
@@ -1691,7 +1691,6 @@ async def makedirs(cache_dir: str, exist_ok: bool) -> None:
                 "FEDCBA9876543210": pw_api.NodeType.CIRCLE,
                 "1298347650AFBECD": pw_api.NodeType.SCAN,
             }
-        pw_nw_cache.update_nodetypes("1234ABCD4321FEDC", pw_api.NodeType.STEALTH)
 
         with patch("aiofiles.threadpool.sync_open", return_value=mock_file_stream):
             # await pw_nw_cache.save_cache()
@@ -1952,7 +1951,7 @@ async def load_callback(event: pw_api.NodeEvent, mac: str) -> None:  # type: ign
 
         assert test_sed.node_info.is_battery_powered
         assert test_sed.is_battery_powered
-        assert await test_sed.load() is None
+        assert await test_sed.load()
         assert sorted(test_sed.features) == sorted(
             (
                 pw_api.NodeFeature.AVAILABLE,
@@ -2169,7 +2168,7 @@ async def load_callback(event: pw_api.NodeEvent, mac: str) -> None:  # type: ign
             relay_state=None,
         )
         await test_scan.update_node_details(node_info)
-        assert await test_scan.load()
+        assert await test_scan.load() is None
 
         # test motion reset timer
         assert test_scan.reset_timer == 10
@@ -2278,7 +2277,7 @@ async def load_callback(event: pw_api.NodeEvent, mac: str) -> None:  # type: ign
         )
         await test_scan.update_node_details(node_info)
         test_scan.cache_enabled = True
-        assert await test_scan.load()
+        await test_scan.load()
         assert sorted(test_scan.features) == sorted(
             (
                 pw_api.NodeFeature.AVAILABLE,
@@ -2357,7 +2356,7 @@ async def load_callback(event: pw_api.NodeEvent, mac: str) -> None:  # type: ign
             relay_state=None,
         )
         await test_switch.update_node_details(node_info)
-        assert await test_switch.load()
+        await test_switch.load()
 
         #  Switch specific defaults
         assert test_switch.switch is False
@@ -2380,7 +2379,7 @@ async def load_callback(event: pw_api.NodeEvent, mac: str) -> None:  # type: ign
         await test_switch.update_node_details(node_info)
         test_switch.cache_enabled = True
         assert test_switch.cache_enabled is True
-        assert await test_switch.load()
+        await test_switch.load()
         assert sorted(test_switch.features) == sorted(
             (
                 pw_api.NodeFeature.AVAILABLE,