Refactor missing_addresses_after()

Author: bouwew

plugwise_usb/nodes/helpers/pulses.py

@@ -1001,54 +1001,42 @@ def _missing_addresses_before(
     def _missing_addresses_after(
         self, address: int, slot: int, target: datetime
     ) -> list[int]:
-        """Return list of any missing address(es) after given log timestamp."""
+        """Return list of missing address(es) after a given log timestamp."""
+        if self._logs is None:
+            return []
+
         addresses: list[int] = []
 
-        if self._logs is None:
-            return addresses
+        # 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)
 
-        # 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)
+        interval_cons = get_interval(self._log_interval_consumption, 1)
+        interval_prod = get_interval(self._log_interval_production, 1)
 
-        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:
+        # Initial timestamps
+        base_timestamp = self._logs[address][slot].timestamp
+        timestamp_cons = base_timestamp + interval_cons
+        timestamp_prod = base_timestamp + interval_prod
+
+        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)
+                timestamp_cons += timedelta(hours=1)  # Always increment by 1 hour here
                 address, slot = calc_log_address(address, slot, 1)
-                expected_timestamp += timedelta(hours=1)
+        else:
+            # Consider both consumption and production timestamps
+            while timestamp_cons < target or timestamp_prod < target:
                 if address not in addresses:
                     addresses.append(address)
-            return addresses
-
-        # 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)
+                if timestamp_prod < timestamp_cons:
+                    timestamp_prod += interval_prod
+                else:
+                    timestamp_cons += interval_cons
+                address, slot = calc_log_address(address, slot, 1)
 
-        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:
-            if address not in addresses:
-                addresses.append(address)
-            if expected_timestamp_prod < expected_timestamp_cons:
-                expected_timestamp_prod += calc_interval_prod
-            else:
-                expected_timestamp_cons += calc_interval_cons
-            address, slot = calc_log_address(address, slot, 1)
         return addresses