yee88 0.3.0__py3-none-any.whl

yee88/progress.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from collections.abc import Callable
+
+from .model import Action, ActionEvent, ResumeToken, StartedEvent, TakopiEvent
+
+
+@dataclass(frozen=True, slots=True)
+class ActionState:
+    action: Action
+    phase: str
+    ok: bool | None
+    display_phase: str
+    completed: bool
+    first_seen: int
+    last_update: int
+
+
+@dataclass(frozen=True, slots=True)
+class ProgressState:
+    engine: str
+    action_count: int
+    actions: tuple[ActionState, ...]
+    resume: ResumeToken | None
+    resume_line: str | None
+    context_line: str | None
+
+
+class ProgressTracker:
+    def __init__(self, *, engine: str) -> None:
+        self.engine = engine
+        self.resume: ResumeToken | None = None
+        self.action_count = 0
+        self._actions: dict[str, ActionState] = {}
+        self._seq = 0
+
+    def note_event(self, event: TakopiEvent) -> bool:
+        match event:
+            case StartedEvent(resume=resume):
+                self.resume = resume
+                return True
+            case ActionEvent(action=action, phase=phase, ok=ok):
+                if action.kind == "turn":
+                    return False
+                action_id = str(action.id or "")
+                if not action_id:
+                    return False
+                completed = phase == "completed"
+                existing = self._actions.get(action_id)
+                has_open = existing is not None and not existing.completed
+                is_update = phase == "updated" or (phase == "started" and has_open)
+                display_phase = "updated" if is_update and not completed else phase
+
+                self._seq += 1
+                seq = self._seq
+
+                if existing is None:
+                    self.action_count += 1
+                    first_seen = seq
+                else:
+                    first_seen = existing.first_seen
+                self._actions[action_id] = ActionState(
+                    action=action,
+                    phase=phase,
+                    ok=ok,
+                    display_phase=display_phase,
+                    completed=completed,
+                    first_seen=first_seen,
+                    last_update=seq,
+                )
+                return True
+            case _:
+                return False
+
+    def set_resume(self, resume: ResumeToken | None) -> None:
+        if resume is not None:
+            self.resume = resume
+
+    def snapshot(
+        self,
+        *,
+        resume_formatter: Callable[[ResumeToken], str] | None = None,
+        context_line: str | None = None,
+    ) -> ProgressState:
+        resume_line: str | None = None
+        if self.resume is not None and resume_formatter is not None:
+            resume_line = resume_formatter(self.resume)
+        actions = tuple(
+            sorted(self._actions.values(), key=lambda item: item.first_seen)
+        )
+        return ProgressState(
+            engine=self.engine,
+            action_count=self.action_count,
+            actions=actions,
+            resume=self.resume,
+            resume_line=resume_line,
+            context_line=context_line,
+        )

yee88/router.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Literal
+from collections.abc import Iterable
+
+from .model import EngineId, ResumeToken
+from .runner import Runner
+
+
+class RunnerUnavailableError(RuntimeError):
+    def __init__(self, engine: EngineId, issue: str | None = None) -> None:
+        message = f"engine {engine!r} is unavailable"
+        if issue:
+            message = f"{message}: {issue}"
+        super().__init__(message)
+        self.engine = engine
+        self.issue = issue
+
+
+type EngineStatus = Literal["ok", "missing_cli", "bad_config", "load_error"]
+
+
+@dataclass(frozen=True, slots=True)
+class RunnerEntry:
+    engine: EngineId
+    runner: Runner
+    status: EngineStatus = "ok"
+    issue: str | None = None
+
+    @property
+    def available(self) -> bool:
+        # "bad_config" means we ignored user config and built the runner with defaults.
+        # The engine is still runnable, but a warning should be surfaced to the user.
+        return self.status in {"ok", "bad_config"}
+
+
+class AutoRouter:
+    def __init__(
+        self, entries: Iterable[RunnerEntry], default_engine: EngineId
+    ) -> None:
+        self._entries = tuple(entries)
+        if not self._entries:
+            raise ValueError("AutoRouter requires at least one runner.")
+        by_engine: dict[EngineId, RunnerEntry] = {}
+        for entry in self._entries:
+            if entry.engine in by_engine:
+                raise ValueError(f"duplicate runner engine: {entry.engine}")
+            by_engine[entry.engine] = entry
+        if default_engine not in by_engine:
+            raise ValueError(f"default engine {default_engine!r} is not configured")
+        self._by_engine = by_engine
+        self.default_engine = default_engine
+
+    @property
+    def entries(self) -> tuple[RunnerEntry, ...]:
+        return self._entries
+
+    @property
+    def available_entries(self) -> tuple[RunnerEntry, ...]:
+        return tuple(entry for entry in self._entries if entry.available)
+
+    @property
+    def engine_ids(self) -> tuple[EngineId, ...]:
+        return tuple(entry.engine for entry in self._entries)
+
+    @property
+    def default_entry(self) -> RunnerEntry:
+        return self._by_engine[self.default_engine]
+
+    def entry_for_engine(self, engine: EngineId | None) -> RunnerEntry:
+        engine = self.default_engine if engine is None else engine
+        entry = self._by_engine.get(engine)
+        if entry is None:
+            raise RunnerUnavailableError(engine, "engine not configured")
+        return entry
+
+    def entry_for(self, resume: ResumeToken | None) -> RunnerEntry:
+        if resume is None:
+            return self.entry_for_engine(None)
+        return self.entry_for_engine(resume.engine)
+
+    def runner_for(self, resume: ResumeToken | None) -> Runner:
+        entry = self.entry_for(resume)
+        if not entry.available:
+            raise RunnerUnavailableError(entry.engine, entry.issue)
+        return entry.runner
+
+    def format_resume(self, token: ResumeToken) -> str:
+        entry = self.entry_for(token)
+        return entry.runner.format_resume(token)
+
+    def extract_resume(self, text: str | None) -> ResumeToken | None:
+        if not text:
+            return None
+        for entry in self._entries:
+            token = entry.runner.extract_resume(text)
+            if token is not None:
+                return token
+        return None
+
+    def resolve_resume(
+        self, text: str | None, reply_text: str | None
+    ) -> ResumeToken | None:
+        token = self.extract_resume(text)
+        if token is not None:
+            return token
+        if reply_text is None:
+            return None
+        return self.extract_resume(reply_text)
+
+    def is_resume_line(self, line: str) -> bool:
+        return any(entry.runner.is_resume_line(line) for entry in self._entries)