synth-ai 0.2.16__py3-none-any.whl → 0.2.17__py3-none-any.whl

synth_ai/cli/commands/status/formatters.py

@@ -0,0 +1,164 @@
+"""Rich-based formatting helpers for status commands."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterable
+from datetime import datetime
+from typing import Any
+
+from rich import box
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+console = Console()
+
+
+def _format_timestamp(value: Any) -> str:
+    if value in (None, "", 0):
+        return ""
+    if isinstance(value, int | float):
+        try:
+            return datetime.fromtimestamp(float(value)).isoformat()
+        except Exception:
+            return str(value)
+    if isinstance(value, str):
+        try:
+            return datetime.fromisoformat(value.replace("Z", "+00:00")).strftime("%Y-%m-%d %H:%M:%S")
+        except Exception:
+            return value
+    return str(value)
+
+
+def print_json(data: Any) -> None:
+    console.print_json(data=data)
+
+
+def jobs_table(jobs: Iterable[dict[str, Any]]) -> Table:
+    table = Table(title="Training Jobs", box=box.SIMPLE, header_style="bold")
+    table.add_column("ID", style="cyan", overflow="fold")
+    table.add_column("Type", style="magenta")
+    table.add_column("Status")
+    table.add_column("Created", style="green")
+    table.add_column("Updated", style="green")
+    table.add_column("Model", style="yellow", overflow="fold")
+    for job in jobs:
+        status = job.get("status", "unknown")
+        status_color = {
+            "running": "green",
+            "queued": "cyan",
+            "succeeded": "bright_green",
+            "failed": "red",
+            "cancelled": "yellow",
+        }.get(status, "white")
+        table.add_row(
+            str(job.get("job_id") or job.get("id", "")),
+            str(job.get("training_type") or job.get("type", "")),
+            f"[{status_color}]{status}[/{status_color}]",
+            _format_timestamp(job.get("created_at")),
+            _format_timestamp(job.get("updated_at")),
+            str(job.get("model_id") or job.get("model", "")),
+        )
+    return table
+
+
+def job_panel(job: dict[str, Any]) -> Panel:
+    lines = [f"[bold cyan]Job[/bold cyan] {job.get('job_id') or job.get('id')}"]
+    if job.get("name"):
+        lines.append(f"Name: {job['name']}")
+    lines.append(f"Type: {job.get('training_type', job.get('type', ''))}")
+    lines.append(f"Status: {job.get('status', 'unknown')}")
+    if job.get("model_id"):
+        lines.append(f"Model: {job['model_id']}")
+    if job.get("base_model"):
+        lines.append(f"Base Model: {job['base_model']}")
+    lines.append(f"Created: {_format_timestamp(job.get('created_at'))}")
+    lines.append(f"Updated: {_format_timestamp(job.get('updated_at'))}")
+    if config := job.get("config"):
+        lines.append("")
+        lines.append(f"[dim]{json.dumps(config, indent=2, sort_keys=True)}[/dim]")
+    return Panel("\n".join(lines), title="Job Details", border_style="cyan")
+
+
+def runs_table(runs: Iterable[dict[str, Any]]) -> Table:
+    table = Table(title="Job Runs", box=box.SIMPLE, header_style="bold")
+    table.add_column("Run #", justify="right")
+    table.add_column("Engine")
+    table.add_column("Status")
+    table.add_column("Created")
+    table.add_column("Started")
+    table.add_column("Ended")
+    table.add_column("Duration", justify="right")
+    for run in runs:
+        table.add_row(
+            str(run.get("run_number") or run.get("id", "")),
+            str(run.get("engine", "")),
+            str(run.get("status", "unknown")),
+            _format_timestamp(run.get("created_at")),
+            _format_timestamp(run.get("started_at")),
+            _format_timestamp(run.get("ended_at")),
+            str(run.get("duration_seconds") or run.get("duration", "")),
+        )
+    return table
+
+
+def events_panel(events: Iterable[dict[str, Any]]) -> Panel:
+    rendered = []
+    for event in events:
+        ts = _format_timestamp(event.get("timestamp") or event.get("created_at"))
+        level = event.get("level") or event.get("severity", "info")
+        message = event.get("message") or event.get("detail") or ""
+        rendered.append(f"[dim]{ts}[/dim] [{level}] {message}")
+    if not rendered:
+        rendered.append("[dim]No events found.[/dim]")
+    return Panel("\n".join(rendered), title="Job Events", border_style="green")
+
+
+def metrics_table(metrics: dict[str, Any]) -> Table:
+    table = Table(title="Job Metrics", box=box.SIMPLE, header_style="bold")
+    table.add_column("Metric")
+    table.add_column("Value", justify="right")
+    for key, value in metrics.items():
+        if isinstance(value, dict):
+            table.add_row(key, Text(json.dumps(value), overflow="fold"))
+        else:
+            table.add_row(key, str(value))
+    return table
+
+
+def files_table(files: Iterable[dict[str, Any]]) -> Table:
+    table = Table(title="Training Files", box=box.SIMPLE, header_style="bold")
+    table.add_column("ID", overflow="fold")
+    table.add_column("Purpose")
+    table.add_column("Size", justify="right")
+    table.add_column("Created")
+    table.add_column("Filename", overflow="fold")
+    for file in files:
+        table.add_row(
+            str(file.get("file_id") or file.get("id", "")),
+            str(file.get("purpose", "")),
+            str(file.get("bytes", "")),
+            _format_timestamp(file.get("created_at")),
+            str(file.get("filename", "")),
+        )
+    return table
+
+
+def models_table(models: Iterable[dict[str, Any]]) -> Table:
+    table = Table(title="Fine-tuned Models", box=box.SIMPLE, header_style="bold")
+    table.add_column("ID", overflow="fold")
+    table.add_column("Base")
+    table.add_column("Created")
+    table.add_column("Owner")
+    table.add_column("Status")
+    for model in models:
+        table.add_row(
+            str(model.get("id", model.get("name", ""))),
+            str(model.get("base_model") or model.get("base", "")),
+            _format_timestamp(model.get("created_at")),
+            str(model.get("owner") or model.get("organization", "")),
+            str(model.get("status", "")),
+        )
+    return table

synth_ai/cli/commands/status/subcommands/__init__.py

@@ -0,0 +1,9 @@
+"""
+Subcommands for the status CLI namespace.
+"""
+
+from .files import files_group  # noqa: F401
+from .jobs import jobs_group  # noqa: F401
+from .models import models_group  # noqa: F401
+from .runs import runs_group  # noqa: F401
+from .summary import summary_command  # noqa: F401

synth_ai/cli/commands/status/subcommands/files.py

@@ -0,0 +1,79 @@
+"""`synth files` command group."""
+
+from __future__ import annotations
+
+import asyncio
+
+import click
+from rich.json import JSON
+
+from ..client import StatusAPIClient
+from ..errors import StatusAPIError
+from ..formatters import console, files_table, print_json
+from ..utils import bail, common_options, resolve_context_config
+
+
+@click.group("files", help="Manage training files.")
+@click.pass_context
+def files_group(ctx: click.Context) -> None:  # pragma: no cover - Click wiring
+    ctx.ensure_object(dict)
+
+
+@files_group.command("list")
+@common_options()
+@click.option("--purpose", type=click.Choice(["fine-tune", "validation"]))
+@click.option("--limit", type=int, default=20, show_default=True)
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def list_files(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    purpose: str | None,
+    limit: int,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                files = await client.list_files(purpose=purpose, limit=limit)
+                if output_json:
+                    print_json(files)
+                else:
+                    console.print(files_table(files))
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())
+
+
+@files_group.command("get")
+@common_options()
+@click.argument("file_id")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def get_file(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    file_id: str,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                file_info = await client.get_file(file_id)
+                if output_json:
+                    print_json(file_info)
+                else:
+                    console.print(JSON.from_data(file_info))
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())

synth_ai/cli/commands/status/subcommands/jobs.py

@@ -0,0 +1,334 @@
+"""`synth jobs` command group implementation."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+import click
+
+from ..client import StatusAPIClient
+from ..errors import StatusAPIError
+from ..formatters import (
+    console,
+    events_panel,
+    job_panel,
+    jobs_table,
+    metrics_table,
+    print_json,
+    runs_table,
+)
+from ..utils import bail, common_options, parse_relative_time, resolve_context_config
+
+
+@click.group("jobs", help="Manage training jobs.")
+@click.pass_context
+def jobs_group(ctx: click.Context) -> None:  # pragma: no cover - Click wiring
+    ctx.ensure_object(dict)
+
+
+def _print_or_json(items: Any, output_json: bool) -> None:
+    if output_json:
+        print_json(items)
+    elif isinstance(items, list):
+        console.print(jobs_table(items))
+    else:
+        console.print(job_panel(items))
+
+
+@jobs_group.command("list")
+@common_options()
+@click.option(
+    "--status",
+    type=click.Choice(["queued", "running", "succeeded", "failed", "cancelled"]),
+    help="Filter by job status.",
+)
+@click.option(
+    "--type",
+    "job_type",
+    type=click.Choice(["sft_offline", "sft_online", "rl_online", "dpo", "sft"]),
+    help="Filter by training job type.",
+)
+@click.option("--created-after", help="Filter by creation date (ISO8601 or relative like '24h').")
+@click.option("--limit", default=20, show_default=True, type=int)
+@click.option("--json", "output_json", is_flag=True, help="Emit raw JSON.")
+@click.pass_context
+def list_jobs(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    status: str | None,
+    job_type: str | None,
+    created_after: str | None,
+    limit: int,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+    created_filter = parse_relative_time(created_after)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                jobs = await client.list_jobs(
+                    status=status,
+                    job_type=job_type,
+                    created_after=created_filter,
+                    limit=limit,
+                )
+                _print_or_json(jobs, output_json)
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())
+
+
+@jobs_group.command("get")
+@common_options()
+@click.argument("job_id")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def get_job(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    job_id: str,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                job = await client.get_job(job_id)
+                _print_or_json(job, output_json)
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())
+
+
+@jobs_group.command("history")
+@common_options()
+@click.argument("job_id")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def job_history(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    job_id: str,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                runs = await client.list_job_runs(job_id)
+                if output_json:
+                    print_json(runs)
+                else:
+                    console.print(runs_table(runs))
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())
+
+
+@jobs_group.command("timeline")
+@common_options()
+@click.argument("job_id")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def job_timeline(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    job_id: str,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                timeline = await client.get_job_timeline(job_id)
+                if output_json:
+                    print_json(timeline)
+                else:
+                    console.print(events_panel(timeline))
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())
+
+
+@jobs_group.command("metrics")
+@common_options()
+@click.argument("job_id")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def job_metrics(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    job_id: str,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                metrics = await client.get_job_metrics(job_id)
+                if output_json:
+                    print_json(metrics)
+                else:
+                    console.print(metrics_table(metrics))
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())
+
+
+@jobs_group.command("config")
+@common_options()
+@click.argument("job_id")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def job_config(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    job_id: str,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                config = await client.get_job_config(job_id)
+                if output_json:
+                    print_json(config)
+                else:
+                    console.print(job_panel({"job_id": job_id, "config": config}))
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())
+
+
+@jobs_group.command("status")
+@common_options()
+@click.argument("job_id")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def job_status(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    job_id: str,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                status = await client.get_job_status(job_id)
+                if output_json:
+                    print_json(status)
+                else:
+                    console.print(f"[bold]{job_id}[/bold]: {status.get('status', 'unknown')}")
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())
+
+
+@jobs_group.command("cancel")
+@common_options()
+@click.argument("job_id")
+@click.pass_context
+def cancel_job(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    job_id: str,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                resp = await client.cancel_job(job_id)
+                console.print(resp.get("message") or f"[yellow]Cancellation requested for {job_id}[/yellow]")
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())
+
+
+@jobs_group.command("logs")
+@common_options()
+@click.argument("job_id")
+@click.option("--since", help="Only show events emitted after the provided timestamp/relative offset.")
+@click.option("--tail", type=int, help="Show only the last N events.")
+@click.option("--follow/--no-follow", default=False, help="Poll for new events.")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def job_logs(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    job_id: str,
+    since: str | None,
+    tail: int | None,
+    follow: bool,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+    since_filter = parse_relative_time(since)
+
+    async def _loop() -> None:
+        seen_ids: set[str] = set()
+        cursor: str | None = None
+        try:
+            async with StatusAPIClient(cfg) as client:
+                while True:
+                    events = await client.get_job_events(
+                        job_id,
+                        since=cursor or since_filter,
+                        limit=tail,
+                        after=cursor,
+                    )
+                    new_events: list[dict[str, Any]] = []
+                    for event in events:
+                        event_id = str(event.get("event_id") or event.get("id") or event.get("timestamp"))
+                        if event_id in seen_ids:
+                            continue
+                        seen_ids.add(event_id)
+                        new_events.append(event)
+                    if new_events:
+                        cursor = str(new_events[-1].get("event_id") or new_events[-1].get("id") or "")
+                        if output_json:
+                            print_json(new_events)
+                        else:
+                            console.print(events_panel(new_events))
+                    if not follow:
+                        break
+                    await asyncio.sleep(2.0)
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_loop())

synth_ai/cli/commands/status/subcommands/models.py

@@ -0,0 +1,79 @@
+"""`synth models` command group."""
+
+from __future__ import annotations
+
+import asyncio
+
+import click
+from rich.json import JSON
+
+from ..client import StatusAPIClient
+from ..errors import StatusAPIError
+from ..formatters import console, models_table, print_json
+from ..utils import bail, common_options, resolve_context_config
+
+
+@click.group("models", help="Inspect fine-tuned models.")
+@click.pass_context
+def models_group(ctx: click.Context) -> None:  # pragma: no cover - Click wiring
+    ctx.ensure_object(dict)
+
+
+@models_group.command("list")
+@common_options()
+@click.option("--limit", type=int, default=None, help="Maximum number of models to return.")
+@click.option("--type", "model_type", type=click.Choice(["rl", "sft"]), default=None, help="Filter by model type.")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def list_models(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    limit: int | None,
+    model_type: str | None,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                models = await client.list_models(limit=limit, model_type=model_type)
+                if output_json:
+                    print_json(models)
+                else:
+                    console.print(models_table(models))
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())
+
+
+@models_group.command("get")
+@common_options()
+@click.argument("model_id")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def get_model(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    model_id: str,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                model = await client.get_model(model_id)
+                if output_json:
+                    print_json(model)
+                else:
+                    console.print(JSON.from_data(model))
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())