synth-ai 0.4.1__py3-none-any.whl → 0.4.4__py3-none-any.whl

synth_ai/cli/commands/status/config.py

@@ -1,92 +1,12 @@
-"""Configuration utilities for the status command suite.
-
-Provides helpers to resolve backend URLs, API keys, and request timeouts
-from CLI options and environment variables.
-"""
+"""Configuration helpers for status commands."""
 
 from __future__ import annotations
 
-import importlib
-import os
-from collections.abc import Callable
 from dataclasses import dataclass
 
-DEFAULT_TIMEOUT = 30.0
-
-
-def _load_backend_helpers() -> tuple[str, Callable[[], tuple[str, str]] | None]:
-    """Attempt to load shared backend helpers from synth_ai.core.env."""
-    try:
-        module = importlib.import_module("synth_ai.core.env")
-    except Exception:
-        return "https://api.usesynth.ai", None
-
-    default = getattr(module, "PROD_BASE_URL_DEFAULT", "https://api.usesynth.ai")
-    getter = getattr(module, "get_backend_from_env", None)
-    return str(default), getter if callable(getter) else None
-
-
-PROD_BASE_URL_DEFAULT, _GET_BACKEND_FROM_ENV = _load_backend_helpers()
-
-
-def _normalize_base_url(raw: str) -> str:
-    """Ensure the configured base URL includes the /api/v1 prefix."""
-    base = raw.rstrip("/") if raw else ""
-    if not base:
-        return raw
-    if base.endswith("/api") or base.endswith("/api/v1") or "/api/" in base:
-        return base
-    return f"{base}/api/v1"
-
 
-def _default_base_url() -> str:
-    """Compute the default backend base URL using env vars or helper module."""
-    for var in ("SYNTH_BACKEND_BASE_URL", "BACKEND_BASE_URL", "SYNTH_BASE_URL"):
-        val = os.getenv(var)
-        if val:
-            return _normalize_base_url(val)
-    if _GET_BACKEND_FROM_ENV:
-        try:
-            base, _ = _GET_BACKEND_FROM_ENV()
-            return _normalize_base_url(base)
-        except Exception:
-            pass
-    return _normalize_base_url(PROD_BASE_URL_DEFAULT)
-
-
-def _resolve_api_key(cli_key: str | None) -> tuple[str | None, str | None]:
-    """Resolve the API key from CLI input or known environment variables."""
-    if cli_key:
-        return cli_key, "--api-key"
-    for var in ("SYNTH_BACKEND_API_KEY", "SYNTH_API_KEY", "DEFAULT_DEV_API_KEY"):
-        val = os.getenv(var)
-        if val:
-            return val, var
-    return None, None
-
-
-@dataclass()
+@dataclass
 class BackendConfig:
-    """Configuration bundle shared across status commands."""
-
     base_url: str
     api_key: str | None
-    timeout: float = DEFAULT_TIMEOUT
-
-    @property
-    def headers(self) -> dict[str, str]:
-        if not self.api_key:
-            return {}
-        return {"Authorization": f"Bearer {self.api_key}"}
-
-
-def resolve_backend_config(
-    *,
-    base_url: str | None,
-    api_key: str | None,
-    timeout: float | None = None,
-) -> BackendConfig:
-    """Resolve the backend configuration from CLI options/environment."""
-    resolved_url = _normalize_base_url(base_url) if base_url else _default_base_url()
-    key, _ = _resolve_api_key(api_key)
-    return BackendConfig(base_url=resolved_url, api_key=key, timeout=timeout or DEFAULT_TIMEOUT)
+    timeout: float = 30.0

synth_ai/cli/commands/status/errors.py

@@ -1,20 +1,11 @@
-from __future__ import annotations
-
-"""
-Custom error hierarchy for status CLI commands.
-"""
+"""Errors for status CLI helpers."""
 
+from __future__ import annotations
 
 
 class StatusAPIError(RuntimeError):
-    """Raised when the backend returns a non-success response."""
+    """Raised when status API calls fail."""
 
-    def __init__(self, message: str, status_code: int | None = None):
+    def __init__(self, message: str, *, status_code: int | None = None) -> None:
         super().__init__(message)
         self.status_code = status_code
-
-
-class StatusCLIError(RuntimeError):
-    """Raised for client-side validation errors."""
-
-    pass

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

@@ -1,9 +1,3 @@
-"""
-Subcommands for the status CLI namespace.
-"""
+"""Status subcommands."""
 
-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
+from __future__ import annotations

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

@@ -0,0 +1,13 @@
+"""Status configuration helpers."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+
+
+
+@dataclass
+class StatusConfig:
+    base_url: str = "https://api.usesynth.ai"

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

@@ -1,79 +1,34 @@
-"""`synth files` command group."""
+"""Status files subcommand."""
 
 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
+from .config import StatusConfig
+from .utils import StatusAPIClient, print_json
 
 
-@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())
+@click.group("files")
+def files_group() -> None:
+    return None
 
 
 @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)
-
+@click.option("--json", "as_json", is_flag=True, default=False)
+def get_file(file_id: str, as_json: bool) -> None:
     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}")
+        config = StatusConfig()
+        async with StatusAPIClient(config) as client:
+            data = await client.get_file(file_id)  # type: ignore[attr-defined]
+            if as_json:
+                print_json(data)
+            else:
+                click.echo(data)
 
     asyncio.run(_run())
+
+
+__all__ = ["files_group"]

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

@@ -1,334 +1,51 @@
-"""`synth jobs` command group implementation."""
+"""Status jobs subcommand."""
 
 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
+from .config import StatusConfig
+from .utils import StatusAPIClient, print_json
 
 
-@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))
+@click.group("jobs")
+def jobs_group() -> None:
+    return None
 
 
 @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)
-
+@click.option("--json", "as_json", is_flag=True, default=False)
+@click.option("--status", default=None)
+def list_jobs(as_json: bool, status: str | None) -> None:
     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}")
+        config = StatusConfig()
+        async with StatusAPIClient(config) as client:
+            data = await client.list_jobs(status=status)  # type: ignore[attr-defined]
+            if as_json:
+                print_json(data)
+            else:
+                click.echo(data)
 
     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()
+@jobs_group.command("logs")
 @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)
-
+@click.option("--json", "as_json", is_flag=True, default=False)
+@click.option("--tail", default=None, type=int)
+def logs(job_id: str, as_json: bool, tail: int | None) -> None:
     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}")
+        config = StatusConfig()
+        async with StatusAPIClient(config) as client:
+            data = await client.get_job_events(job_id, limit=tail)  # type: ignore[attr-defined]
+            if as_json:
+                print_json(data)
+            else:
+                click.echo(data)
 
     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())
+__all__ = ["jobs_group"]