More improvements

Author: bouwew

plugwise_usb/messages/requests.py

@@ -202,7 +202,7 @@ def start_response_timeout(self) -> None:
 
     def stop_response_timeout(self) -> None:
         """Stop timeout for node response."""
-        self._waiting_for_response = True
+        self._waiting_for_response = False
         if self._response_timeout is not None:
             self._response_timeout.cancel()
 
@@ -1231,13 +1231,13 @@ def __init__(
     async def send(self) -> NodeResponse | None:
         """Send request."""
         result = await self._send_request()
-        _LOGGER.warning("NodeSleepConfigRequest result: %s", result)
+        _LOGGER.debug("NodeSleepConfigRequest result: %s", result)
         if isinstance(result, NodeResponse):
             return result
         if result is None:
             return None
         raise MessageError(
-            f"Invalid response message. Received {result.__class__.__name__}, expected NodeAckResponse"
+            f"Invalid response message. Received {result.__class__.__name__}, expected NodeResponse"
         )
 
     def __repr__(self) -> str:

plugwise_usb/network/registry.py

@@ -128,8 +128,10 @@ async def load_registry_from_cache(self) -> None:
                 "Unable to restore network registry because cache is not initialized"
             )
             return
+
         if self._cache_restored:
             return
+
         for address, registration in self._network_cache.registrations.items():
             mac, node_type = registration
             if self._registry.get(address) is None:
@@ -259,12 +261,12 @@ async def register_node(self, mac: str) -> None:
         try:
             await request.send()
         except StickError as exc:
-            raise NodeError("{exc}") from exc
+            raise NodeError(f"{exc}") from exc
 
     async def unregister_node(self, mac: str) -> None:
         """Unregister node from current Plugwise network."""
         if not validate_mac(mac):
-            raise NodeError(f"MAC '{mac}' invalid")
+            raise NodeError(f"MAC {mac} invalid")
 
         mac_registered = False
         for registration in self._registry.values():

plugwise_usb/nodes/circle.py

@@ -822,14 +822,14 @@ async def _load_from_cache(self) -> bool:
         # Relay
         if await self._relay_load_from_cache():
             _LOGGER.debug(
-                "Node %s failed to load relay state from cache",
+                "Node %s successfully loaded relay state from cache",
                 self._mac_in_str,
             )
         # Relay init config if feature is enabled
         if NodeFeature.RELAY_INIT in self._features:
             if await self._relay_init_load_from_cache():
                 _LOGGER.debug(
-                    "Node %s failed to load relay_init state from cache",
+                    "Node %s successfully loaded relay_init state from cache",
                     self._mac_in_str,
                 )
         return True

plugwise_usb/nodes/helpers/pulses.py

@@ -824,7 +824,7 @@ def _logs_missing(self, from_timestamp: datetime) -> list[int] | None:
                 "The Circle %s does not overwrite old logged data, please reset the Circle's energy-logs via Source",
                 self._mac,
             )
-            return
+            return None
 
         if (
             last_address == first_address

plugwise_usb/nodes/node.py

@@ -618,15 +618,22 @@ def _get_cache_as_datetime(self, setting: str) -> datetime | None:
         if (timestamp_str := self._get_cache(setting)) is not None:
             data = timestamp_str.split("-")
             if len(data) == 6:
-                return datetime(
-                    year=int(data[0]),
-                    month=int(data[1]),
-                    day=int(data[2]),
-                    hour=int(data[3]),
-                    minute=int(data[4]),
-                    second=int(data[5]),
-                    tzinfo=UTC,
-                )
+                try:
+                    return datetime(
+                        year=int(data[0]),
+                        month=int(data[1]),
+                        day=int(data[2]),
+                        hour=int(data[3]),
+                        minute=int(data[4]),
+                        second=int(data[5]),
+                        tzinfo=UTC,
+                    )
+                except ValueError:
+                    _LOGGER.warning(
+                        "Invalid datetime format in cache for setting %s: %s",
+                        setting,
+                        timestamp_str,
+                    )
         return None
 
     def _set_cache(self, setting: str, value: Any) -> None:

plugwise_usb/nodes/scan.py

@@ -47,6 +47,11 @@
 # Light override
 SCAN_DEFAULT_DAYLIGHT_MODE: Final = False
 
+# Sensitivity values for motion sensor configuration
+SENSITIVITY_HIGH_VALUE = 20  # 0x14
+SENSITIVITY_MEDIUM_VALUE = 30  # 0x1E  
+SENSITIVITY_OFF_VALUE = 255  # 0xFF
+
 # endregion
 
 
@@ -169,7 +174,7 @@ def _motion_from_cache(self) -> bool:
             if (
                 cached_motion_state == "True"
                 and (motion_timestamp := self._motion_timestamp_from_cache()) is not None
-                and (datetime.now(tz=UTC) - motion_timestamp).seconds < self._reset_timer_from_cache() * 60
+                and (datetime.now(tz=UTC) - motion_timestamp).total_seconds < self._reset_timer_from_cache() * 60
             ):
                 return True
             return False
@@ -378,7 +383,7 @@ async def _motion_state_update(
             self._set_cache(CACHE_MOTION_STATE, "False")
             if self._motion_state.state is None or self._motion_state.state:
                 if self._reset_timer_motion_on is not None:
-                    reset_timer = (timestamp - self._reset_timer_motion_on).seconds
+                    reset_timer = (timestamp - self._reset_timer_motion_on).total_seconds
                     if self._motion_config.reset_timer is None:
                         self._motion_config = replace(
                             self._motion_config,
@@ -465,11 +470,12 @@ async def scan_configure(
     ) -> bool:
         """Configure Scan device settings. Returns True if successful."""
         # Default to medium:
-        sensitivity_value = 30  # b'1E'
-        if sensitivity_level == MotionSensitivity.HIGH:
-            sensitivity_value = 20  # b'14'
-        if sensitivity_level == MotionSensitivity.OFF:
-            sensitivity_value = 255  # b'FF'
+        sensitivity_value = SENSITIVITY_MEDIUM_VALUE
+        sensitivity_map = {
+            MotionSensitivity.HIGH: SENSITIVITY_HIGH_VALUE,
+            MotionSensitivity.OFF: SENSITIVITY_OFF_VALUE,
+        }
+        sensitivity_value = sensitivity_map.get(sensitivity_level, SENSITIVITY_MEDIUM_VALUE)
         request = ScanConfigureRequest(
             self._send,
             self._mac_in_bytes,

plugwise_usb/nodes/sense.py

@@ -52,9 +52,10 @@ async def load(self) -> bool:
         """Load and activate Sense node features."""
         if self._loaded:
             return True
+
         self._node_info.is_battery_powered = True
         if self._cache_enabled:
-            _LOGGER.debug("Load Sense node %s from cache", self._node_info.mac)
+            _LOGGER.debug("Loading Sense node %s from cache", self._node_info.mac)
             if await self._load_from_cache():
                 self._loaded = True
                 self._setup_protocol(
@@ -64,7 +65,8 @@ async def load(self) -> bool:
                 if await self.initialize():
                     await self._loaded_callback(NodeEvent.LOADED, self.mac)
                     return True
-        _LOGGER.debug("Load of Sense node %s failed", self._node_info.mac)
+
+        _LOGGER.debug("Loading of Sense node %s failed", self._node_info.mac)
         return False
 
     @raise_not_loaded
@@ -94,6 +96,7 @@ async def _sense_report(self, response: PlugwiseResponse) -> bool:
             raise MessageError(
                 f"Invalid response message type ({response.__class__.__name__}) received, expected SenseReportResponse"
             )
+        report_received = False
         await self._available_update_state(True, response.timestamp)
         if response.temperature.value != 65535:
             self._temperature = int(
@@ -103,6 +106,8 @@ async def _sense_report(self, response: PlugwiseResponse) -> bool:
             await self.publish_feature_update_to_subscribers(
                 NodeFeature.TEMPERATURE, self._temperature
             )
+            report_received = True
+
         if response.humidity.value != 65535:
             self._humidity = int(
                 SENSE_HUMIDITY_MULTIPLIER * (response.humidity.value / 65536)
@@ -111,8 +116,9 @@ async def _sense_report(self, response: PlugwiseResponse) -> bool:
             await self.publish_feature_update_to_subscribers(
                 NodeFeature.HUMIDITY, self._humidity
             )
-            return True
-        return False
+            report_received = True
+    
+        return report_received
 
     @raise_not_loaded
     async def get_state(self, features: tuple[NodeFeature]) -> dict[NodeFeature, Any]: