yjz dZddlmZddlZddlZddlmZddlmZm Z m Z ej e Z ddejdddZddZdS)uAsync/sync bridging helpers. The codebase has ~30 sites that schedule a coroutine onto an event loop from a worker thread via :func:`asyncio.run_coroutine_threadsafe`. That function can raise :class:`RuntimeError` (e.g. the loop was closed during a shutdown race), and when it does the coroutine object is never awaited and never closed — which triggers a ``"coroutine '' was never awaited"`` RuntimeWarning and leaks the coroutine's frame until GC. :func:`safe_schedule_threadsafe` wraps the call, closes the coroutine on scheduling failure, and returns ``None`` (instead of a half-formed future) so callers can branch cleanly: fut = safe_schedule_threadsafe(coro, loop) if fut is None: return # or fallback behavior fut.result(timeout=5) The helper deliberately does NOT also handle ``future.result()`` failures — that is a separate concern. Once the loop has accepted the coroutine, its lifecycle belongs to the loop, not the scheduling thread. ) annotationsN)Future)Any CoroutineOptionalz$Failed to schedule coroutine on loop)logger log_message log_levelcoroCoroutine[Any, Any, Any]loop#Optional[asyncio.AbstractEventLoop]rOptional[logging.Logger]r strr intreturnOptional[Future]cz||nt}|Atj|r|||d|dS tj||S#t $rK}tj|r|||d||Yd}~dSd}~wwxYw)aYSchedule ``coro`` on ``loop`` from a sync context, leak-safe. Returns the :class:`concurrent.futures.Future` on success, or ``None`` if the loop is missing or :func:`asyncio.run_coroutine_threadsafe` raised (e.g. the loop was closed during a shutdown race). In all failure paths the coroutine is :meth:`close`-d so it does not trigger ``"coroutine was never awaited"`` warnings or leak its frame. Callers retain full control over what to do with the returned future (call ``.result(timeout=...)``, attach ``add_done_callback``, ignore it fire-and-forget, etc.). Nz%s: loop is Nonez%s: %s)_DEFAULT_LOGGERasyncio iscoroutinecloselogrun_coroutine_threadsafe Exception)r r rr r rexcs 7/home/ragecks/.hermes/hermes-agent/agent/async_utils.pysafe_schedule_threadsafer"s(&&&OC |  t $ $  JJLLL  -{;;;t/d;;;   t $ $  JJLLL  8[#666ttttt sA%% B:/AB55B:task'asyncio.Future[Any]'Nonecj |dS#tjtf$rYdSwxYw)uRetrieve a detached task's result without surfacing cancellation. Used as an ``add_done_callback`` on tasks that were cancelled and detached (e.g. an adapter close path that swallows ``CancelledError`` past its teardown deadline). Observing ``task.exception()`` prevents "exception was never retrieved" noise on the event loop; cancellation and any terminal error are deliberately swallowed — the task's owner already gave up on it. N) exceptionrCancelledErrorr)rs rconsume_detached_task_resultr%GsG    "I .     s 22) r r r rrrr rr rrr)rr rr!)__doc__ __future__rrloggingconcurrent.futuresrtypingrrr getLogger__name__rDEBUGrr%rr0s,#"""""%%%%%%++++++++++$'#H--(,=] """"""J       r/