timing_tools.py: Decrease Logging More (#114)

Author: ric-evans

wipac_dev_tools/timing_tools.py

@@ -1,6 +1,7 @@
 """Utilities for timers, interval trackers, etc."""
 
 import asyncio
+import itertools
 import logging
 import time
 from typing import Union
@@ -29,50 +30,68 @@ def __init__(
             self.logger = logging.getLogger(logger)
 
     def fastforward(self):
-        """Reset the timer so that the next call to `has_interval_elapsed` will return True.
+        """Force the interval timer to consider the current interval as already elapsed.
 
-        This effectively skips the current interval and forces the timer to indicate
-        that the interval has elapsed on the next check.
+        This resets the internal timer to a state where the next call to `has_interval_elapsed`
+        will immediately return `True`, as if the interval has already passed.
         """
         self._last_time = float("-inf")
 
-    async def wait_until_interval(self, frequency: float = 1.0) -> None:
+    @staticmethod
+    def _is_nth(i: int, nth: int) -> bool:
+        return nth > 0 and i % nth == 0
+
+    async def wait_until_interval(
+        self,
+        frequency: float = 1.0,
+        log_every_nth: int = 60,
+    ) -> None:
         """Wait asynchronously until the specified interval has elapsed.
 
         This method checks the elapsed time every `frequency` seconds,
         allowing cooperative multitasking during the wait.
         """
         if self.logger:
             self.logger.debug(
-                f"Waiting until {self.seconds}s has elapsed since the last iteration..."
+                f"Waiting for {self.seconds}s interval before proceeding..."
             )
-        while not self.has_interval_elapsed():
+
+        for i in itertools.count():
+            if self.has_interval_elapsed(do_log=self._is_nth(i, log_every_nth)):
+                return
             await asyncio.sleep(frequency)
 
-    def wait_until_interval_sync(self, frequency: float = 1.0) -> None:
+    def wait_until_interval_sync(
+        self,
+        frequency: float = 1.0,
+        log_every_nth: int = 60,
+    ) -> None:
         """Wait until the specified interval has elapsed.
 
         This method checks the elapsed time every `frequency` seconds,
         blocking until the interval has elapsed.
         """
         if self.logger:
             self.logger.debug(
-                f"Waiting until {self.seconds}s has elapsed since the last iteration..."
+                f"Waiting for {self.seconds}s interval before proceeding..."
             )
-        while not self.has_interval_elapsed():
+
+        for i in itertools.count():
+            if self.has_interval_elapsed(do_log=self._is_nth(i, log_every_nth)):
+                return
             time.sleep(frequency)
 
-    def has_interval_elapsed(self) -> bool:
+    def has_interval_elapsed(self, do_log: bool = True) -> bool:
         """Check if the specified time interval has elapsed since the last expiration.
 
         If the interval has elapsed, the internal timer is reset to the current time.
         """
         diff = time.monotonic() - self._last_time
         if diff >= self.seconds:
             self._last_time = time.monotonic()
-            if self.logger:
+            if self.logger and do_log:
                 self.logger.debug(
-                    f"At least {self.seconds}s have elapsed (actually {diff}s)."
+                    f"Interval elapsed: {self.seconds}s (actual: {diff:.3f}s)."
                 )
             return True
         return False