synth-ai 0.2.8.dev2__py3-none-any.whl → 0.4.3__py3-none-any.whl

synth_ai/cli/commands/artifacts/config.py

@@ -0,0 +1,57 @@
+"""Configuration utilities for artifacts CLI."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+import click
+
+from synth_ai.core.env import get_backend_from_env
+
+DEFAULT_TIMEOUT = 30.0
+
+
+@dataclass
+class ArtifactsConfig:
+    """Configuration for artifacts CLI commands."""
+    
+    base_url: str
+    api_key: str
+    timeout: float = DEFAULT_TIMEOUT
+    
+    @property
+    def api_base_url(self) -> str:
+        """Get the API base URL (ensures /api suffix)."""
+        base = self.base_url.rstrip("/")
+        if not base.endswith("/api"):
+            base = f"{base}/api"
+        return base
+
+
+def resolve_backend_config(
+    *,
+    base_url: str | None = None,
+    api_key: str | None = None,
+    timeout: float | None = None,
+) -> ArtifactsConfig:
+    """Resolve backend configuration from environment or explicit values."""
+    if base_url is None:
+        base, key = get_backend_from_env()
+        base_url = base
+        if api_key is None:
+            api_key = key
+    
+    if api_key is None:
+        api_key = os.getenv("SYNTH_API_KEY", "")
+        if not api_key:
+            raise click.ClickException(
+                "API key required. Set SYNTH_API_KEY env var or use --api-key option."
+            )
+    
+    return ArtifactsConfig(
+        base_url=base_url or "",
+        api_key=api_key,
+        timeout=timeout or DEFAULT_TIMEOUT,
+    )
+

synth_ai/cli/commands/artifacts/core.py

@@ -0,0 +1,24 @@
+"""Core artifacts command group."""
+
+from __future__ import annotations
+
+import click
+
+from .download import download_command
+from .export import export_command
+from .list import list_command
+from .show import show_command
+
+
+@click.group("artifacts", help="Manage artifacts (models and optimized prompts).")
+def artifacts_group() -> None:
+    """Artifacts command group for managing models and prompts."""
+    pass
+
+
+# Register subcommands
+artifacts_group.add_command(list_command, name="list")
+artifacts_group.add_command(export_command, name="export")
+artifacts_group.add_command(download_command, name="download")
+artifacts_group.add_command(show_command, name="show")
+

synth_ai/cli/commands/artifacts/download.py

@@ -0,0 +1,188 @@
+"""Download optimized prompts command."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+from typing import Any
+
+import click
+
+try:
+    import yaml
+except ImportError:
+    yaml = None  # type: ignore
+from rich.console import Console
+
+from .client import ArtifactsClient
+from .config import DEFAULT_TIMEOUT, resolve_backend_config
+
+console = Console()
+
+
+def _extract_prompt_text(payload: dict[str, Any]) -> str:
+    """Extract prompt text from snapshot payload."""
+    if isinstance(payload, dict):
+        # Try to find messages or text fields
+        if "messages" in payload:
+            messages = payload["messages"]
+            if isinstance(messages, list):
+                texts = []
+                for msg in messages:
+                    if isinstance(msg, dict) and "content" in msg:
+                        texts.append(msg["content"])
+                return "\n\n".join(texts)
+        if "text" in payload:
+            return str(payload["text"])
+        if "prompt" in payload:
+            return str(payload["prompt"])
+    return json.dumps(payload, indent=2)
+
+
+@click.command("download", help="Download optimized prompts.")
+@click.argument("job_id", required=True)
+@click.option(
+    "--output",
+    "-o",
+    type=click.Path(),
+    default=None,
+    help="Output file or directory path.",
+)
+@click.option(
+    "--format",
+    "output_format",
+    type=click.Choice(["json", "yaml", "text"]),
+    default="json",
+    help="Output format.",
+)
+@click.option(
+    "--snapshot-id",
+    help="Download specific snapshot (default: best snapshot).",
+)
+@click.option(
+    "--all-snapshots",
+    is_flag=True,
+    help="Download all snapshots from the job.",
+)
+@click.option(
+    "--base-url",
+    envvar="BACKEND_BASE_URL",
+    default=None,
+    help="Backend base URL.",
+)
+@click.option(
+    "--api-key",
+    envvar="SYNTH_API_KEY",
+    default=None,
+    help="API key.",
+)
+@click.option(
+    "--timeout",
+    default=DEFAULT_TIMEOUT,
+    type=float,
+    show_default=True,
+    help="Request timeout in seconds.",
+)
+def download_command(
+    job_id: str,
+    output: str | None,
+    output_format: str,
+    snapshot_id: str | None,
+    all_snapshots: bool,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+) -> None:
+    """Download optimized prompts from a prompt optimization job."""
+    config = resolve_backend_config(base_url=base_url, api_key=api_key, timeout=timeout)
+    
+    async def _run() -> None:
+        client = ArtifactsClient(config.api_base_url, config.api_key, timeout=config.timeout)
+        try:
+            # Get job details
+            job_data = await client.get_prompt(job_id)
+            best_snapshot_id = job_data.get("best_snapshot_id")
+            
+            if all_snapshots:
+                # Download all snapshots
+                artifacts = await client.list_prompt_snapshots(job_id)
+                if not artifacts:
+                    console.print(f"[yellow]No snapshots found for job {job_id}[/yellow]")
+                    return
+                
+                # Determine output directory
+                if output:
+                    output_path = Path(output)
+                    output_dir = output_path.parent if output_path.suffix else output_path
+                else:
+                    output_dir = Path(f"./prompts/{job_id}")
+                
+                output_dir.mkdir(parents=True, exist_ok=True)
+                console.print(f"[yellow]Downloading {len(artifacts)} snapshots to {output_dir}...[/yellow]")
+                
+                for artifact in artifacts:
+                    snap_id = artifact.get("snapshot_id")
+                    if not snap_id:
+                        continue
+                    
+                    snapshot_data = await client.get_prompt_snapshot(job_id, snap_id)
+                    payload = snapshot_data.get("payload", {})
+                    
+                    # Determine filename
+                    if output_format == "text":
+                        content = _extract_prompt_text(payload)
+                        ext = "txt"
+                    elif output_format == "yaml":
+                        if yaml is None:
+                            raise click.ClickException("yaml format requires PyYAML. Install with: pip install pyyaml")
+                        content = yaml.dump(payload, default_flow_style=False)
+                        ext = "yaml"
+                    else:
+                        content = json.dumps(payload, indent=2, default=str)
+                        ext = "json"
+                    
+                    file_path = output_dir / f"snapshot_{snap_id}.{ext}"
+                    file_path.write_text(content)
+                    console.print(f"  [green]✓[/green] {file_path}")
+            else:
+                # Download single snapshot (best or specified)
+                target_snapshot_id = snapshot_id or best_snapshot_id
+                if not target_snapshot_id:
+                    raise click.ClickException(f"No snapshot found for job {job_id}")
+                
+                snapshot_data = await client.get_prompt_snapshot(job_id, target_snapshot_id)
+                payload = snapshot_data.get("payload", {})
+                
+                # Determine output path
+                if output:
+                    output_path = Path(output)
+                else:
+                    if output_format == "text":
+                        ext = "txt"
+                    elif output_format == "yaml":
+                        ext = "yaml"
+                    else:
+                        ext = "json"
+                    output_path = Path(f"./prompts/{job_id}/best.{ext}")
+                
+                output_path.parent.mkdir(parents=True, exist_ok=True)
+                
+                # Write content
+                if output_format == "text":
+                    content = _extract_prompt_text(payload)
+                elif output_format == "yaml":
+                    if yaml is None:
+                        raise click.ClickException("yaml format requires PyYAML. Install with: pip install pyyaml")
+                    content = yaml.dump(payload, default_flow_style=False)
+                else:
+                    content = json.dumps(payload, indent=2, default=str)
+                
+                output_path.write_text(content)
+                console.print(f"[green]✓ Downloaded to {output_path}[/green]")
+        except Exception as e:
+            console.print(f"[red]Error: {e}[/red]")
+            raise click.ClickException(str(e)) from e
+    
+    asyncio.run(_run())
+

synth_ai/cli/commands/artifacts/export.py

@@ -0,0 +1,186 @@
+"""Export model to HuggingFace command."""
+
+from __future__ import annotations
+
+import asyncio
+
+import click
+from rich.console import Console
+
+from .client import ArtifactsClient
+from .config import DEFAULT_TIMEOUT, resolve_backend_config
+from .parsing import (
+    parse_model_id,
+    resolve_wasabi_key_for_model,
+    validate_model_id,
+)
+
+console = Console()
+
+
+async def _resolve_model_storage_path(
+    client: ArtifactsClient,
+    model_id: str,
+    prefer_merged: bool,
+) -> tuple[str, str]:
+    """Resolve model ID to Wasabi storage path and artifact kind."""
+    # Get model details
+    model_data = await client.get_model(model_id)
+    model_type = model_data.get("type")
+    base_model = model_data.get("base_model", "")
+    job_id = model_data.get("job_id", "")
+    
+    if model_type == "fine_tuned":
+        # Fine-tuned model: check Wasabi availability first
+        try:
+            wasabi_data = await client.get_models_on_wasabi()
+            models = wasabi_data.get("models", [])
+            # Find matching model
+            for model_info in models:
+                if model_info.get("id") == model_id:
+                    wasabi_info = model_info.get("wasabi", {})
+                    merged_info = wasabi_info.get("merged", {})
+                    adapter_info = wasabi_info.get("adapter", {})
+                    
+                    if prefer_merged and merged_info.get("present"):
+                        wasabi_key = merged_info.get("key", "")
+                        if wasabi_key:
+                            return wasabi_key, "training_file"
+                    elif adapter_info.get("present"):
+                        wasabi_key = adapter_info.get("key", "")
+                        if wasabi_key:
+                            return wasabi_key, "lora"
+        except Exception as e:
+            console.print(f"[yellow]Warning: Could not check Wasabi availability: {e}[/yellow]")
+        
+        # Fallback: construct path using parsing utilities
+        try:
+            parsed = parse_model_id(model_id)
+            wasabi_key = resolve_wasabi_key_for_model(parsed, prefer_merged=prefer_merged)
+            artifact_kind = "training_file" if prefer_merged else "lora"
+            return wasabi_key, artifact_kind
+        except Exception:
+            # Last resort fallback
+            safe_base = base_model.replace("/", "-").replace(":", "-")
+            if prefer_merged:
+                wasabi_key = f"models/{safe_base}-{job_id}-fp16.tar.gz"
+                artifact_kind = "training_file"
+            else:
+                wasabi_key = f"models/{base_model}/ft-{job_id}/adapter.tar.gz"
+                artifact_kind = "lora"
+            return wasabi_key, artifact_kind
+    elif model_type == "rl":
+        # RL model: use weights_path
+        weights_path = model_data.get("weights_path", "")
+        if not weights_path:
+            raise click.ClickException(f"RL model {model_id} has no weights_path")
+        # Determine artifact kind from path
+        artifact_kind = "lora" if "adapter" in weights_path.lower() else "training_file"
+        return weights_path, artifact_kind
+    else:
+        raise click.ClickException(f"Unknown model type: {model_type}")
+
+
+@click.command("export", help="Export a model to HuggingFace Hub.")
+@click.argument("model_id", required=True)
+@click.option(
+    "--repo-id",
+    required=True,
+    help="HuggingFace repository ID (e.g., username/model-name).",
+)
+@click.option(
+    "--private/--public",
+    default=True,
+    help="Repository visibility (default: private).",
+)
+@click.option(
+    "--prefer-merged/--prefer-adapter",
+    default=True,
+    help="Prefer merged model over adapter (default: merged).",
+)
+@click.option(
+    "--tags",
+    help="Comma-separated tags for the repository.",
+)
+@click.option(
+    "--base-url",
+    envvar="BACKEND_BASE_URL",
+    default=None,
+    help="Backend base URL.",
+)
+@click.option(
+    "--api-key",
+    envvar="SYNTH_API_KEY",
+    default=None,
+    help="API key.",
+)
+@click.option(
+    "--timeout",
+    default=DEFAULT_TIMEOUT,
+    type=float,
+    show_default=True,
+    help="Request timeout in seconds.",
+)
+def export_command(
+    model_id: str,
+    repo_id: str,
+    private: bool,
+    prefer_merged: bool,
+    tags: str | None,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+) -> None:
+    """Export a fine-tuned or RL model to HuggingFace Hub."""
+    config = resolve_backend_config(base_url=base_url, api_key=api_key, timeout=timeout)
+    
+    async def _run() -> None:
+        client = ArtifactsClient(config.api_base_url, config.api_key, timeout=config.timeout)
+        try:
+            # Validate and parse model ID
+            if not validate_model_id(model_id):
+                raise click.ClickException(
+                    f"Invalid model ID format: {model_id}. "
+                    f"Expected format: peft:BASE_MODEL:JOB_ID, ft:BASE_MODEL:JOB_ID, or rl:BASE_MODEL:JOB_ID"
+                )
+            
+            # Validate model ID format (parsed is used for validation)
+            parse_model_id(model_id)
+            
+            # Resolve storage path
+            console.print(f"[yellow]Resolving storage path for {model_id}...[/yellow]")
+            wasabi_key, artifact_kind = await _resolve_model_storage_path(
+                client, model_id, prefer_merged
+            )
+            
+            # Get model details for base_model
+            model_data = await client.get_model(model_id)
+            base_model = model_data.get("base_model")
+            
+            # Parse tags
+            tag_list = [t.strip() for t in tags.split(",")] if tags else None
+            
+            # Export to HuggingFace
+            console.print(f"[yellow]Exporting to HuggingFace: {repo_id}...[/yellow]")
+            result = await client.export_to_huggingface(
+                wasabi_key=wasabi_key,
+                repo_id=repo_id,
+                repo_type="model",
+                artifact_kind=artifact_kind,
+                base_model=base_model,
+                visibility="private" if private else "public",
+                tags=tag_list,
+            )
+            
+            # Show result
+            repo_url = result.get("repo_url") or f"https://huggingface.co/{repo_id}"
+            console.print(f"[green]✓ Successfully exported to {repo_url}[/green]")
+            if isinstance(result, dict):
+                console.print(f"Repository: {repo_id}")
+                console.print(f"Visibility: {'private' if private else 'public'}")
+        except Exception as e:
+            console.print(f"[red]Error: {e}[/red]")
+            raise click.ClickException(str(e)) from e
+    
+    asyncio.run(_run())
+

synth_ai/cli/commands/artifacts/list.py

@@ -0,0 +1,156 @@
+"""List artifacts command."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from .client import ArtifactsClient
+from .config import DEFAULT_TIMEOUT, resolve_backend_config
+
+console = Console()
+
+
+def _format_table(data: dict[str, Any]) -> None:
+    """Format artifacts as a table."""
+    # Fine-tuned models
+    ft_models = data.get("fine_tuned_models", [])
+    if ft_models:
+        console.print(f"\n[bold]Fine-tuned Models ({len(ft_models)})[/bold]")
+        table = Table(show_header=True, header_style="bold")
+        table.add_column("Model ID")
+        table.add_column("Base Model")
+        table.add_column("Created")
+        table.add_column("Job ID")
+        for model in ft_models:
+            model_id = model.get("id", "")
+            base = model.get("base_model", "")
+            created = model.get("created_at", "")
+            job_id = model.get("job_id", "")
+            table.add_row(model_id[:40], base[:30], str(created)[:19], job_id[:20])
+        console.print(table)
+    
+    # RL models
+    rl_models = data.get("rl_models", [])
+    if rl_models:
+        console.print(f"\n[bold]RL Models ({len(rl_models)})[/bold]")
+        table = Table(show_header=True, header_style="bold")
+        table.add_column("Model ID")
+        table.add_column("Base Model")
+        table.add_column("Created")
+        table.add_column("Job ID")
+        for model in rl_models:
+            model_id = model.get("id", "")
+            base = model.get("base_model", "")
+            created = model.get("created_at", "")
+            job_id = model.get("job_id", "")
+            table.add_row(model_id[:40], base[:30], str(created)[:19], job_id[:20])
+        console.print(table)
+    
+    # Prompts
+    prompts = data.get("prompts", [])
+    if prompts:
+        console.print(f"\n[bold]Optimized Prompts ({len(prompts)})[/bold]")
+        table = Table(show_header=True, header_style="bold")
+        table.add_column("Job ID")
+        table.add_column("Algorithm")
+        table.add_column("Best Score")
+        table.add_column("Created")
+        for prompt in prompts:
+            job_id = prompt.get("job_id", "")
+            algorithm = prompt.get("algorithm", "")
+            score = prompt.get("best_score")
+            created = prompt.get("created_at", "")
+            score_str = f"{score:.3f}" if score is not None else "N/A"
+            table.add_row(job_id[:30], algorithm[:10], score_str, str(created)[:19])
+        console.print(table)
+    
+    # Summary
+    summary = data.get("summary", {})
+    total = summary.get("total_count", 0)
+    if total == 0:
+        console.print("\n[yellow]No artifacts found.[/yellow]")
+
+
+@click.command("list", help="List all artifacts (models and prompts).")
+@click.option(
+    "--type",
+    "artifact_type",
+    type=click.Choice(["models", "prompts", "all"]),
+    default="all",
+    help="Filter by artifact type.",
+)
+@click.option(
+    "--format",
+    "output_format",
+    type=click.Choice(["table", "json"]),
+    default="table",
+    help="Output format.",
+)
+@click.option(
+    "--limit",
+    default=50,
+    type=int,
+    show_default=True,
+    help="Maximum items per type.",
+)
+@click.option(
+    "--status",
+    type=click.Choice(["succeeded", "failed", "running"]),
+    default="succeeded",
+    help="Filter by status.",
+)
+@click.option(
+    "--base-url",
+    envvar="BACKEND_BASE_URL",
+    default=None,
+    help="Backend base URL.",
+)
+@click.option(
+    "--api-key",
+    envvar="SYNTH_API_KEY",
+    default=None,
+    help="API key.",
+)
+@click.option(
+    "--timeout",
+    default=DEFAULT_TIMEOUT,
+    type=float,
+    show_default=True,
+    help="Request timeout in seconds.",
+)
+def list_command(
+    artifact_type: str,
+    output_format: str,
+    limit: int,
+    status: str,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+) -> None:
+    """List all artifacts (fine-tuned models, RL models, and optimized prompts)."""
+    config = resolve_backend_config(base_url=base_url, api_key=api_key, timeout=timeout)
+    
+    async def _run() -> None:
+        client = ArtifactsClient(config.api_base_url, config.api_key, timeout=config.timeout)
+        try:
+            data = await client.list_artifacts(
+                artifact_type=artifact_type if artifact_type != "all" else None,
+                status=status,
+                limit=limit,
+            )
+            if output_format == "json":
+                console.print(json.dumps(data, indent=2, default=str))
+            else:
+                _format_table(data)
+        except Exception as e:
+            console.print(f"[red]Error: {e}[/red]")
+            raise click.ClickException(str(e)) from e
+    
+    asyncio.run(_run())
+