"""Clocks that stop while the computer sleeps. A laptop that sleeps in the middle of a request freezes Hermes and the local model server together. Timers measured on the wall clock or on Python's ``time.monotonic`` on Windows keep counting through the sleep, so every stall watchdog fires the moment the machine wakes and kills work that was about to continue. Watchdogs that judge "no progress" use these clocks instead. """ from __future__ import annotations import sys import time from collections.abc import Callable _SLEEP_THRESHOLD_S = 5.0 def _windows_unbiased_clock() -> Callable[[], float] | None: """The unbiased interrupt time in seconds, or None where kernel32 lacks it.""" try: import ctypes query = ctypes.windll.kernel32.QueryUnbiasedInterruptTime except (AttributeError, OSError): return None def clock() -> float: value = ctypes.c_ulonglong(0) query(ctypes.byref(value)) return value.value / 10_000_000 return clock #: Seconds the machine has spent awake, from an arbitrary start. Windows: the unbiased interrupt #: time, which excludes sleep and hibernation. Linux and macOS: ``time.monotonic``, which already #: stops during suspend there. awake_seconds: Callable[[], float] = ( (_windows_unbiased_clock() if sys.platform == "win32" else None) or time.monotonic) class SleepWatch: """Reports how long this process was stopped since the last check, for a caller that checks every ``interval`` seconds: the wall time past one interval. That covers a machine that slept and a process that Modern Standby froze, without relying on how any clock treats either. Gaps under five seconds (clock sync, scheduling noise) don't count. """ def __init__(self, interval: float) -> None: self._interval = interval self._wall = time.time() def slept(self) -> float: """Seconds stopped since the previous call, or 0.0.""" wall = time.time() stopped, self._wall = wall - self._wall - self._interval, wall return stopped if stopped >= _SLEEP_THRESHOLD_S else 0.0