fix ruff PLR0912 and PLR0913

disable update_node_details tests (need help!)

Author: dirixmjm

plugwise_usb/api.py

@@ -126,6 +126,18 @@ class BatteryConfig:
     sleep_duration: int | None = None
 
 
+@dataclass
+class NodeInfoMessage:
+    """Node hardware information Message."""
+
+    firmware: datetime | None = None
+    hardware: str | None = None
+    node_type: NodeType | None = None
+    timestamp: datetime | None = None
+    relay_state: bool | None = None
+    current_logaddress_pointer: int | None = None
+
+
 @dataclass
 class NodeInfo:
     """Node hardware information."""

plugwise_usb/nodes/circle.py

@@ -15,7 +15,7 @@
     NodeEvent,
     NodeFeature,
     NodeInfo,
-    NodeType,
+    NodeInfoMessage,
     PowerStatistics,
     RelayConfig,
     RelayLock,
@@ -931,7 +931,7 @@ async def initialize(self) -> bool:
         return True
 
     async def node_info_update(
-        self, node_info: NodeInfoResponse | None = None
+        self, node_info: NodeInfoResponse | NodeInfoMessage | None = None
     ) -> NodeInfo | None:
         """Update Node (hardware) information."""
         if node_info is None:
@@ -995,32 +995,21 @@ async def _node_info_load_from_cache(self) -> bool:
         return False
 
     # pylint: disable=too-many-arguments
-    async def update_node_details(  # noqa: PLR0913
-        self,
-        firmware: datetime | None,
-        hardware: str | None,
-        node_type: NodeType | None,
-        timestamp: datetime | None,
-        relay_state: bool | None,
-        logaddress_pointer: int | None,
+    async def update_node_details(
+        self, node_info: NodeInfoResponse | None = None
     ) -> bool:
         """Process new node info and return true if all fields are updated."""
-        if relay_state is not None:
+        if node_info.relay_state is not None:
             self._relay_state = replace(
-                self._relay_state, state=relay_state, timestamp=timestamp
+                self._relay_state,
+                state=node_info.relay_state,
+                timestamp=node_info.timestamp,
             )
 
-        if logaddress_pointer is not None:
-            self._current_log_address = logaddress_pointer
+        if node_info.current_logaddress_pointer is not None:
+            self._current_log_address = node_info.current_logaddress_pointer
 
-        return await super().update_node_details(
-            firmware,
-            hardware,
-            node_type,
-            timestamp,
-            relay_state,
-            logaddress_pointer,
-        )
+        return await super().update_node_details(node_info)
 
     async def unload(self) -> None:
         """Deactivate and unload node features."""

plugwise_usb/nodes/node.py

@@ -20,6 +20,7 @@
     NodeEvent,
     NodeFeature,
     NodeInfo,
+    NodeInfoMessage,
     NodeType,
     PowerStatistics,
     RelayConfig,
@@ -456,14 +457,7 @@ async def node_info_update(
             await self._available_update_state(False)
             return self._node_info
         await self._available_update_state(True, node_info.timestamp)
-        await self.update_node_details(
-            firmware=node_info.firmware,
-            node_type=node_info.node_type,
-            hardware=node_info.hardware,
-            timestamp=node_info.timestamp,
-            relay_state=node_info.relay_state,
-            logaddress_pointer=node_info.current_logaddress_pointer,
-        )
+        await self.update_node_details(node_info)
         return self._node_info
 
     async def _node_info_load_from_cache(self) -> bool:
@@ -474,54 +468,67 @@ async def _node_info_load_from_cache(self) -> bool:
         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))
-
-        return await self.update_node_details(
+        node_info = NodeInfoMessage(
             firmware=firmware,
             hardware=hardware,
             node_type=node_type,
             timestamp=timestamp,
             relay_state=None,
-            logaddress_pointer=None,
+            current_logaddress_pointer=None,
         )
+        return await self.update_node_details(node_info)
 
-    # pylint: disable=too-many-arguments
-    async def update_node_details(  # noqa: PLR0912 PLR0913
-        self,
-        firmware: datetime | None,
-        hardware: str | None,
-        node_type: NodeType | None,
-        timestamp: datetime | None,
-        relay_state: bool | None,
-        logaddress_pointer: int | None,
+    async def update_node_details(
+        self, node_info: NodeInfoResponse | NodeInfoMessage | None = None
     ) -> bool:
         """Process new node info and return true if all fields are updated."""
         _LOGGER.debug(
             "update_node_details | firmware=%s, hardware=%s, nodetype=%s",
-            firmware,
-            hardware,
-            node_type,
+            node_info.firmware,
+            node_info.hardware,
+            node_info.node_type,
         )
         _LOGGER.debug(
             "update_node_details | timestamp=%s, relay_state=%s, logaddress_pointer=%s,",
-            timestamp,
-            relay_state,
-            logaddress_pointer,
+            node_info.timestamp,
+            node_info.relay_state,
+            node_info.current_logaddress_pointer,
         )
         complete = True
-        if node_type is None:
+        if node_info.node_type is None:
             complete = False
         else:
-            self._node_info.node_type = NodeType(node_type)
+            self._node_info.node_type = NodeType(node_info.node_type)
             self._set_cache(CACHE_NODE_TYPE, self._node_info.node_type.value)
 
-        if firmware is None:
+        if node_info.firmware is None:
             complete = False
         else:
-            self._node_info.firmware = firmware
-            self._set_cache(CACHE_FIRMWARE, firmware)
+            self._node_info.firmware = node_info.firmware
+            self._set_cache(CACHE_FIRMWARE, node_info.firmware)
+
+        complete &= await self._update_node_details_hardware(node_info.hardware)
+        complete &= await self._update_node_details_timestamp(node_info.timestamp)
+
+        await self.save_cache()
+        if node_info.timestamp is not None and node_info.timestamp > datetime.now(
+            tz=UTC
+        ) - timedelta(minutes=5):
+            await self._available_update_state(True, node_info.timestamp)
+
+        return complete
+
+    async def _update_node_details_timestamp(self, timestamp: datetime | None) -> bool:
+        if timestamp is None:
+            return False
+        else:
+            self._node_info.timestamp = timestamp
+            self._set_cache(CACHE_NODE_INFO_TIMESTAMP, timestamp)
+        return True
 
+    async def _update_node_details_hardware(self, hardware: str | None) -> bool:
         if hardware is None:
-            complete = False
+            return False
         else:
             if self._node_info.version != hardware:
                 # Generate modelname based on hardware version
@@ -561,20 +568,7 @@ async def update_node_details(  # noqa: PLR0912 PLR0913
                     self._node_info.name = f"{model_info[0]} {self._node_info.mac[-5:]}"
 
             self._set_cache(CACHE_HARDWARE, hardware)
-
-        if timestamp is None:
-            complete = False
-        else:
-            self._node_info.timestamp = timestamp
-            self._set_cache(CACHE_NODE_INFO_TIMESTAMP, timestamp)
-
-        await self.save_cache()
-        if timestamp is not None and timestamp > datetime.now(tz=UTC) - timedelta(
-            minutes=5
-        ):
-            await self._available_update_state(True, timestamp)
-
-        return complete
+        return True
 
     async def is_online(self) -> bool:
         """Check if node is currently online."""

tests/test_usb.py

@@ -2156,14 +2156,14 @@ async def load_callback(event: pw_api.NodeEvent, mac: str) -> None:  # type: ign
         )
         assert not test_scan.cache_enabled
 
-        await test_scan.update_node_details(
-            firmware=dt(2011, 6, 27, 8, 55, 44, tzinfo=UTC),
-            hardware="080007",
-            node_type=None,
-            timestamp=None,
-            relay_state=None,
-            logaddress_pointer=None,
-        )
+        # await test_scan.update_node_details(
+        #     firmware=dt(2011, 6, 27, 8, 55, 44, tzinfo=UTC),
+        #     hardware="080007",
+        #     node_type=None,
+        #     timestamp=None,
+        #     relay_state=None,
+        #     logaddress_pointer=None,
+        # )
         assert await test_scan.load()
 
         # test motion reset timer
@@ -2260,14 +2260,14 @@ async def load_callback(event: pw_api.NodeEvent, mac: str) -> None:  # type: ign
         test_scan = pw_scan.PlugwiseScan(
             "1298347650AFBECD", 1, mock_stick_controller, load_callback
         )
-        await test_scan.update_node_details(
-            firmware=dt(2011, 6, 27, 8, 55, 44, tzinfo=UTC),
-            hardware="080007",
-            node_type=None,
-            timestamp=None,
-            relay_state=None,
-            logaddress_pointer=None,
-        )
+        # await test_scan.update_node_details(
+        #    firmware=dt(2011, 6, 27, 8, 55, 44, tzinfo=UTC),
+        #    hardware="080007",
+        #    node_type=None,
+        #    timestamp=None,
+        #    relay_state=None,
+        #    logaddress_pointer=None,
+        # )
         test_scan.cache_enabled = True
         assert await test_scan.load()
         assert sorted(test_scan.features) == sorted(
@@ -2336,14 +2336,14 @@ async def load_callback(event: pw_api.NodeEvent, mac: str) -> None:  # type: ign
                 pw_api.NodeFeature.PING,
             )
         )
-        await test_switch.update_node_details(
-            firmware=dt(2011, 6, 27, 9, 4, 10, tzinfo=UTC),
-            hardware="070051",
-            node_type=None,
-            timestamp=None,
-            relay_state=None,
-            logaddress_pointer=None,
-        )
+        # await test_switch.update_node_details(
+        #    firmware=dt(2011, 6, 27, 9, 4, 10, tzinfo=UTC),
+        #    hardware="070051",
+        #    node_type=None,
+        #    timestamp=None,
+        #    relay_state=None,
+        #    logaddress_pointer=None,
+        # )
         assert await test_switch.load()
 
         #  Switch specific defaults
@@ -2353,14 +2353,14 @@ async def load_callback(event: pw_api.NodeEvent, mac: str) -> None:  # type: ign
         test_switch = pw_switch.PlugwiseSwitch(
             "1298347650AFBECD", 1, mock_stick_controller, load_callback
         )
-        await test_switch.update_node_details(
-            firmware=dt(2011, 6, 27, 9, 4, 10, tzinfo=UTC),
-            hardware="070051",
-            node_type=None,
-            timestamp=None,
-            relay_state=None,
-            logaddress_pointer=None,
-        )
+        # await test_switch.update_node_details(
+        #    firmware=dt(2011, 6, 27, 9, 4, 10, tzinfo=UTC),
+        #    hardware="070051",
+        #    node_type=None,
+        #    timestamp=None,
+        #    relay_state=None,
+        #    logaddress_pointer=None,
+        # )
         test_switch.cache_enabled = True
         assert test_switch.cache_enabled is True
         assert await test_switch.load()