Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
"""Shared progress bar utilities for LoCoMo benchmark scripts.
Provides a four-state progress bar (successful / failed / running / pending) built on
top of ``rich.progress``, plus helpers for both threaded and asyncio
scenarios.
"""
from __future__ import annotations
import sys
import time
from typing import Optional
from rich.console import Console
from rich.progress import (
Progress,
ProgressColumn,
Task,
TaskID,
TextColumn,
)
from rich.table import Column
from rich.text import Text
from openviking.session.train.components.progress import ProgressSummaryColumn
def format_duration(seconds: float) -> str:
"""Format a duration as compact h/m/s text for progress displays."""
total_seconds = max(0, int(round(seconds)))
hours, remainder = divmod(total_seconds, 3600)
minutes, secs = divmod(remainder, 60)
if hours:
return f"{hours}h{minutes:02d}m{secs:02d}s"
if minutes:
return f"{minutes}m{secs:02d}s"
return f"{secs}s"
class ElapsedTimeColumn(ProgressColumn):
"""Render wall-clock elapsed time for a progress task."""
def render(self, task: Task) -> Text:
started_at = task.fields.get("started_at")
if started_at is None:
return Text("elapsed: 0s", style="dim")
elapsed = format_duration(time.monotonic() - float(started_at))
return Text(f"elapsed: {elapsed}", style="dim")
# ---------------------------------------------------------------------------
# Multi-state bar column
# ---------------------------------------------------------------------------
class ThreeStateBarColumn(ProgressColumn):
"""A progress bar that renders four states: successful / failed / running / pending.
- **successful** = solid green
- **failed** = solid red
- **running** = shaded yellow
- **pending** = hollow / background
The number of in-flight items is read from
``task.fields.get("running", 0)``. The total bar width maps to
``task.total``; ``task.completed`` is the processed count and
``task.fields["failed"]`` splits failures out of that processed count.
"""
def __init__(
self,
bar_width: int = 28,
style: str = "bar.complete",
running_style: str = "bar.finished",
complete_style: Optional[str] = None,
finished_style: Optional[str] = None,
pulse_style: str = "bar.pulse",
table_column: Optional[Column] = None,
) -> None:
super().__init__(table_column=table_column or Column(ratio=1, no_wrap=True))
self.bar_width = bar_width
self.style = style
# "complete" = done portion, "finished" = running portion.
# We accept both naming conventions so callers can override freely.
self.complete_style = complete_style or style
self.finished_style = finished_style or running_style
self.pulse_style = pulse_style
def render(self, task: Task) -> Text:
"""Render the four-state bar."""
bar_width = self.bar_width or 40
total = max(task.total or 0, 0)
processed = max(task.completed or 0, 0)
failed = max(int(task.fields.get("failed", 0) or 0), 0)
done = max(int(task.fields.get("succeeded", processed - failed) or 0), 0)
running = max(int(task.fields.get("running", 0) or 0), 0)
if total <= 0:
# Degenerate case: show empty bar
return Text("─" * bar_width, style="bar.back")
# Clamp so we don't exceed 100% visually
done = min(done, total)
failed = min(failed, total - done)
running = min(running, total - done - failed)
done_width = int(bar_width * done / total)
failed_width = int(bar_width * (done + failed) / total) - done_width
running_width = (
int(bar_width * (done + failed + running) / total) - done_width - failed_width
)
pending_width = bar_width - done_width - failed_width - running_width
bar = Text()
if done_width > 0:
bar.append("█" * done_width, style="green")
if failed_width > 0:
bar.append("█" * failed_width, style="red")
if running_width > 0:
bar.append("▓" * running_width, style="yellow")
if pending_width > 0:
bar.append("░" * pending_width, style="dim")
return bar
# ---------------------------------------------------------------------------
# Factory
# ---------------------------------------------------------------------------
def make_three_state_progress(
description: str = "Progress",
console: Optional[Console] = None,
transient: bool = False,
) -> tuple[Progress, TaskID]:
"""Create a :class:`Progress` instance with a four-state bar.
Returns the ``(progress, task_id)`` pair. The task starts with
``completed=0``, ``total=0``, ``running=0``, ``failed=0``; callers
should call ``progress.update(task_id, total=N)`` to set the total and
use a tracker to keep success/failure/running fields in sync.
"""
console = console or Console(stderr=True, soft_wrap=False)
progress = Progress(
ThreeStateBarColumn(),
TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
ProgressSummaryColumn(),
ElapsedTimeColumn(),
console=console,
transient=transient,
)
task_id = progress.add_task(
description,
total=0,
running=0,
succeeded=0,
failed=0,
started_at=time.monotonic(),
)
return progress, task_id
def should_show_progress(no_progress_flag: bool) -> bool:
"""Decide whether to render a progress bar.
Disabled when the user explicitly passed ``--no-progress`` or when
stderr is not a TTY (e.g. redirected to a file / CI logs).
"""
if no_progress_flag:
return False
return sys.stderr.isatty()
# ---------------------------------------------------------------------------
# Thread-safe counter (for run_eval.py's ThreadPoolExecutor)
# ---------------------------------------------------------------------------
class ThreadSafeProgressTracker:
"""Thin wrapper around a rich Progress that keeps ``running`` count
correct when tasks start/finish from multiple threads.
Usage::
tracker = ThreadSafeProgressTracker(progress, task_id, total=N)
# For each job:
tracker.job_started()
try:
... do work ...
finally:
tracker.job_finished()
"""
def __init__(self, progress: Progress, task_id: TaskID, total: int) -> None:
import threading
self._progress = progress
self._task_id = task_id
self._lock = threading.Lock()
self._running = 0
self._done = 0
self._failed = 0
self._total = total
self._progress.update(task_id, total=total, completed=0, running=0, succeeded=0, failed=0)
def job_started(self) -> None:
"""Call when a worker thread picks up a job."""
with self._lock:
self._running += 1
self._progress.update(
self._task_id,
running=self._running,
)
def job_finished(self, *, failed: bool = False) -> None:
"""Call when a worker thread finishes a job."""
with self._lock:
self._running = max(0, self._running - 1)
self._done += 1
if failed:
self._failed += 1
self._progress.update(
self._task_id,
completed=self._done,
running=self._running,
succeeded=self._done - self._failed,
failed=self._failed,
)
@property
def done(self) -> int:
with self._lock:
return self._done
@property
def running(self) -> int:
with self._lock:
return self._running
@property
def failed(self) -> int:
with self._lock:
return self._failed
# ---------------------------------------------------------------------------
# Async-safe counter (for judge.py's asyncio semaphore pattern)
# ---------------------------------------------------------------------------
class AsyncProgressTracker:
"""Same idea as :class:`ThreadSafeProgressTracker` but for asyncio.
Since asyncio tasks all run on the same event loop, we don't strictly
need a lock; we keep one anyway for clarity and in case someone later
mixes threads in.
"""
def __init__(self, progress: Progress, task_id: TaskID, total: int) -> None:
self._progress = progress
self._task_id = task_id
self._running = 0
self._done = 0
self._failed = 0
self._total = total
self._progress.update(task_id, total=total, completed=0, running=0, succeeded=0, failed=0)
def job_started(self) -> None:
self._running += 1
self._progress.update(self._task_id, running=self._running)
def job_finished(self, *, failed: bool = False) -> None:
self._running = max(0, self._running - 1)
self._done += 1
if failed:
self._failed += 1
self._progress.update(
self._task_id,
completed=self._done,
running=self._running,
succeeded=self._done - self._failed,
failed=self._failed,
)
@property
def done(self) -> int:
return self._done
@property
def running(self) -> int:
return self._running
@property
def failed(self) -> int:
return self._failed