Refactor missing_addresses_after()

Author: bouwew

plugwise_usb/nodes/helpers/pulses.py

@@ -998,57 +998,45 @@ def _missing_addresses_before(
 
         return addresses
 
-    def _missing_addresses_after(
-        self, address: int, slot: int, target: datetime
-    ) -> list[int]:
-        """Return list of any missing address(es) after given log timestamp."""
-        addresses: list[int] = []
+def _missing_addresses_after(
+    self, address: int, slot: int, target: datetime
+) -> list[int]:
+    """Return list of missing address(es) after a given log timestamp."""
+    if self._logs is None:
+        return []
 
-        if self._logs is None:
-            return addresses
+    addresses: list[int] = []
 
-        # default interval
-        calc_interval_cons = timedelta(hours=1)
-        if (
-            self._log_interval_consumption is not None
-            and self._log_interval_consumption > 0
-        ):
-            # Use consumption interval
-            calc_interval_cons = timedelta(minutes=self._log_interval_consumption)
+    # Determine consumption and production intervals
+    def get_interval(config_value, default_hours):
+        return timedelta(minutes=config_value) if config_value and config_value > 0 else timedelta(hours=default_hours)
 
-        if not self._log_production:  # False
-            expected_timestamp = (
-                self._logs[address][slot].timestamp + calc_interval_cons
-            )
-            address, slot = calc_log_address(address, slot, 1)
-            while expected_timestamp < target:
-                address, slot = calc_log_address(address, slot, 1)
-                expected_timestamp += timedelta(hours=1)
-                if address not in addresses:
-                    addresses.append(address)
-            return addresses
+    interval_cons = get_interval(self._log_interval_consumption, 1)
+    interval_prod = get_interval(self._log_interval_production, 1)
 
-        # Production logging active
-        calc_interval_prod = timedelta(hours=1)
-        if (
-            self._log_interval_production is not None
-            and self._log_interval_production > 0
-        ):
-            calc_interval_prod = timedelta(minutes=self._log_interval_production)
+    # Initial timestamps
+    base_timestamp = self._logs[address][slot].timestamp
+    timestamp_cons = base_timestamp + interval_cons
+    timestamp_prod = base_timestamp + interval_prod
 
-        expected_timestamp_cons = (
-            self._logs[address][slot].timestamp + calc_interval_cons
-        )
-        expected_timestamp_prod = (
-            self._logs[address][slot].timestamp + calc_interval_prod
-        )
-        address, slot = calc_log_address(address, slot, 1)
-        while expected_timestamp_cons < target or expected_timestamp_prod < target:
+    address, slot = calc_log_address(address, slot, 1)
+
+    if not self._log_production:
+        # Only consumption interval is considered
+        while timestamp_cons < target:
             if address not in addresses:
                 addresses.append(address)
-            if expected_timestamp_prod < expected_timestamp_cons:
-                expected_timestamp_prod += calc_interval_prod
+            timestamp_cons += timedelta(hours=1)  # Always increment by 1 hour here
+            address, slot = calc_log_address(address, slot, 1)
+    else:
+        # Consider both consumption and production timestamps
+        while timestamp_cons < target or timestamp_prod < target:
+            if address not in addresses:
+                addresses.append(address)
+            if timestamp_prod < timestamp_cons:
+                timestamp_prod += interval_prod
             else:
-                expected_timestamp_cons += calc_interval_cons
+                timestamp_cons += interval_cons
             address, slot = calc_log_address(address, slot, 1)
-        return addresses
+
+    return addresses