synth-ai 0.2.13.dev2__py3-none-any.whl → 0.2.16__py3-none-any.whl

synth_ai/cli/man.py

@@ -1,106 +0,0 @@
-#!/usr/bin/env python3
-"""
-CLI: human-friendly manual for Synth AI commands and options.
-"""
-
-from __future__ import annotations
-
-from rich import box
-from rich.console import Console
-from rich.panel import Panel
-from rich.table import Table
-
-
-def _commands_table() -> Table:
-    t = Table(title="Commands", box=box.SIMPLE, header_style="bold")
-    t.add_column("Command")
-    t.add_column("Summary")
-    t.add_row(
-        "balance",
-        "Show remaining credit balance (USD) and a compact spend summary for last 24h and 7d.\n"
-        "Options: --base-url, --api-key, --usage",
-    )
-    t.add_row(
-        "traces",
-        "List local trace DBs, trace counts, experiments, and per-system counts.\nOptions: --root",
-    )
-    t.add_row(
-        "experiments",
-        "Snapshot table of experiments from the local traces DB.\nOptions: --url, --limit",
-    )
-    t.add_row(
-        "experiment <id>",
-        "Details and sessions for an experiment (accepts partial ID).\nOptions: --url",
-    )
-    t.add_row(
-        "usage",
-        "Model usage statistics (tokens, cost).\nOptions: --url, --model",
-    )
-    t.add_row(
-        "status",
-        "DB stats, systems, and environment service health.\nOptions: --url, --service-url",
-    )
-    t.add_row(
-        "calc '<expr>'",
-        "Evaluate a simple arithmetic expression (e.g., 2*(3+4)).",
-    )
-    t.add_row(
-        "env list | env register | env unregister",
-        "Manage environment registry via the service.\nOptions vary; see examples.",
-    )
-    return t
-
-
-def _env_table() -> Table:
-    t = Table(title="Environment Variables", box=box.SIMPLE, header_style="bold")
-    t.add_column("Variable")
-    t.add_column("Used By")
-    t.add_column("Purpose")
-    t.add_row(
-        "SYNTH_BACKEND_BASE_URL",
-        "balance",
-        "Backend base URL (preferred) e.g. http://localhost:8000/api/v1",
-    )
-    t.add_row("BACKEND_BASE_URL", "balance", "Fallback backend base URL")
-    t.add_row("LOCAL_BACKEND_URL", "balance", "Another fallback backend base URL")
-    t.add_row("SYNTH_BASE_URL", "balance", "Generic base URL (may point to Modal, guarded)")
-    t.add_row("SYNTH_BACKEND_API_KEY", "balance", "Backend API key (preferred)")
-    t.add_row("SYNTH_API_KEY", "balance, env*", "API key used if backend-specific key not set")
-    t.add_row("DEFAULT_DEV_API_KEY", "balance", "Dev fallback key for local testing")
-    t.add_row(
-        "SYNTH_TRACES_ROOT",
-        "traces",
-        "Root directory of local trace DBs (default ./synth_ai.db/dbs)",
-    )
-    return t
-
-
-def _examples_table() -> Table:
-    t = Table(title="Examples", box=box.SIMPLE, header_style="bold")
-    t.add_column("Command")
-    t.add_column("Example")
-    t.add_row("Balance (local backend)", "uvx . balance")
-    t.add_row(
-        "Balance with URL+key",
-        "uvx . balance --base-url http://localhost:8000 --api-key $SYNTH_API_KEY",
-    )
-    t.add_row("Traces (default root)", "uvx . traces")
-    t.add_row("Traces (custom root)", "uvx . traces --root /path/to/dbs")
-    t.add_row("Experiments", "uvx . experiments --limit 20")
-    t.add_row("Experiment detail", "uvx . experiment abcd1234")
-    t.add_row("Usage by model", "uvx . usage --model gpt-4o-mini")
-    t.add_row("Status", "uvx . status")
-    t.add_row("Calc", "uvx . calc '2*(3+4)'")
-    t.add_row("Env list", "uvx . env list --service-url http://localhost:8901")
-    return t
-
-
-def register(cli):
-    @cli.command(name="man")
-    def man():
-        """Show Synth AI CLI manual with commands, options, env vars, and examples."""
-        console = Console()
-        console.print(Panel("Synth AI CLI Manual", border_style="cyan"))
-        console.print(_commands_table())
-        console.print(_env_table())
-        console.print(_examples_table())

synth_ai/core/experiment.py

@@ -1,13 +0,0 @@
-class ExperimentalSystem:
-    system_id: str
-    system_version_id: str
-    pass
-
-
-class Experiment:
-    id: str
-    name: str
-    description: str
-    created_at: str
-    updated_at: str
-    related_systems: list[ExperimentalSystem]

synth_ai/core/system.py

@@ -1,15 +0,0 @@
-class System:
-    id: str
-    name: str
-    description: str
-    pass
-
-
-class SystemVersion:
-    id: str
-    system_id: str
-    branch: str
-    commit: str
-    created_at: str
-    description: str
-    pass

synth_ai/demo_registry.py

@@ -1,295 +0,0 @@
-"""Registry of demo task app templates for `uvx synth-ai demo init`."""
-
-from __future__ import annotations
-
-import textwrap
-from collections.abc import Callable, Iterable
-from dataclasses import dataclass
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parents[1]
-
-
-@dataclass(frozen=True)
-class CopySpec:
-    """File copy specification from repo-relative source to template-relative destination."""
-
-    source: str
-    destination: str
-    make_executable: bool = False
-
-    def absolute_source(self) -> Path:
-        return (REPO_ROOT / self.source).resolve()
-
-
-@dataclass(frozen=True)
-class DemoTemplate:
-    """Describes a demo task app template that can be materialised into the CWD."""
-
-    template_id: str
-    name: str
-    description: str
-    copy_specs: tuple[CopySpec, ...]
-    default_subdir: str | None = None
-    env_lines: tuple[str, ...] = ()
-    config_source: str | None = None
-    config_destination: str = "demo_config.toml"
-    requires_modal: bool = False
-    post_copy: Callable[[Path], None] | None = None
-
-    def iter_copy_specs(self) -> Iterable[CopySpec]:
-        return self.copy_specs
-
-    def config_source_path(self) -> Path | None:
-        if not self.config_source:
-            return None
-        return (REPO_ROOT / self.config_source).resolve()
-
-
-DEMO_TEMPLATES: tuple[DemoTemplate, ...] = (
-    DemoTemplate(
-        template_id="math-modal",
-        name="Math Single-Step (Modal deployment)",
-        description="Packaged modal task app matching examples/rl math environment.",
-        copy_specs=(
-            CopySpec(
-                "synth_ai/demos/demo_task_apps/math/modal_task_app.py",
-                "task_app.py",
-            ),
-            CopySpec(
-                "synth_ai/demos/demo_task_apps/math/deploy_task_app.sh",
-                "deploy_task_app.sh",
-                make_executable=True,
-            ),
-            CopySpec(
-                "synth_ai/demos/demo_task_apps/math/config.toml",
-                "configs/rl_from_base_qwen17.toml",
-            ),
-        ),
-        default_subdir="math_demo",
-        env_lines=(
-            "# Required for task app auth to environment service",
-            "ENVIRONMENT_API_KEY=",
-            "",
-            "# Optional: for CLI job submission and proxying OpenAI models",
-            "SYNTH_API_KEY=",
-            "OPENAI_API_KEY=",
-            "",
-            "# Optional: set to 'prod' to use production names",
-            "ENVIRONMENT=",
-        ),
-        config_source="synth_ai/demos/demo_task_apps/math/config.toml",
-        requires_modal=True,
-        post_copy=lambda root: _postprocess_math_modal(root),
-    ),
-    DemoTemplate(
-        template_id="crafter-local",
-        name="Crafter GRPO (local FastAPI)",
-        description="Lightweight wrapper around examples/warming_up_to_rl/task_app/grpo_crafter for local experimentation.",
-        copy_specs=(
-            CopySpec(
-                "synth_ai/demos/demo_task_apps/crafter/grpo_crafter_task_app.py",
-                "task_app.py",
-            ),
-            CopySpec(
-                "synth_ai/demos/demo_task_apps/crafter/README.md",
-                "README.md",
-            ),
-            CopySpec(
-                "synth_ai/demos/demo_task_apps/crafter/configs/rl_from_base_qwen4b.toml",
-                "configs/rl_from_base_qwen4b.toml",
-            ),
-            CopySpec(
-                "synth_ai/demos/demo_task_apps/crafter/configs/crafter_fft_4b.toml",
-                "configs/crafter_fft_4b.toml",
-            ),
-            CopySpec(
-                "examples/warming_up_to_rl/task_app/grpo_crafter.py",
-                "grpo_crafter.py",
-            ),
-            CopySpec(
-                "examples/warming_up_to_rl/task_app/synth_envs_hosted",
-                "synth_envs_hosted",
-            ),
-            CopySpec(
-                "examples/warming_up_to_rl/run_local_rollout.py",
-                "run_local_rollout.py",
-            ),
-            CopySpec(
-                "examples/warming_up_to_rl/run_local_rollout_traced.py",
-                "run_local_rollout_traced.py",
-            ),
-            CopySpec(
-                "examples/warming_up_to_rl/export_trace_sft.py",
-                "export_trace_sft.py",
-            ),
-            CopySpec(
-                "examples/warming_up_to_rl/run_fft_and_save.py",
-                "run_fft_and_save.py",
-            ),
-            CopySpec(
-                "examples/warming_up_to_rl/run_local_rollout_modal.py",
-                "run_local_rollout_modal.py",
-            ),
-        ),
-        default_subdir="crafter_demo",
-        env_lines=(
-            "ENVIRONMENT_API_KEY=",
-            "SYNTH_API_KEY=",
-            "",
-            "# Optional: URL for existing Crafter task app",
-            "TASK_APP_BASE_URL=",
-        ),
-        config_source="synth_ai/demos/demo_task_apps/crafter/configs/rl_from_base_qwen4b.toml",
-        config_destination="demo_config.toml",
-        requires_modal=False,
-        post_copy=lambda root: _postprocess_crafter_local(root),
-    ),
-)
-
-
-def get_demo_template(template_id: str) -> DemoTemplate | None:
-    for template in DEMO_TEMPLATES:
-        if template.template_id == template_id:
-            return template
-    return None
-
-
-def list_demo_templates() -> tuple[DemoTemplate, ...]:
-    return DEMO_TEMPLATES
-
-
-def _postprocess_math_modal(root: Path) -> None:
-    task_path = (root / "task_app.py").resolve()
-    if not task_path.exists():
-        return
-    text = task_path.read_text(encoding="utf-8")
-    text = text.replace('App("hendrycks-math-task-app")', 'App("hendrycks-math-task-app-demo")')
-    text = text.replace(
-        'DEFAULT_TASK_APP_SECRET_NAME = "hendrycks-math-task-app-secret"',
-        'DEFAULT_TASK_APP_SECRET_NAME = "hendrycks-math-task-app-demo-secret"',
-    )
-    task_path.write_text(text, encoding="utf-8")
-
-
-CRAFT_DEMO_TEMPLATE = (
-    textwrap.dedent(
-        '''
-"""Demo-friendly wrapper for the GRPO Crafter task app."""
-
-from __future__ import annotations
-
-import argparse
-from pathlib import Path
-
-from synth_ai.task.apps import ModalDeploymentConfig, registry
-import sys
-from pathlib import Path
-_EXAMPLES_TASK_APP = Path(__file__).resolve().parents[4] / "examples" / "warming_up_to_rl" / "task_app"
-if str(_EXAMPLES_TASK_APP) not in sys.path:
-    sys.path.insert(0, str(_EXAMPLES_TASK_APP))
-from grpo_crafter import build_config
-from synth_ai.task.server import TaskAppConfig, create_task_app, run_task_app
-
-
-APP_ID = "grpo-crafter-demo"
-BASE_APP_ID = "grpo-crafter"
-
-
-try:
-    _BASE_ENTRY = registry.get(BASE_APP_ID)
-except Exception:  # pragma: no cover - registry may be unavailable
-    MODAL_DEPLOYMENT: ModalDeploymentConfig | None = None
-else:
-    base_modal = _BASE_ENTRY.modal
-    if base_modal is None:
-        MODAL_DEPLOYMENT = None
-    else:
-        modal_app_name = base_modal.app_name
-        if not modal_app_name.endswith("-demo"):
-            modal_app_name = f"{modal_app_name}-demo"
-        MODAL_DEPLOYMENT = ModalDeploymentConfig(
-            app_name=modal_app_name,
-            python_version=base_modal.python_version,
-            pip_packages=tuple(base_modal.pip_packages),
-            extra_local_dirs=tuple(base_modal.extra_local_dirs),
-            secret_names=tuple(base_modal.secret_names),
-            volume_mounts=tuple(base_modal.volume_mounts),
-            timeout=base_modal.timeout,
-            memory=base_modal.memory,
-            cpu=base_modal.cpu,
-            min_containers=base_modal.min_containers,
-            max_containers=base_modal.max_containers,
-        )
-
-ENV_FILES: tuple[str, ...] = ()
-
-
-def build_task_app_config() -> TaskAppConfig:
-    """Return a fresh TaskAppConfig for the demo wrapper."""
-
-    # Build config dynamically so environment variables are read at runtime
-    _base_config = build_config()
-    return TaskAppConfig(
-        app_id="grpo-crafter-demo",
-        name=_base_config.name,
-        description=_base_config.description,
-        base_task_info=_base_config.base_task_info,
-        describe_taskset=_base_config.describe_taskset,
-        provide_task_instances=_base_config.provide_task_instances,
-        rollout=_base_config.rollout,
-        dataset_registry=_base_config.dataset_registry,
-        rubrics=_base_config.rubrics,
-        proxy=_base_config.proxy,
-        routers=_base_config.routers,
-        middleware=_base_config.middleware,
-        app_state=_base_config.app_state,
-        require_api_key=_base_config.require_api_key,
-        expose_debug_env=_base_config.expose_debug_env,
-        cors_origins=_base_config.cors_origins,
-        startup_hooks=_base_config.startup_hooks,
-        shutdown_hooks=_base_config.shutdown_hooks,
-    )
-
-
-def fastapi_app():
-    """Return the FastAPI application for Modal or other ASGI hosts."""
-
-    return create_task_app(build_task_app_config())
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Run the Crafter task app locally")
-    parser.add_argument("--host", default="0.0.0.0")
-    parser.add_argument("--port", type=int, default=8001)
-    parser.add_argument("--reload", action="store_true", help="Enable uvicorn autoreload")
-    parser.add_argument(
-        "--env-file",
-        action="append",
-        default=[],
-        help="Additional .env files to load before startup",
-    )
-    args = parser.parse_args()
-
-    default_env = Path(__file__).resolve().parents[4] / "backend" / ".env.dev"
-    env_files = [str(default_env)] if default_env.exists() else []
-    env_files.extend(args.env_file or [])
-
-    run_task_app(
-        build_task_app_config,
-        host=args.host,
-        port=args.port,
-        reload=args.reload,
-        env_files=env_files,
-    )
-    '''
-    ).strip()
-    + "\n"
-)
-
-
-def _postprocess_crafter_local(root: Path) -> None:
-    task_path = (root / "task_app.py").resolve()
-    if not task_path.exists():
-        return
-    task_path.write_text(CRAFT_DEMO_TEMPLATE, encoding="utf-8")

synth_ai/handshake.py

@@ -1,109 +0,0 @@
-from __future__ import annotations
-
-import contextlib
-import os
-import time
-import webbrowser
-from typing import Any
-from urllib.parse import urljoin, urlsplit, urlunsplit
-
-import requests
-
-
-class HandshakeError(Exception):
-    pass
-
-
-_TRUTHY = {"1", "true", "yes", "on"}
-
-
-def _origin() -> str:
-    """Resolve the dashboard origin for the browser handshake.
-
-    Priority order:
-      1. Explicit ``SYNTH_CANONICAL_ORIGIN`` override.
-      2. Development flag ``SYNTH_CANONICAL_DEV`` (case-insensitive truthy) → localhost.
-      3. Production dashboard at ``https://www.usesynth.ai/dashboard``.
-    """
-
-    override = (os.getenv("SYNTH_CANONICAL_ORIGIN") or "").strip()
-    if override:
-        return override.rstrip("/")
-
-    dev_flag = (os.getenv("SYNTH_CANONICAL_DEV") or "").strip().lower()
-    if dev_flag in _TRUTHY:
-        print("USING DEV ORIGIN")
-        return "http://localhost:3000"
-
-    return "https://www.usesynth.ai/dashboard"
-
-
-def _split_origin(origin: str) -> tuple[str, str]:
-    parsed = urlsplit(origin)
-    bare = urlunsplit((parsed.scheme, parsed.netloc, "", "", ""))
-    path = parsed.path.rstrip("/")
-    return bare, path
-
-
-def _ensure_verification_uri(data: dict[str, Any], base_with_path: str) -> None:
-    uri = data.get("verification_uri")
-    if not isinstance(uri, str) or not uri:
-        return
-    if uri.startswith("http://") or uri.startswith("https://"):
-        return
-    data["verification_uri"] = urljoin(base_with_path.rstrip("/") + "/", uri.lstrip("/"))
-
-
-def start_handshake_session(origin: str | None = None) -> tuple[str, str, int, int]:
-    base = (origin or _origin()).rstrip("/")
-    api_origin, _ = _split_origin(base)
-    url = urljoin(api_origin.rstrip("/") + "/", "api/sdk/handshake/init")
-    r = requests.post(url, timeout=10)
-    if r.status_code != 200:
-        raise HandshakeError(f"init failed: {r.status_code} {r.text}")
-    try:
-        data = r.json()
-    except ValueError as exc:  # pragma: no cover - network dependent
-        raise HandshakeError(f"init returned malformed JSON: {exc}") from exc
-    _ensure_verification_uri(data, base)
-    return (
-        str(data.get("device_code")),
-        str(data.get("verification_uri")),
-        int(data.get("expires_in", 600)),
-        int(data.get("interval", 3)),
-    )
-
-
-def poll_handshake_token(
-    device_code: str, origin: str | None = None, *, timeout_s: int | None = None
-) -> dict[str, Any]:
-    base = (origin or _origin()).rstrip("/")
-    api_origin, _ = _split_origin(base)
-    url = urljoin(api_origin.rstrip("/") + "/", "api/sdk/handshake/token")
-    deadline = time.time() + (timeout_s or 600)
-    while True:
-        if time.time() > deadline:
-            raise HandshakeError("handshake timed out")
-        try:
-            r = requests.post(url, json={"device_code": device_code}, timeout=10)
-        except Exception:
-            time.sleep(2)
-            continue
-        if r.status_code == 200:
-            try:
-                data = r.json()
-            except ValueError as exc:  # pragma: no cover - network dependent
-                raise HandshakeError(f"token returned malformed JSON: {exc}") from exc
-            _ensure_verification_uri(data, base)
-            return data
-        elif r.status_code in (404, 410):
-            raise HandshakeError(f"handshake failed: {r.status_code}")
-        # 428 authorization_pending or others → wait and retry
-        time.sleep(2)
-
-
-def run_handshake(origin: str | None = None) -> dict[str, Any]:
-    device_code, verification_uri, expires_in, interval = start_handshake_session(origin)
-    with contextlib.suppress(Exception):
-        webbrowser.open(verification_uri)
-    return poll_handshake_token(device_code, origin, timeout_s=expires_in)

synth_ai/http.py

@@ -1,26 +0,0 @@
-"""
-Compatibility shim to avoid shadowing Python's stdlib `http` module.
-This re-exports the actual client implementation from http_client.py and
-supports both package and script execution contexts.
-"""
-
-try:
-    from synth_ai.http_client import *  # type: ignore F401,F403
-except Exception:
-    try:
-        from .http_client import *  # type: ignore F401,F403
-    except Exception:
-        import importlib.util as _ilu
-        import sys as _sys
-        from pathlib import Path as _Path
-
-        _here = _Path(__file__).resolve()
-        _client_path = _here.parent / "http_client.py"
-        _spec = _ilu.spec_from_file_location("http_client", str(_client_path))
-        if not _spec or not _spec.loader:
-            raise ImportError("Could not load http_client module") from None
-        _mod = _ilu.module_from_spec(_spec)
-        _spec.loader.exec_module(_mod)
-        _sys.modules["synth_ai.http_client"] = _mod
-        for _name in ("HTTPError", "AsyncHttpClient", "sleep"):
-            globals()[_name] = getattr(_mod, _name)