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

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

@@ -1,79 +1,35 @@
-"""`synth models` command group."""
+"""Status models 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, models_table, print_json
-from ..utils import bail, common_options, resolve_context_config
+from .config import StatusConfig
+from .utils import StatusAPIClient, print_json
 
 
-@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)
+@click.group("models")
+def models_group() -> None:
+    return None
 
 
 @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)
-
+@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:
-        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}")
+        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())
 
 
-@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())
+__all__ = ["models_group"]

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

@@ -1,4 +1,4 @@
-"""`synth runs` command group."""
+"""Status runs subcommand."""
 
 from __future__ import annotations
 
@@ -6,76 +6,29 @@ 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
+from .config import StatusConfig
+from .utils import StatusAPIClient, print_json
 
 
-@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)
+@click.group("runs")
+def runs_group() -> None:
+    return None
 
 
 @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)
-
+@click.option("--json", "as_json", is_flag=True, default=False)
+def list_runs(job_id: str, as_json: bool) -> 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_job_runs(job_id)  # type: ignore[attr-defined]
+            if as_json:
+                print_json(data)
+            else:
+                click.echo(data)
 
     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())
+__all__ = ["runs_group"]

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

@@ -1,182 +1,77 @@
-"""Session status command for Synth CLI."""
+"""Status session subcommand."""
 
 from __future__ import annotations
 
 import asyncio
-from typing import Optional
+import os
+from decimal import Decimal
 
 import click
-from rich.console import Console
-from rich.table import Table
-
-from synth_ai.cli.commands.status.config import resolve_backend_config
-from synth_ai.cli.local.session import AgentSessionClient, SessionNotFoundError
-
-console = Console()
-
-
-@click.command("session", help="Show current agent session status and limits.")
-@click.option(
-    "--session-id",
-    type=str,
-    default=None,
-    help="Session ID to check (default: uses active session from environment)"
-)
-@click.option(
-    "--base-url",
-    envvar="SYNTH_STATUS_BASE_URL",
-    default=None,
-    help="Synth backend base URL (defaults to environment configuration).",
-)
-@click.option(
-    "--api-key",
-    envvar="SYNTH_STATUS_API_KEY",
-    default=None,
-    help="API key for authenticated requests (falls back to Synth defaults).",
-)
-@click.option(
-    "--timeout",
-    default=30.0,
-    show_default=True,
-    type=float,
-    help="HTTP request timeout in seconds.",
-)
-def session_status_cmd(
-    session_id: Optional[str],
-    base_url: Optional[str],
-    api_key: Optional[str],
-    timeout: float,
-) -> None:
-    """Show agent session status, limits, and current usage."""
-    cfg = resolve_backend_config(base_url=base_url, api_key=api_key, timeout=timeout)
-    
+
+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:
-        import os
-        
-        # Use provided session_id or try to get from environment
-        if not session_id:
-            session_id_env = os.getenv("SYNTH_SESSION_ID")
-            if session_id_env:
-                session_id_to_use = session_id_env
-            else:
-                # Try to get active session
-                if not cfg.api_key:
-                    console.print("[red]API key is required. Set SYNTH_API_KEY environment variable.[/red]")
-                    return
-                client = AgentSessionClient(f"{cfg.base_url}/api", cfg.api_key)
-                try:
-                    async with client._http:
-                        sessions = await client.list(status="active", limit=1)
-                        if sessions:
-                            session_id_to_use = sessions[0].session_id
-                        else:
-                            console.print("[yellow]No active session found.[/yellow]")
-                            console.print("Create a session with: [cyan]uvx synth-ai codex[/cyan] or [cyan]uvx synth-ai opencode[/cyan]")
-                            return
-                except Exception as e:
-                    console.print(f"[red]Error fetching active session: {e}[/red]")
-                    return
-        else:
-            session_id_to_use = session_id
-        
-        if not cfg.api_key:
-            console.print("[red]API key is required. Set SYNTH_API_KEY environment variable.[/red]")
+        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
-        client = AgentSessionClient(f"{cfg.base_url}/api", cfg.api_key)
-        try:
-            session = await client.get(session_id_to_use)
-            
-            # Display session info
-            table = Table(title=f"Session: {session.session_id[:16]}...", show_header=True, header_style="bold cyan")
-            table.add_column("Property", style="cyan")
-            table.add_column("Value", style="green")
-            
-            table.add_row("Session ID", session.session_id)
-            table.add_row("Status", f"[bold]{session.status}[/bold]")
-            table.add_row("Created", session.created_at.strftime("%Y-%m-%d %H:%M:%S UTC"))
-            if session.ended_at:
-                table.add_row("Ended", session.ended_at.strftime("%Y-%m-%d %H:%M:%S UTC"))
-            if session.expires_at:
-                table.add_row("Expires", session.expires_at.strftime("%Y-%m-%d %H:%M:%S UTC"))
-            
-            console.print(table)
-            console.print()
-            
-            # Display usage summary
-            usage_table = Table(title="Usage Summary", show_header=True, header_style="bold cyan")
-            usage_table.add_column("Metric", style="cyan")
-            usage_table.add_column("Value", style="green")
-            
-            usage_table.add_row("Tokens", f"{session.usage.tokens:,}")
-            usage_table.add_row("Cost (USD)", f"${session.usage.cost_usd:.4f}")
-            usage_table.add_row("GPU Hours", f"{session.usage.gpu_hours:.4f}")
-            usage_table.add_row("API Calls", f"{session.usage.api_calls:,}")
-            
-            console.print(usage_table)
-            console.print()
-            
-            # Display limits
-            if session.limits:
-                limits_table = Table(title="Session Limits", show_header=True, header_style="bold cyan")
-                limits_table.add_column("Type", style="cyan")
-                limits_table.add_column("Limit", style="green")
-                limits_table.add_column("Used", style="yellow")
-                limits_table.add_column("Remaining", style="green")
-                limits_table.add_column("Status", style="bold")
-                
-                for limit in session.limits:
-                    remaining = limit.remaining
-                    status = "[green]✓ OK[/green]" if remaining > 0 else "[red]✗ EXCEEDED[/red]"
-                    if limit.metric_type == "cost_usd":
-                        limits_table.add_row(
-                            "Cost (USD)",
-                            f"${limit.limit_value:.2f}",
-                            f"${limit.current_usage:.4f}",
-                            f"${remaining:.4f}",
-                            status
-                        )
-                    elif limit.metric_type == "tokens":
-                        limits_table.add_row(
-                            "Tokens",
-                            f"{limit.limit_value:,.0f}",
-                            f"{limit.current_usage:,.0f}",
-                            f"{remaining:,.0f}",
-                            status
-                        )
-                    elif limit.metric_type == "gpu_hours":
-                        limits_table.add_row(
-                            "GPU Hours",
-                            f"{limit.limit_value:.2f}",
-                            f"{limit.current_usage:.4f}",
-                            f"{remaining:.4f}",
-                            status
-                        )
-                    else:
-                        limits_table.add_row(
-                            limit.metric_type,
-                            str(limit.limit_value),
-                            str(limit.current_usage),
-                            str(remaining),
-                            status
-                        )
-                
-                console.print(limits_table)
-                
-                # Warn if any limit exceeded
-                exceeded = [limit for limit in session.limits if limit.current_usage >= limit.limit_value]
-                if exceeded:
-                    console.print()
-                    console.print("[red][bold]⚠ WARNING: Session limits exceeded![/bold][/red]")
-                    console.print("The session will reject new requests until limits are increased.")
-                    for limit in exceeded:
-                        console.print(f"  - {limit.metric_type}: {limit.current_usage} >= {limit.limit_value}")
-            else:
-                console.print("[yellow]No limits configured for this session.[/yellow]")
-                
-        except SessionNotFoundError:
-            console.print(f"[red]Session not found: {session_id_to_use}[/red]")
-        except Exception as e:
-            console.print(f"[red]Error fetching session: {e}[/red]")
-    
+
+        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

@@ -1,4 +1,4 @@
-"""`synth status summary` command."""
+"""Status summary command."""
 
 from __future__ import annotations
 
@@ -6,42 +6,34 @@ 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:
+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(limit=limit)
+                jobs = await client.list_jobs()  # type: ignore[attr-defined]
             except StatusAPIError:
                 jobs = []
             try:
-                models = await client.list_models(limit=limit)
+                await client.list_models()  # type: ignore[attr-defined]
             except StatusAPIError:
-                models = []
+                pass
             try:
-                files = await client.list_files(limit=limit)
+                await client.list_files()  # type: ignore[attr-defined]
             except StatusAPIError:
-                files = []
-        return jobs, models, files
+                pass
+
+        click.echo("Training Jobs")
+        for job in jobs:
+            click.echo(str(job))
+
+    asyncio.run(_run())
+
 
-    jobs, models, files = asyncio.run(_run())
-    console.print(jobs_table(jobs[:limit]))
-    console.print(models_table(models[:limit]))
-    console.print(files_table(files[:limit]))
+__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))