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

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())

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

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import click
+from rich.table import Table
+from synth_ai.pricing.model_pricing import MODEL_PRICES
+
+from ..formatters import console
+
+
+@click.command("pricing", help="List supported provider/model rates (SDK static table).")
+def pricing_command() -> None:
+    table = Table(title="Supported Models and Rates (USD/token)")
+    table.add_column("Provider", style="cyan", no_wrap=True)
+    table.add_column("Model", style="magenta")
+    table.add_column("Input USD", justify="right")
+    table.add_column("Output USD", justify="right")
+    for provider, models in MODEL_PRICES.items():
+        for model, rates in models.items():
+            table.add_row(provider, model, f"{rates.input_usd:.9f}", f"{rates.output_usd:.9f}")
+    console.print(table)
+
+

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

@@ -0,0 +1,81 @@
+"""`synth runs` command group."""
+
+from __future__ import annotations
+
+import asyncio
+
+import click
+
+from ..client import StatusAPIClient
+from ..errors import StatusAPIError
+from ..formatters import console, events_panel, print_json, runs_table
+from ..utils import bail, common_options, parse_relative_time, resolve_context_config
+
+
+@click.group("runs", help="Inspect individual job runs/attempts.")
+@click.pass_context
+def runs_group(ctx: click.Context) -> None:  # pragma: no cover - Click wiring
+    ctx.ensure_object(dict)
+
+
+@runs_group.command("list")
+@common_options()
+@click.argument("job_id")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def list_runs(
+    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())
+
+
+@runs_group.command("logs")
+@common_options()
+@click.argument("job_id")
+@click.option("--run", "run_id", required=True, help="Run identifier (number or ID) to inspect.")
+@click.option("--since", help="Filter events after the supplied timestamp/relative offset.")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def run_logs(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    job_id: str,
+    run_id: str,
+    since: str | None,
+    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 _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                events = await client.get_job_events(job_id, since=since_filter, run_id=run_id)
+                if output_json:
+                    print_json(events)
+                else:
+                    console.print(events_panel(events))
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())

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

@@ -0,0 +1,47 @@
+"""`synth status summary` command."""
+
+from __future__ import annotations
+
+import asyncio
+
+import click
+
+from ..client import StatusAPIClient
+from ..errors import StatusAPIError
+from ..formatters import console, files_table, jobs_table, models_table
+from ..utils import common_options, resolve_context_config
+
+
+@click.command("summary", help="Show a condensed overview of recent jobs, models, and files.")
+@common_options()
+@click.option("--limit", default=5, show_default=True, type=int, help="Rows per section.")
+@click.pass_context
+def summary_command(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    limit: int,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> tuple[list[dict[str, object]], list[dict[str, object]], list[dict[str, object]]]:
+        async with StatusAPIClient(cfg) as client:
+            try:
+                jobs = await client.list_jobs(limit=limit)
+            except StatusAPIError:
+                jobs = []
+            try:
+                models = await client.list_models(limit=limit)
+            except StatusAPIError:
+                models = []
+            try:
+                files = await client.list_files(limit=limit)
+            except StatusAPIError:
+                files = []
+        return jobs, models, files
+
+    jobs, models, files = asyncio.run(_run())
+    console.print(jobs_table(jobs[:limit]))
+    console.print(models_table(models[:limit]))
+    console.print(files_table(files[:limit]))