Further reduce complexity of _logs_missing()

Author: bouwew

plugwise_usb/nodes/helpers/pulses.py

@@ -819,28 +819,44 @@ def _logs_missing(self, from_timestamp: datetime) -> list[int] | None:
         first = self._first_log_reference()
         last = self._last_log_reference()
 
-        if None in first or None in last:
-            _LOGGER.debug(
-                "_logs_missing | %s | first=%s, last=%s", self._mac, first, last
-            )
+        if not self._valid_log_references(first, last):
             return None
 
+        if self._is_single_unique_log(first, last):
+            return None
+
+        if (missing := self._find_missing_in_range(first, last, from_timestamp)):
+            return missing
+
         first_address, first_slot = first
-        last_address, last_slot = last
+        if not self._is_first_log_recent_enough(first_address, first_slot, from_timestamp):
+            return []
 
-        if (
-            first == last and
-            self._logs[first_address][first_slot].timestamp == self._logs[last_address][last_slot].timestamp
-        ):
-            return None  # Only one unique log, not enough to work with
+        return self._calculate_missing_before_first(first_address, first_slot, from_timestamp)
 
-        missing = []
-        _LOGGER.debug(
-            "_logs_missing | %s | first_address=%s, last_address=%s",
-            self._mac, first_address, last_address
+    # --- Helper Methods for _logs_missing() ---
+
+    def _valid_log_references(self, first, last) -> bool:
+        if None in first or None in last:
+            _LOGGER.debug("_logs_missing | %s | first=%s, last=%s", self._mac, first, last)
+            return False
+        return True
+
+    def _is_single_unique_log(self, first, last) -> bool:
+        if first != last:
+            return False
+
+        address, slot = first
+        return (
+            self._logs[address][slot].timestamp
+            == self._logs[last[0]][last[1]].timestamp
         )
 
-        # Check for missing logs in the collected range
+    def _find_missing_in_range(self, first, last, from_timestamp) -> list[int]:
+        first_address, first_slot = first
+        last_address, last_slot = last
+        missing = []
+
         address, slot = last_address, last_slot
         while (address, slot) != (first_address, first_slot):
             address, slot = calc_log_address(address, slot, -1)
@@ -853,49 +869,44 @@ def _logs_missing(self, from_timestamp: datetime) -> list[int] | None:
 
         if missing:
             _LOGGER.debug("_logs_missing | %s | missing in range=%s", self._mac, missing)
-            return missing
-
-        # Check if first slot exists and is recent enough
-        if (
-            first_address not in self._logs or
-            first_slot not in self._logs[first_address] or
-            self._logs[first_address][first_slot].timestamp < from_timestamp
-        ):
-            return []
+        return missing
 
-        # Estimate log interval
-        log_interval = self._log_interval_consumption or self._log_interval_production
-        if (
-            self._log_interval_production is not None and
-            log_interval is not None and
-            self._log_interval_production < log_interval
-        ):
-            log_interval = self._log_interval_production
+    def _is_first_log_recent_enough(self, address, slot, from_timestamp) -> bool:
+        return (
+            address in self._logs and
+            slot in self._logs[address] and
+            self._logs[address][slot].timestamp >= from_timestamp
+        )
 
-        if log_interval is None:
+    def _calculate_missing_before_first(self, first_address, first_slot, from_timestamp) -> list[int] | None:
+        if (log_interval := self._get_log_interval()) is None:
             return None
 
-        # Walk backward before the first known log to find additional missing logs
         timestamp = self._logs[first_address][first_slot].timestamp
         calc_timestamp = timestamp - timedelta(minutes=log_interval)
         address, slot = calc_log_address(first_address, first_slot, -1)
 
-        _LOGGER.debug(
-            "_logs_missing | %s | calculated timestamp=%s", self._mac, calc_timestamp
-        )
-
+        missing = []
         while calc_timestamp > from_timestamp:
             if (address, slot) == (self._first_empty_log_address, self._first_empty_log_slot):
                 break
-            if address not in missing:
-                missing.append(address)
+            missing = update_addresses(address, missing)
             calc_timestamp -= timedelta(minutes=log_interval)
             address, slot = calc_log_address(address, slot, -1)
 
         missing.sort(reverse=True)
         _LOGGER.debug("_logs_missing | %s | calculated missing=%s", self._mac, missing)
         return missing
 
+    def _get_log_interval(self) -> int | None:
+        log_interval = self._log_interval_consumption or self._log_interval_production
+        if (
+            self._log_interval_production is not None and
+            log_interval is not None and
+            self._log_interval_production < log_interval
+        ):
+            log_interval = self._log_interval_production
+        return log_interval
 
     def _last_known_duration(self) -> timedelta:
         """Duration for last known logs."""