64 lines
2.0 KiB
Python
64 lines
2.0 KiB
Python
"""Bounded background refresh orchestration for registered knowledge sources."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
from collections.abc import Awaitable, Callable, Iterable
|
|
from uuid import UUID
|
|
|
|
from packages.connector_kit.knowledge import (
|
|
IndexReport,
|
|
InMemoryKnowledgeIndex,
|
|
)
|
|
from packages.connector_kit.knowledge import (
|
|
KnowledgeRefreshJob as SingleRefreshJob,
|
|
)
|
|
|
|
|
|
class KnowledgeRefreshScheduler:
|
|
"""Cooperative scheduler; it never accepts a caller-supplied physical path."""
|
|
|
|
def __init__(
|
|
self,
|
|
index: InMemoryKnowledgeIndex,
|
|
source_ids: Iterable[UUID],
|
|
*,
|
|
interval_seconds: float = 300.0,
|
|
on_refresh: Callable[[tuple[IndexReport, ...]], Awaitable[None]] | None = None,
|
|
) -> None:
|
|
if not 1 <= interval_seconds <= 86_400:
|
|
raise ValueError("refresh interval is outside bounds")
|
|
self.index = index
|
|
self.source_ids = tuple(source_ids)
|
|
self.interval_seconds = interval_seconds
|
|
self.on_refresh = on_refresh
|
|
self._task: asyncio.Task[None] | None = None
|
|
self._stop = asyncio.Event()
|
|
|
|
async def run_once(self) -> tuple[IndexReport, ...]:
|
|
reports = SingleRefreshJob(self.index, self.source_ids).run_once()
|
|
if self.on_refresh is not None:
|
|
await self.on_refresh(reports)
|
|
return reports
|
|
|
|
async def start(self) -> None:
|
|
if self._task is not None and not self._task.done():
|
|
return
|
|
self._stop.clear()
|
|
self._task = asyncio.create_task(self._loop())
|
|
|
|
async def stop(self) -> None:
|
|
self._stop.set()
|
|
task = self._task
|
|
self._task = None
|
|
if task is not None:
|
|
await task
|
|
|
|
async def _loop(self) -> None:
|
|
while not self._stop.is_set():
|
|
await self.run_once()
|
|
try:
|
|
await asyncio.wait_for(self._stop.wait(), timeout=self.interval_seconds)
|
|
except TimeoutError:
|
|
continue
|