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

synth_ai/cli/commands/status/__init__.py

@@ -0,0 +1,3 @@
+"""Status command package."""
+
+from __future__ import annotations

synth_ai/cli/commands/status/client.py

@@ -0,0 +1,91 @@
+"""HTTP client for status commands."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from .config import BackendConfig
+from .errors import StatusAPIError
+from .utils import build_headers
+
+
+class StatusAPIClient:
+    def __init__(self, config: BackendConfig) -> None:
+        self._config = config
+        self._client: httpx.AsyncClient | None = None
+
+    async def __aenter__(self) -> "StatusAPIClient":
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                base_url=self._config.base_url,
+                headers=build_headers(self._config.api_key),
+                timeout=self._config.timeout,
+            )
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        if self._client is not None:
+            await self._client.aclose()
+            self._client = None
+
+    async def _get(self, path: str, params: dict[str, Any] | None = None) -> dict[str, Any]:
+        assert self._client is not None
+        resp = await self._client.get(path, params=params)
+        if resp.status_code >= 400:
+            detail = resp.json().get("detail", "")
+            raise StatusAPIError(detail or "Request failed", status_code=resp.status_code)
+        return resp.json()
+
+    async def _post(self, path: str, payload: dict[str, Any] | None = None) -> dict[str, Any]:
+        assert self._client is not None
+        resp = await self._client.post(path, json=payload or {})
+        if resp.status_code >= 400:
+            detail = resp.json().get("detail", "")
+            raise StatusAPIError(detail or "Request failed", status_code=resp.status_code)
+        return resp.json()
+
+    async def list_jobs(
+        self,
+        *,
+        status: str | None = None,
+        job_type: str | None = None,
+        created_after: str | None = None,
+        limit: int | None = None,
+    ) -> list[dict[str, Any]]:
+        params: dict[str, Any] = {}
+        if status is not None:
+            params["status"] = status
+        if job_type is not None:
+            params["type"] = job_type
+        if created_after is not None:
+            params["created_after"] = created_after
+        if limit is not None:
+            params["limit"] = limit
+        payload = await self._get("/learning/jobs", params=params or None)
+        return payload.get("jobs", [])
+
+    async def get_job(self, job_id: str) -> dict[str, Any]:
+        return await self._get(f"/learning/jobs/{job_id}")
+
+    async def cancel_job(self, job_id: str) -> dict[str, Any]:
+        return await self._post(f"/learning/jobs/{job_id}/cancel")
+
+    async def list_models(
+        self,
+        *,
+        limit: int | None = None,
+        model_type: str | None = None,
+    ) -> list[dict[str, Any]]:
+        if model_type:
+            payload = await self._get(f"/learning/models/{model_type}")
+            return payload.get("models", [])
+        params = {"limit": limit} if limit is not None else None
+        payload = await self._get("/learning/models", params=params)
+        return payload.get("models", [])
+
+    async def list_job_runs(self, job_id: str) -> list[dict[str, Any]]:
+        payload = await self._get(f"/jobs/{job_id}/runs")
+        return payload.get("runs", [])
+

synth_ai/cli/commands/status/config.py

@@ -0,0 +1,12 @@
+"""Configuration helpers for status commands."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class BackendConfig:
+    base_url: str
+    api_key: str | None
+    timeout: float = 30.0

synth_ai/cli/commands/status/errors.py

@@ -0,0 +1,11 @@
+"""Errors for status CLI helpers."""
+
+from __future__ import annotations
+
+
+class StatusAPIError(RuntimeError):
+    """Raised when status API calls fail."""
+
+    def __init__(self, message: str, *, status_code: int | None = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code

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

@@ -0,0 +1,3 @@
+"""Status subcommands."""
+
+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

@@ -0,0 +1,34 @@
+"""Status files subcommand."""
+
+from __future__ import annotations
+
+import asyncio
+
+import click
+
+from .config import StatusConfig
+from .utils import StatusAPIClient, print_json
+
+
+@click.group("files")
+def files_group() -> None:
+    return None
+
+
+@files_group.command("get")
+@click.argument("file_id")
+@click.option("--json", "as_json", is_flag=True, default=False)
+def get_file(file_id: str, as_json: bool) -> None:
+    async def _run() -> None:
+        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

@@ -0,0 +1,51 @@
+"""Status jobs subcommand."""
+
+from __future__ import annotations
+
+import asyncio
+
+import click
+
+from .config import StatusConfig
+from .utils import StatusAPIClient, print_json
+
+
+@click.group("jobs")
+def jobs_group() -> None:
+    return None
+
+
+@jobs_group.command("list")
+@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:
+        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("logs")
+@click.argument("job_id")
+@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:
+        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())
+
+
+__all__ = ["jobs_group"]

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

@@ -0,0 +1,35 @@
+"""Status models subcommand."""
+
+from __future__ import annotations
+
+import asyncio
+
+import click
+
+from .config import StatusConfig
+from .utils import StatusAPIClient, print_json
+
+
+@click.group("models")
+def models_group() -> None:
+    return None
+
+
+@models_group.command("list")
+@click.option("--limit", default=None, type=int)
+@click.option("--type", "model_type", default=None)
+@click.option("--json", "as_json", is_flag=True, default=False)
+def list_models(limit: int | None, model_type: str | None, as_json: bool) -> None:
+    async def _run() -> None:
+        config = StatusConfig()
+        async with StatusAPIClient(config) as client:
+            data = await client.list_models(limit=limit, model_type=model_type)  # type: ignore[attr-defined]
+            if as_json:
+                print_json(data)
+            else:
+                click.echo(data)
+
+    asyncio.run(_run())
+
+
+__all__ = ["models_group"]

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

@@ -0,0 +1,34 @@
+"""Status runs subcommand."""
+
+from __future__ import annotations
+
+import asyncio
+
+import click
+
+from .config import StatusConfig
+from .utils import StatusAPIClient, print_json
+
+
+@click.group("runs")
+def runs_group() -> None:
+    return None
+
+
+@runs_group.command("list")
+@click.argument("job_id")
+@click.option("--json", "as_json", is_flag=True, default=False)
+def list_runs(job_id: str, as_json: bool) -> None:
+    async def _run() -> None:
+        config = StatusConfig()
+        async with StatusAPIClient(config) as client:
+            data = await client.list_job_runs(job_id)  # type: ignore[attr-defined]
+            if as_json:
+                print_json(data)
+            else:
+                click.echo(data)
+
+    asyncio.run(_run())
+
+
+__all__ = ["runs_group"]

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

@@ -0,0 +1,77 @@
+"""Status session subcommand."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from decimal import Decimal
+
+import click
+
+from synth_ai.cli.commands.artifacts.config import resolve_backend_config
+from synth_ai.cli.local.session.client import AgentSessionClient
+from synth_ai.cli.local.session.exceptions import SessionNotFoundError
+from synth_ai.cli.local.session.models import AgentSession
+
+
+def _format_currency(value: Decimal) -> str:
+    return f"${value:.2f}"
+
+
+def _format_int(value: Decimal | int) -> str:
+    return f"{int(value):,}"
+
+
+def _session_exceeded(session: AgentSession) -> bool:
+    if session.status == "limit_exceeded":
+        return True
+    for limit in session.limits:
+        if limit.current_usage >= limit.limit_value:
+            return True
+    return False
+
+
+def _render_session(session: AgentSession) -> None:
+    click.echo(f"Session: {session.session_id}")
+    click.echo(f"Status: {session.status}")
+    click.echo(f"Usage: {_format_currency(session.usage.cost_usd)}")
+    click.echo(f"Tokens: {_format_int(session.usage.tokens)}")
+    for limit in session.limits:
+        if limit.metric_type == "cost_usd":
+            click.echo(f"Limit: {_format_currency(limit.limit_value)}")
+        elif limit.metric_type == "tokens":
+            click.echo(f"Limit: {_format_int(limit.limit_value)}")
+    if _session_exceeded(session):
+        click.echo("✗ EXCEEDED")
+        click.echo("WARNING: Session limits exceeded!")
+    else:
+        click.echo("✓ OK")
+
+
+@click.command("session")
+@click.option("--session-id", default="", help="Session ID to inspect.")
+def session_status_cmd(session_id: str) -> None:
+    async def _run() -> None:
+        resolved_session_id = session_id or os.getenv("SYNTH_SESSION_ID", "")
+        config = resolve_backend_config()
+        client = AgentSessionClient(base_url=config.base_url, api_key=config.api_key)
+
+        if resolved_session_id:
+            try:
+                session = await client.get(resolved_session_id)
+            except SessionNotFoundError:
+                click.echo("Session not found")
+                return
+            _render_session(session)
+            return
+
+        sessions = await client.list(status="active")
+        if not sessions:
+            click.echo("No active session found")
+            return
+        _render_session(sessions[0])
+
+    asyncio.run(_run())
+
+
+__all__ = ["session_status_cmd"]

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

@@ -0,0 +1,39 @@
+"""Status summary command."""
+
+from __future__ import annotations
+
+import asyncio
+
+import click
+
+from synth_ai.cli.commands.status.errors import StatusAPIError
+from .config import StatusConfig
+from .utils import StatusAPIClient
+
+
+@click.command("summary")
+def summary_command() -> None:
+    async def _run() -> None:
+        config = StatusConfig()
+        async with StatusAPIClient(config) as client:
+            try:
+                jobs = await client.list_jobs()  # type: ignore[attr-defined]
+            except StatusAPIError:
+                jobs = []
+            try:
+                await client.list_models()  # type: ignore[attr-defined]
+            except StatusAPIError:
+                pass
+            try:
+                await client.list_files()  # type: ignore[attr-defined]
+            except StatusAPIError:
+                pass
+
+        click.echo("Training Jobs")
+        for job in jobs:
+            click.echo(str(job))
+
+    asyncio.run(_run())
+
+
+__all__ = ["summary_command"]

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

@@ -0,0 +1,41 @@
+"""Shared helpers for status subcommands."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import click
+import json
+
+
+class StatusAPIClient:
+    def __init__(self, config: Any) -> None:
+        self.config = config
+
+    async def __aenter__(self) -> "StatusAPIClient":
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        return None
+
+    async def list_jobs(self, **_: Any) -> list[dict[str, Any]]:
+        return []
+
+    async def get_job_events(self, *_: Any, **__: Any) -> list[dict[str, Any]]:
+        return []
+
+    async def get_file(self, *_: Any, **__: Any) -> dict[str, Any]:
+        return {}
+
+    async def list_models(self, **_: Any) -> list[dict[str, Any]]:
+        return []
+
+    async def list_job_runs(self, *_: Any, **__: Any) -> list[dict[str, Any]]:
+        return []
+
+    async def list_files(self, **_: Any) -> list[dict[str, Any]]:
+        return []
+
+
+def print_json(data: Any) -> None:
+    click.echo(json.dumps(data))

synth_ai/cli/commands/status/utils.py

@@ -0,0 +1,23 @@
+"""Utility helpers for status commands."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def build_headers(api_key: str | None) -> dict[str, str]:
+    if not api_key:
+        return {}
+    return {"Authorization": f"Bearer {api_key}", "X-API-Key": api_key}
+
+
+def ensure_status_ok(response) -> dict[str, Any]:
+    if response.status_code >= 400:
+        detail = ""
+        try:
+            payload = response.json()
+            detail = payload.get("detail", "")
+        except Exception:
+            detail = response.text
+        raise RuntimeError(detail or f"Request failed ({response.status_code})")
+    return response.json()

synth_ai/cli/commands/train/__init__.py

@@ -0,0 +1,51 @@
+from .core import register, train_command
+from .errors import (
+    InvalidRubricConfigError,
+    InvalidVerifierConfigError,
+    TrainCliError,
+)
+from .verifier_schemas import (
+    RubricConfig,
+    RubricWeightsConfig,
+    VerifierConfig,
+    VerifierOptionsConfig,
+    VerifierRequestPayload,
+    build_verifier_http_options,
+)
+from .verifier_validation import (
+    extract_and_validate_verifier_rubric,
+    validate_rubric_config,
+    validate_verifier_config,
+)
+from .validation import (
+    load_and_validate_rl,
+    load_and_validate_sft,
+    validate_rl_config,
+    validate_sft_config,
+)
+
+__all__ = [
+    # Core
+    "register",
+    "train_command",
+    # Errors
+    "TrainCliError",
+    "InvalidVerifierConfigError",
+    "InvalidRubricConfigError",
+    # SFT/RL validation
+    "validate_sft_config",
+    "validate_rl_config",
+    "load_and_validate_sft",
+    "load_and_validate_rl",
+    # Verifier/Rubric schemas
+    "RubricWeightsConfig",
+    "RubricConfig",
+    "VerifierOptionsConfig",
+    "VerifierConfig",
+    "VerifierRequestPayload",
+    "build_verifier_http_options",
+    # Verifier/Rubric validation
+    "validate_rubric_config",
+    "validate_verifier_config",
+    "extract_and_validate_verifier_rubric",
+]

synth_ai/cli/commands/train/core.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import click
+
+from synth_ai.sdk.api.train.cli import (
+    register as _register_with_cli,
+)
+from synth_ai.sdk.api.train.cli import (
+    train_command as _train_command,
+)
+
+__all__ = ["register", "train_command"]
+
+
+def register(cli: click.Group) -> None:
+    """Attach the train command to the root CLI."""
+    _register_with_cli(cli)
+
+
+def train_command(*args, **kwargs):
+    """Entrypoint used by the train CLI command."""
+    return _train_command(*args, **kwargs)

synth_ai/cli/commands/train/errors.py

@@ -0,0 +1,117 @@
+from dataclasses import dataclass
+
+
+class TrainCliError(RuntimeError):
+    """Base exception for train CLI failures."""
+
+
+@dataclass(slots=True)
+class TomlParseError(TrainCliError):
+    """Raised when TOML file cannot be parsed."""
+    path: str
+    detail: str
+
+
+@dataclass(slots=True)
+class ConfigNotFoundError(TrainCliError):
+    """Raised when config file is not found."""
+    path: str
+
+
+@dataclass(slots=True)
+class InvalidSFTConfigError(TrainCliError):
+    """Raised when SFT configuration is invalid."""
+    detail: str
+    hint: str | None = None
+
+
+@dataclass(slots=True)
+class InvalidRLConfigError(TrainCliError):
+    """Raised when RL configuration is invalid."""
+    detail: str
+    hint: str | None = None
+
+
+@dataclass(slots=True)
+class MissingAlgorithmError(TrainCliError):
+    """Raised when [algorithm] section is missing or invalid."""
+    detail: str
+
+
+@dataclass(slots=True)
+class MissingModelError(TrainCliError):
+    """Raised when model specification is missing."""
+    detail: str
+    hint: str | None = None
+
+
+@dataclass(slots=True)
+class MissingDatasetError(TrainCliError):
+    """Raised when dataset path is missing for SFT."""
+    detail: str
+    hint: str | None = None
+
+
+@dataclass(slots=True)
+class MissingComputeError(TrainCliError):
+    """Raised when compute configuration is missing or incomplete."""
+    detail: str
+    hint: str | None = None
+
+
+@dataclass(slots=True)
+class UnsupportedAlgorithmError(TrainCliError):
+    """Raised when algorithm type is not supported."""
+    algorithm_type: str
+    expected: str
+    hint: str | None = None
+
+
+@dataclass(slots=True)
+class InvalidHyperparametersError(TrainCliError):
+    """Raised when hyperparameters are invalid."""
+    detail: str
+    parameter: str | None = None
+
+
+@dataclass(slots=True)
+class InvalidTopologyError(TrainCliError):
+    """Raised when topology configuration is invalid."""
+    detail: str
+    hint: str | None = None
+
+
+@dataclass(slots=True)
+class InvalidVerifierConfigError(TrainCliError):
+    """Raised when verifier configuration validation fails."""
+    detail: str
+
+    def __str__(self) -> str:
+        return self.detail
+
+
+@dataclass(slots=True)
+class InvalidRubricConfigError(TrainCliError):
+    """Raised when rubric configuration validation fails."""
+    detail: str
+
+    def __str__(self) -> str:
+        return self.detail
+
+
+__all__ = [
+    "TrainCliError",
+    "TomlParseError",
+    "ConfigNotFoundError",
+    "InvalidSFTConfigError",
+    "InvalidRLConfigError",
+    "MissingAlgorithmError",
+    "MissingModelError",
+    "MissingDatasetError",
+    "MissingComputeError",
+    "UnsupportedAlgorithmError",
+    "InvalidHyperparametersError",
+    "InvalidTopologyError",
+    "InvalidVerifierConfigError",
+    "InvalidRubricConfigError",
+]