redzed 25.12.30__py3-none-any.whl → 26.2.4__py3-none-any.whl

redzed/circuit.py

@@ -2,15 +2,16 @@
 The circuit runner.
 - - - - - -
 Part of the redzed package.
-# Docs: https://redzed.readthedocs.io/en/latest/
-# Project home: https://github.com/xitop/redzed/
+Docs: https://redzed.readthedocs.io/en/latest/
+Project home: https://github.com/xitop/redzed/
 """
 from __future__ import annotations
 
-__all__ = ['CircuitState', 'get_circuit', 'reset_circuit', 'run', 'unique_name']
+__all__ = [
+    'CircuitState', 'stop_function', 'get_circuit', 'reset_circuit', 'run', 'unique_name']
 
 import asyncio
-from collections.abc import Coroutine, Iterable, MutableMapping, Sequence
+from collections.abc import Callable, Coroutine, Iterable, MutableMapping, Sequence
 import contextlib
 import enum
 import itertools
@@ -21,12 +22,12 @@ import typing as t
 
 from .block import Block, PersistenceFlags
 from .cron_service import Cron
-from .debug import get_debug_level
+from .debug import get_debug_level, set_debug_level
 from .initializers import AsyncInitializer
 from .formula_trigger import Formula, Trigger
 from .signal_shutdown import TerminatingSignal
 from .undef import UNDEF
-from .utils import check_async_coro, check_identifier, tasks_are_eager, time_period
+from .utils import check_identifier, tasks_are_eager, time_period
 
 _logger = logging.getLogger(__package__)
 _current_circuit: Circuit|None = None
@@ -63,6 +64,13 @@ def unique_name(prefix: str = 'auto') -> str:
     return get_circuit().rz_unique_name(prefix)
 
 
+_StopFunction: t.TypeAlias = Callable[[], t.Any]
+
+def stop_function(func: _StopFunction) -> _StopFunction:
+    get_circuit().rz_add_stop_function(func)
+    return func
+
+
 class CircuitState(enum.IntEnum):
     """
     Circuit state.
@@ -83,16 +91,16 @@ class _TerminateTaskGroup(Exception):
 
 
 @contextlib.contextmanager
-def error_debug(item: Block|Formula|Trigger, suppress_error: bool = False) -> t.Iterator[None]:
+def error_debug(exc_source: t.Any, suppress_error: bool = False) -> t.Iterator[None]:
     """Add a note to raised exception -or- log and suppress exception."""
     try:
         yield None
     except Exception as err:
         if not suppress_error:
-            err.add_note(f"This {type(err).__name__} occurred in {item}")
+            err.add_note(f"This {type(err).__name__} occurred in {exc_source}")
             raise
         # errors should be suppressed only during the shutdown & cleanup
-        _logger.error("[Circuit] %s: Suppressing %s: %s", item, type(err).__name__, err)
+        _logger.error("[Circuit] %s: Suppressing %s: %s", exc_source, type(err).__name__, err)
 
 
 class Circuit:
@@ -108,6 +116,7 @@ class Circuit:
         self._blocks: dict[str, Block|Formula] = {}
             # all Blocks and Formulas belonging to this circuit stored by name
         self._triggers: list[Trigger] = []      # all triggers belonging to this circuit
+        self._stops: list[_StopFunction] = []
         self._errors: list[Exception] = []      # exceptions occurred in the runner
         self.rz_persistent_dict: MutableMapping[str, t.Any]|None = None
             # persistent state data back-end
@@ -169,6 +178,9 @@ class Circuit:
 
     # --- circuit components storage ---
 
+    def rz_add_stop_function(self, func: _StopFunction) -> None:
+        self._stops.append(func)
+
     def rz_add_item(self, item: Block|Formula|Trigger) -> None:
         """Add a circuit item."""
         self._check_not_started()
@@ -279,7 +291,7 @@ class Circuit:
 
     def _check_not_started(self) -> None:
         """Raise an error if the circuit runner has started already."""
-        if self._state == CircuitState.CLOSED:
+        if self._state is CircuitState.CLOSED:
             # A circuit may be closed before start (see shutdown),
             # let's use this message instead of the one below.
             raise RuntimeError("The circuit was closed")
@@ -287,7 +299,7 @@ class Circuit:
         if self._state > CircuitState.INIT_CIRCUIT:
             raise RuntimeError("Not allowed after the start")
 
-    def after_shutdown(self) -> bool:
+    def is_shut_down(self) -> bool:
         """Test if we are past the shutdown() call."""
         return self._state >= CircuitState.SHUTDOWN
 
@@ -444,8 +456,10 @@ class Circuit:
     async def _runner_init(self) -> None:
         """Run the circuit during the initialization phase."""
         self._set_state(CircuitState.INIT_CIRCUIT)
+        # ensure a logging handler (won't work in UNDER_CONSTRUCTION level)
+        set_debug_level(get_debug_level())
         await asyncio.sleep(0)  # allow reached_state() synchronization
-        if self.after_shutdown():
+        if self.is_shut_down():
             # It looks like a supporting task has failed immediately after the start
             return
 
@@ -496,14 +510,24 @@ class Circuit:
                     self.save_persistent_state(blk, now)
 
         stop_triggers = list(self.get_items(Trigger))
+        if stop_triggers:
+            self._log_debug2_blocks("Stopping triggers", stop_triggers)
+            for tstop in stop_triggers:
+                with error_debug(tstop, suppress_error=True):
+                    tstop.rz_stop()
+
+        if self._stops:
+            self.log_debug2("Running %d stop function(s)", len(self._stops))
+            for fstop in self._stops:
+                with error_debug(f"Stop function {fstop.__name__}()", suppress_error=True):
+                    fstop()
+
         stop_blocks = [blk for blk in self.get_items(Block) if blk.has_method('rz_stop')]
         if stop_blocks:
-            self._log_debug2_blocks("Stopping (sync)", stop_triggers, stop_blocks)
-            for stop in itertools.chain(stop_triggers, stop_blocks):
-                assert isinstance(stop, (Block, Trigger))       # @mypy
-                with error_debug(stop, suppress_error=True):
-                    # union-attr: checked with .has_method()
-                    stop.rz_stop()  # type: ignore[union-attr]
+            self._log_debug2_blocks("Stopping (sync)", stop_blocks)
+            for bstop in stop_blocks:
+                with error_debug(bstop, suppress_error=True):
+                    bstop.rz_stop()
 
         if self._auto_cancel_tasks:
             self.log_debug2("Cancelling %d service task(s)")
@@ -543,10 +567,6 @@ class Circuit:
 
         When the runner terminates, it cannot be invoked again.
         """
-        if self._state == CircuitState.CLOSED:
-            raise RuntimeError("Cannot restart a closed circuit.")
-        if self._state != CircuitState.UNDER_CONSTRUCTION:
-            raise RuntimeError("The circuit is already running.")
         if not self._blocks:
             raise RuntimeError("The circuit is empty")
         if tasks_are_eager():
@@ -560,7 +580,7 @@ class Circuit:
                 self.abort(err)
             else:
                 # There might be errors reported with abort().
-                # In such case the state has been set to SHUTDOWN.
+                # In such case the state has been set to SHUTDOWN or even CLOSED.
                 # _set_state(RUNNING) will be silently ignored.
                 self._set_state(CircuitState.RUNNING)
             # wait until cancelled from the task group; possible causes:
@@ -572,17 +592,18 @@ class Circuit:
             # will be re-raised at the end if there won't be other exceptions
             pass
         # cancellation causes 2 and 3 do not modify the state
-        if not self.after_shutdown():
+        if not self.is_shut_down():
             self._set_state(CircuitState.SHUTDOWN)
             await asyncio.sleep(0)
-        try:
-            await self._runner_shutdown()
-        except Exception as err:
-            # If an exception is propagated from _runner_shutdown, it is probably a bug.
-            # Calling abort is not necessary when shutting down, but the call will log
-            # and register the exception to be included in the final ExceptionGroup.
-            self.abort(err)
-        self._set_state(CircuitState.CLOSED)
+        if self._state < CircuitState.CLOSED:
+            try:
+                await self._runner_shutdown()
+            except Exception as err:
+                # If an exception is propagated from _runner_shutdown, it is probably a bug.
+                # Calling abort is not necessary when shutting down, but the call will log
+                # and register the exception to be included in the final ExceptionGroup.
+                self.abort(err)
+            self._set_state(CircuitState.CLOSED)
 
         if self._errors:
             raise ExceptionGroup("_runner_core() errors", self._errors)
@@ -604,7 +625,7 @@ class Circuit:
             # the same error may be reported from several places
             return
         self._errors.append(err)
-        if self.after_shutdown():
+        if self.is_shut_down():
             self.log_error("Unhandled error during shutdown: %r", err)
         else:
             self.log_warning("Aborting due to an exception: %r", err)
@@ -616,9 +637,9 @@ class Circuit:
 
         Prevent the runner from starting if it wasn't started yet.
         """
-        if self.after_shutdown():
+        if self.is_shut_down():
             return
-        if self._state == CircuitState.UNDER_CONSTRUCTION:
+        if self._state <= CircuitState.INIT_CIRCUIT:
             self._set_state(CircuitState.CLOSED)
             return
         self._set_state(CircuitState.SHUTDOWN)
@@ -655,7 +676,7 @@ class Circuit:
         try:
             await coro  # return value of a service is ignored
         except asyncio.CancelledError:
-            if self.after_shutdown():
+            if self.is_shut_down():
                 self.log_debug1("%s was cancelled", longname)
                 raise
             err = RuntimeError(f"{longname} was cancelled before shutdown")
@@ -665,7 +686,7 @@ class Circuit:
             err.add_note(f"Error occurred in {longname}")
             self.abort(err)
             raise
-        if self.after_shutdown():
+        if self.is_shut_down():
             self.log_debug1("%s terminated", longname)
             return
         exc = RuntimeError(f"{longname} terminated before shutdown")
@@ -679,9 +700,8 @@ class Circuit:
             **task_kwargs
             ) -> asyncio.Task[None]:
         """Create a service task for the circuit."""
-        if self.after_shutdown():
+        if self.is_shut_down():
             raise RuntimeError("Cannot create a service after shutdown")
-        check_async_coro(coro)
         # Python 3.12 and 3.13 only: Eager tasks start to run before their name is set.
         # As a workaround we tell the watchdog wrapper the name.
         task = asyncio.create_task(
@@ -734,8 +754,13 @@ async def run(*coroutines: Coroutine[t.Any, t.Any, t.Any], catch_sigterm: bool =
 
     If errors occur, raise an exception group with all exceptions.
     """
+    circuit = get_circuit()
+    state = circuit.get_state()
+    if state is CircuitState.CLOSED:
+        raise RuntimeError("Cannot restart a closed circuit.")
+    if state is not CircuitState.UNDER_CONSTRUCTION:
+        raise RuntimeError("The circuit is already running.")
     with TerminatingSignal(signal.SIGTERM) if catch_sigterm else contextlib.nullcontext():
-        circuit = get_circuit()
         try:
             async with asyncio.TaskGroup() as tg:
                 tg.create_task(circuit.rz_runner(), name="Circuit runner")

redzed/cron_service.py

@@ -3,8 +3,8 @@ Call the .rz_cron_event() method of all registered blocks at given times of day.
 
 Blocks acting on given time, date and weekdays are implemented
 on top of this low-level service.
-
 - - - - - -
+Part of the redzed package.
 Docs: https://redzed.readthedocs.io/en/latest/
 Home: https://github.com/xitop/redzed/
 """
@@ -12,23 +12,41 @@ from __future__ import annotations
 
 import asyncio
 import bisect
+from collections import deque
 from collections.abc import Collection
 import datetime as dt
-import time
 import typing as t
 
 from .block import Block, EventData
 from .debug import get_debug_level
 from .utils import SEC_PER_HOUR, SEC_PER_MIN, SEC_PER_DAY
 
-# time tracking accuracy (in seconds)
-_TT_OK = 0.001          # desired accuracy
-_TT_WARNING = 0.1       # log a warning when exceeded
-_TT_ERROR = 2.5         # do a reset when exceeded
-_SYNC_SLEEP = 0.000_2   # sleeps <= 200 µs can be blocking for sake of accuracy
+# time tracking settings (in seconds)
+_TT_OVERHEAD = 0.001    # asyncio sleep overhead estimation; real value will be measured
+_TT_WARNING = 0.2       # timing difference threshold for a warning message
+_TT_ERROR = 2.5         # timing difference threshold for a reset
+
+# hourly wake ups for precise time tracking and early detection of DST changes
+_SET24H = frozenset(dt.time(hour, 0, 0) for hour in range(24))
 
-# hourly wake-ups for precise time tracking and early detection of DST changes
-_SET24 = frozenset(dt.time(hour, 0, 0) for hour in range(24))
+
+def _wait_time(t1: dt.time, t2: dt.time) -> float:
+    """
+    Return seconds from *t1* to *t2* on a 24 hour clock.
+
+    The result is always between -1 and 23 hours (in seconds).
+    Positive values are normal wait times (when *t2* is after *t1*).
+    Negative values correspond to delays after a missed event
+    (when *t2* is less than 1 hour before *t1*).
+    """
+    # datetime.time does not support time arithmetic
+    diff = (SEC_PER_HOUR*(t2.hour - t1.hour)
+        + SEC_PER_MIN*(t2.minute - t1.minute)
+        + (t2.second - t1.second)
+        + (t2.microsecond - t1.microsecond) / 1_000_000.0)
+    if -SEC_PER_HOUR < diff <= 23 * SEC_PER_HOUR:
+        return diff
+    return diff + SEC_PER_DAY if diff < 0 else diff - SEC_PER_DAY
 
 
 class Cron(Block):
@@ -44,7 +62,10 @@ class Cron(Block):
     def __init__(self, *args, utc: bool, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self._utc = bool(utc)
-        self._alarms: dict[dt.time, set[Block]] = {}
+        self._alarms: dict[dt.time, set[Block]] = {tod: set() for tod in _SET24H}
+        self._timetable: list[dt.time] = sorted(_SET24H)
+            # timetable = sorted list (for bisection) of wake-up times (i.e. _alarms keys)
+        self._tt_len = 24
         self._reversed: dict[Block, set[dt.time]] = {}
         self._do_reload = asyncio.Event()
 
@@ -69,144 +90,137 @@ class Cron(Block):
             raise ValueError("time_of_day must not contain timezone data")
 
     def set_schedule(self, blk: Block, times_of_day: Collection[dt.time]) -> None:
-        """
-        Add a block to be activated at given times or update its schedule.
-
-        The block's 'rz_cron_event' method will be called at given time
-        and also when this service is started, reset or reloaded.
-
-        A datetime.datetime object will be passed to the blk as its
-        only argument.
-        """
+        """Add a block to be activated at given times or update its schedule."""
         if not hasattr(blk, 'rz_cron_event'):
             raise TypeError(f"{blk} is not compatible with the cron service")
+        for tod in times_of_day:
+            self._check_tz(tod)
+        self.log_debug2("Got a new schedule for %s", blk)
+        times_of_day = set(times_of_day)
 
-        times_of_day = set(times_of_day) # make a set, make a copy
-        # remove old times of day
+        # remove old times of day; it is not necessary to notify the main loop
         old_times = self._reversed.get(blk, set())
         for tod in old_times - times_of_day:
             self._alarms[tod].discard(blk)
-
-        do_reload = False
         # add new times of day
+        do_reload = False
         for tod in times_of_day - old_times:
-            self._check_tz(tod)
             if tod in self._alarms:
                 self._alarms[tod].add(blk)
             else:
                 self._alarms[tod] = {blk}
-                if tod not in _SET24:
-                    do_reload = True    # new entry added to timetable
+                # new entry added to timetable; the main loop must be notified
+                do_reload = True
         self._reversed[blk] = times_of_day
-
-        # cleanup
-        unused = [tod for tod, blkset in self._alarms.items() if not blkset]
-        for tod in unused:
-            del self._alarms[tod]
-            if tod not in _SET24:
-                do_reload = True    # empty entry removed from the timetable
         if do_reload:
             self._do_reload.set()
+        # cleanup
+        for tod in [
+                tod for tod, blks in self._alarms.items() if tod not in _SET24H and not blks]:
+            del self._alarms[tod]
+
+        self._timetable = sorted(self._alarms)
+        self._tt_len = len(self._timetable)
+
 
     async def _cron_daemon(self) -> t.NoReturn:
         """Recalculate registered blocks according to the schedule."""
-        overhead = _TT_OK   # initial value, will be adjusted
-                            # the sleeptime is reduced by this value
         reset_flag = False
-        reload_flag = True      # reload will also initialize the index
-        short_sleep = False     # alternative sleep function used => do not compute overhead
-        while True:
-            if reload_flag:
-                timetable = sorted(_SET24.union(self._alarms))
-                tlen = len(timetable)
-                self.log_debug1("time schedule reloaded")
-                index = None
-                reload_flag = False
+        overhead = _TT_OVERHEAD       # an estimate to start with
+        measured_overheads: deque[float] = deque(maxlen=8)
+        prev_sleeptime: float
+        long_sleep: bool
+        wakeup: dt.time|None = None
 
+        while True:
             nowdt = self.dtnow()
             nowt = nowdt.time()
-            if index is None:
-                # reload is set before entering the loop -> "tlen" gets initialized
-                # pylint: disable-next=possibly-used-before-assignment
-                index = bisect.bisect_left(timetable, nowt) % tlen
-            wakeup = timetable[index]
-            self.log_debug1("wakeup time: %s", wakeup)
-
-            # sleep until the wakeup time:
-            # step 0 - compute the delay until wakeup time
-            #        - sleep
-            # step 1 - check the current time, adjust overhead estimate,
-            #            A: finish if the time is correct, or
-            #            B: add a tiny sleep if woken up too early, because
-            #               continuing before wakeup time is not acceptable
-            #            C: do a reset if the time is way off
-            # step 2 - check time after 1B,
-            #            A: finish if the time is correct
-            #            B: do a reset otherwise
-            for step in range(3):
-                # datetime.time does not support time arithmetic
-                sleeptime = (SEC_PER_HOUR*(wakeup.hour - nowt.hour)
-                    + SEC_PER_MIN*(wakeup.minute - nowt.minute)
-                    + (wakeup.second - nowt.second)
-                    + (wakeup.microsecond - nowt.microsecond)/ 1_000_000.0)
-                if nowt.hour == 23 and wakeup.hour == 0:
-                    # wrap around midnight (relying on hourly wakeups in SET24)
-                    sleeptime += SEC_PER_DAY
-                # sleeptime: negative = after the alarm time; positive = before the alarm time
+
+            if wakeup is None or self._do_reload.is_set():
+                index = bisect.bisect_left(self._timetable, nowt)
+                next_wakeup = self._timetable[index % self._tt_len]
+                # next_wakeup is new and wakeup was not processed yet,
+                # all we need is to select which one comes first.
+                if wakeup is None \
+                        or next_wakeup != wakeup and _wait_time(next_wakeup, wakeup) > 0:
+                    wakeup = next_wakeup
+                # else: the current wakeup is confirmed
+                self._do_reload.clear()
+                self.log_debug1("wake-up time after reload: %s", wakeup)
+            else:
+                # return the next entry (in circular manner)
+                index = bisect.bisect_right(self._timetable, wakeup)
+                wakeup = self._timetable[index % self._tt_len]
+                self.log_debug1("wake-up time: %s", wakeup)
+
+            # sleep until the wake-up time:
+            #   step 0: main sleep
+            #       compute the delay until wake-up time and sleep
+            #   steps 1 and 2: fine adjustment
+            #       check the current time, adjust overhead estimate and
+            #           - finish if the time is correct, or
+            #           - add a tiny sleep if woken up too early, because
+            #             that is not acceptable, or
+            #           - do a reset if the time is way off
+            #   steps 3 and 4: safety net
+            #       like above, just for the case the computer clock
+            #       does something unexpected
+            for step in range(5):
+                sleeptime = _wait_time(nowt, wakeup)    # negative = we are late
+                debug2 = get_debug_level() >= 2
                 if step == 0:
-                    self.log_debug2("sleep until wakeup: %.3f sec", sleeptime)
-                if step >= 1 or sleeptime < 0:
+                    if debug2:
+                        self.log_debug("sleep until wake up: %.3f sec", sleeptime)
+                else:
                     diff = abs(sleeptime)
-                    if get_debug_level() >= 2:
-                        msg = 'BEFORE' if sleeptime > 0 else 'after'
-                        self.log_debug(
-                            "step %d, diff %.2f ms %s, estimated overhead: %.2f ms",
-                            step, 1000*diff, msg, 1000*overhead)
+                    after = sleeptime <= 0.0
                     if diff > _TT_WARNING:
                         self.log_warning(
-                            "expected time: %s, current time: %s, diff: %.2f ms.",
-                            wakeup, nowt, 1000*diff)
-                    if (step == 2 and sleeptime > 0) or diff > _TT_ERROR:
+                            "expected time: %s, current time: %s, diff: %.1f sec %s",
+                            wakeup, nowt, diff, 'after' if after else 'BEFORE')
+                    elif debug2:
+                        self.log_debug(
+                            "iteration %d, diff %.2f ms %s",
+                            step, 1000*diff, 'after' if after else 'BEFORE')
+                    # prev_sleeptime and long_sleep has been set in previous step
+                    # pylint: disable=used-before-assignment
+                    if diff > _TT_ERROR or sleeptime > prev_sleeptime or step == 4:
+                        # something is wrong with the computer clock
                         reset_flag = True
-                    if reset_flag:
                         break
-                    if step == 1 and not short_sleep and not -_TT_OK <= sleeptime <= 0:
-                        overhead -= (sleeptime + _TT_OK/2) / 2      # average of new and old
-                    if sleeptime <= 0:
+                    if long_sleep:
+                        saved = overhead
+                        measured_overheads.append(overhead - sleeptime)
+                        # Using smallest overhead recently measured, because to be late
+                        # by a tiny amount is much better than to wake up early by a tiny
+                        # amount. The latter case must be corrected by another sleep.
+                        overhead = min(measured_overheads)
+                        if debug2 and overhead != saved:
+                            self.log_debug("estimated overhead >= %.2f ms", 1000*overhead)
+                    if after:
                         break
-                    if get_debug_level() >= 2:
+                    if debug2:
                         self.log_debug("additional sleep %.2f ms", 1000*sleeptime)
+                prev_sleeptime = sleeptime
 
-                if sleeptime == 0.0:
-                    pass    # how likely is this?
-                elif sleeptime <= _SYNC_SLEEP:
-                    short_sleep = True
-                    # breaking the asyncio rules for max time tracking accuracy:
-                    # doing a blocking sleep, but only for a fraction of a millisecond
-                    time.sleep(sleeptime)
-                elif sleeptime <= overhead:
-                    short_sleep = True
-                    await asyncio.sleep(sleeptime)
-                else:
-                    short_sleep = False
+                if (long_sleep := sleeptime > overhead):
                     try:
                         async with asyncio.timeout(sleeptime - overhead):
                             await self._do_reload.wait()
                     except TimeoutError:
-                        pass
+                        pass    # no reload request
                     else:
-                        self._do_reload.clear()
-                        reload_flag = True
-                        break
+                        break   # reload request arrived
+                elif sleeptime > 0.0:
+                    await asyncio.sleep(sleeptime)
                 nowdt = self.dtnow()
                 nowt = nowdt.time()
+            # --- end for loop ---
 
             if reset_flag:
                 # DST begin/end or other computer clock related reason
-                if (not self._utc
-                        and nowdt.isoweekday() >= 6
-                        and abs(diff - SEC_PER_HOUR) <= _TT_ERROR
-                        ):
+                if (not self._utc and nowdt.isoweekday() >= 6
+                        and abs(diff - SEC_PER_HOUR) <= _TT_ERROR):
                     self.log_warning("Apparently a DST (summer time) clock change has occured.")
                 self.log_warning(
                     "Resetting due to a time tracking problem. "
@@ -215,29 +229,29 @@ class Cron(Block):
                 for blk in list(self._reversed):    # all blocks
                     assert hasattr(blk, 'rz_cron_event')
                     blk.rz_cron_event(nowdt)
-                index = None
                 reset_flag = False
+                wakeup = None
                 continue
-            if reload_flag:
+            if self._do_reload.is_set():
                 continue
 
-            if wakeup in self._alarms:
-                # .rz_cron_event() may alter the set we are iterating over
-                block_list = list(self._alarms[wakeup])
-                if get_debug_level() >= 1:
-                    self.log_debug(
-                        "Notifying blocks: %s", ", ".join(blk.name for blk in block_list))
-                for blk in block_list:
-                    assert hasattr(blk, 'rz_cron_event')
-                    blk.rz_cron_event(nowdt)
-            index = (index + 1) % tlen
+            if wakeup not in self._alarms:
+                continue    # entry removed in the meantime
+            # .rz_cron_event() may alter the set we are iterating over
+            block_list = list(self._alarms[wakeup])
+            if get_debug_level() >= 1:
+                self.log_debug(
+                    "Notifying block(s): %s", ", ".join(blk.name for blk in block_list))
+            for blk in block_list:
+                assert hasattr(blk, 'rz_cron_event')
+                blk.rz_cron_event(nowdt)
 
     def _event__get_config(self, _edata: EventData) -> dict[str, dict[str, list[str]]]:
         """Return the internal scheduling data for debugging or monitoring."""
         return {
             'alarms': {
-                str(recalc_time): sorted(blk.name for blk in blk_set)
-                for recalc_time, blk_set in self._alarms.items()},
-            'blocks': {blk.name: sorted(str(recalc_time) for recalc_time in times_set)
-                for blk, times_set in self._reversed.items()},
+                str(tod): sorted(blk.name for blk in blks)
+                for tod, blks in self._alarms.items() if blks},
+            'blocks': {blk.name: sorted(str(tod) for tod in tods)
+                for blk, tods in self._reversed.items()},
             }