Refactor _missing_addresses_before()

Author: bouwew

plugwise_usb/nodes/helpers/pulses.py

@@ -915,65 +915,37 @@ def _last_known_duration(self) -> timedelta:
             address, slot = calc_log_address(address, slot, -1)
         return self._logs[address][slot].timestamp - last_known_timestamp
 
-    def _missing_addresses_before(
-        self, address: int, slot: int, target: datetime
-    ) -> list[int]:
+    def _missing_addresses_before(self, address: int, slot: int, target: datetime) -> list[int]:
         """Return list of missing address(es) prior to given log timestamp."""
-        addresses: list[int] = []
         if self._logs is None or target >= self._logs[address][slot].timestamp:
-            return addresses
+            return []
 
-        # 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)
-            if self._log_interval_consumption == 0:
-                pass
-
-        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 and address > 0:
-                if address not in addresses:
-                    addresses.append(address)
-                expected_timestamp -= calc_interval_cons
-                address, slot = calc_log_address(address, slot, -1)
-        else:
-            # 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)
+        cons_interval = timedelta(
+            minutes=self._log_interval_consumption
+            if self._log_interval_consumption and self._log_interval_consumption > 0
+            else 60
+        )
 
-            expected_timestamp_cons = (
-                self._logs[address][slot].timestamp - calc_interval_cons
-            )
-            expected_timestamp_prod = (
-                self._logs[address][slot].timestamp - calc_interval_prod
-            )
+        prod_interval = timedelta(
+            minutes=self._log_interval_production
+            if self._log_production and self._log_interval_production and self._log_interval_production > 0
+            else 60
+        )
+
+        addresses, ts_cons, ts_prod = [], self._logs[address][slot].timestamp, self._logs[address][slot].timestamp
+        address, slot = calc_log_address(address, slot, -1)
 
+        while address > 0 and (ts_cons - cons_interval > target or (self._log_production and ts_prod - prod_interval > target)):
+            addresses = update_addresses(addres, addresses)
+            if self._log_production and ts_prod - prod_interval > ts_cons - cons_interval:
+                ts_prod -= prod_interval
+            else:
+                ts_cons -= cons_interval
             address, slot = calc_log_address(address, slot, -1)
-            while (
-                expected_timestamp_cons > target or expected_timestamp_prod > target
-            ) and address > 0:
-                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
 
+
     def _missing_addresses_after(
         self, address: int, slot: int, target: datetime
     ) -> list[int]: