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

synth_ai/lm/warmup.py

@@ -1,186 +0,0 @@
-"""
-Model warmup utilities for Synth backend.
-Handles model preloading and warmup polling.
-"""
-
-import asyncio
-import logging
-import sys
-import time
-from datetime import datetime, timedelta
-
-import httpx
-
-from .config import SynthConfig
-
-logger = logging.getLogger(__name__)
-
-
-class WarmupStatus:
-    """Track warmup status for models with TTL."""
-
-    def __init__(self):
-        self._warmed_models: dict[str, datetime] = {}
-        self._ttl = timedelta(minutes=10)  # Consider models warm for 10 minutes
-
-    def is_warm(self, model_name: str) -> bool:
-        """Check if model is already warmed up."""
-        if model_name in self._warmed_models:
-            if datetime.now() - self._warmed_models[model_name] < self._ttl:
-                return True
-            else:
-                # Clean up expired entry
-                del self._warmed_models[model_name]
-        return False
-
-    def mark_warm(self, model_name: str):
-        """Mark model as warmed up."""
-        self._warmed_models[model_name] = datetime.now()
-
-    def clear(self):
-        """Clear all warmup status."""
-        self._warmed_models.clear()
-
-
-# Global warmup tracker
-_warmup_status = WarmupStatus()
-
-
-async def warmup_synth_model(
-    model_name: str,
-    config: SynthConfig | None = None,
-    max_attempts: int | None = None,
-    force: bool = False,
-    verbose: bool = True,
-    gpu_preference: str | None = None,
-) -> bool:
-    """
-    Warm up a model on the Synth backend using fire-and-forget approach.
-
-    Args:
-        model_name: Name of the model to warm up
-        config: Synth configuration (loads from env if not provided)
-        max_attempts: Maximum number of polling attempts
-        force: Force warmup even if model is cached as warm
-        verbose: Print progress messages
-
-    Returns:
-        True if model is successfully warmed up, False otherwise
-    """
-    # Load config from environment if not provided
-    if config is None:
-        config = SynthConfig.from_env()
-
-    # Check if already warm
-    if not force and _warmup_status.is_warm(model_name):
-        return True
-
-    async with httpx.AsyncClient() as client:
-        headers = {"Authorization": f"Bearer {config.api_key}"}
-        if gpu_preference:
-            headers["X-GPU-Preference"] = gpu_preference
-
-        # Step 1: Start warmup (fire and forget)
-        try:
-            response = await client.post(
-                f"{config.get_base_url_without_v1()}/warmup/{model_name}",
-                headers=headers,
-                timeout=30.0,  # Short timeout for the start request
-            )
-
-            if response.status_code == 200:
-                response_data = response.json()
-                if response_data.get("status") in ["warming", "already_warming"]:
-                    pass
-                elif response_data.get("status") == "already_warmed":
-                    _warmup_status.mark_warm(model_name)
-                    return True
-                else:
-                    logger.warning(f"Unexpected warmup response: {response_data}")
-            else:
-                logger.warning(
-                    f"Warmup start failed with status {response.status_code}: {response.text}"
-                )
-                return False
-
-        except Exception as e:
-            logger.warning(f"Warmup start failed: {e}")
-            return False
-
-        # Step 2: Poll status until ready (indefinite by default)
-        spinner = "|/-\\"
-        spin_idx = 0
-        start_time = time.time()
-        attempt = 0
-        while True:
-            attempt += 1
-            try:
-                response = await client.get(
-                    f"{config.get_base_url_without_v1()}/warmup/status/{model_name}",
-                    headers=headers,
-                    timeout=10.0,
-                )
-
-                if response.status_code == 200:
-                    status_data = response.json()
-                    status = status_data.get("status")
-
-                    if status == "warmed":
-                        _warmup_status.mark_warm(model_name)
-                        # Final spinner line as success
-                        elapsed = int(time.time() - start_time)
-                        sys.stdout.write(f"\r✅ Warmed {model_name} in {elapsed}s        \n")
-                        sys.stdout.flush()
-                        return True
-                    elif status == "failed":
-                        error = status_data.get("error", "Unknown error")
-                        logger.error(f"❌ Warmup failed for {model_name}: {error}")
-                        sys.stdout.write(f"\r❌ Warmup failed: {error}            \n")
-                        sys.stdout.flush()
-                        return False
-                    else:
-                        # Treat unknown statuses (e.g., "cold") as still warming
-                        elapsed = int(time.time() - start_time)
-                        wheel = spinner[spin_idx % len(spinner)]
-                        spin_idx += 1
-                        label = status or "pending"
-                        sys.stdout.write(
-                            f"\r⏳ Warming {model_name} [{wheel}] status={label} elapsed={elapsed}s"
-                        )
-                        sys.stdout.flush()
-
-                # Short sleep between status checks
-                await asyncio.sleep(2.0)
-
-            except httpx.TimeoutException:
-                # Continue polling; update spinner line
-                elapsed = int(time.time() - start_time)
-                wheel = spinner[spin_idx % len(spinner)]
-                spin_idx += 1
-                sys.stdout.write(
-                    f"\r⏳ Warming {model_name} [{wheel}] status=timeout elapsed={elapsed}s"
-                )
-                sys.stdout.flush()
-                await asyncio.sleep(1.0)
-            except Exception:
-                # Continue polling; update spinner line with error label
-                elapsed = int(time.time() - start_time)
-                wheel = spinner[spin_idx % len(spinner)]
-                spin_idx += 1
-                sys.stdout.write(
-                    f"\r⏳ Warming {model_name} [{wheel}] status=error elapsed={elapsed}s"
-                )
-                sys.stdout.flush()
-                await asyncio.sleep(1.0)
-
-            # Optional max_attempts for callers who want a cap
-            if max_attempts is not None and attempt >= max_attempts:
-                logger.error(f"Failed to warm up {model_name} after {max_attempts} status checks")
-                sys.stdout.write("\n")
-                sys.stdout.flush()
-                return False
-
-
-def get_warmup_status() -> WarmupStatus:
-    """Get the global warmup status tracker."""
-    return _warmup_status

synth_ai/rl/secrets.py

@@ -1,19 +0,0 @@
-from __future__ import annotations
-
-"""Helpers for generating RL environment credentials."""
-
-import secrets
-
-__all__ = ["mint_environment_api_key"]
-
-
-def mint_environment_api_key() -> str:
-    """Mint a random ENVIRONMENT_API_KEY value.
-
-    The current format is 64 hexadecimal characters (256 bits of entropy), which
-    matches the shell helpers used by the RL examples. This keeps the token easy
-    to copy while remaining suitably strong for authentication.
-    """
-
-    # secrets.token_hex(32) → 32 random bytes rendered as 64 hex characters.
-    return secrets.token_hex(32)

synth_ai/scripts/verify_rewards.py

@@ -1,100 +0,0 @@
-#!/usr/bin/env python3
-"""
-Verify reward persistence in a traces database.
-
-Usage:
-  uv run python -m synth_ai.scripts.verify_rewards --db /path/to/db.sqlite --min-reward 1
-"""
-
-import argparse
-import asyncio
-import os
-from typing import Dict
-
-from sqlalchemy import text
-
-from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
-
-
-async def verify(db_path: str, min_reward: int) -> int:
-    db_url = db_path
-    if not db_url.startswith("sqlite+aiosqlite:///"):
-        db_url = f"sqlite+aiosqlite:///{os.path.abspath(db_path)}"
-
-    mgr = AsyncSQLTraceManager(db_url=db_url)
-    await mgr.initialize()
-
-    try:
-        async with mgr.session() as session:
-            # Sessions with outcome_rewards
-            q_good = text(
-                """
-                SELECT session_id, MAX(total_reward) as total_reward
-                FROM outcome_rewards
-                GROUP BY session_id
-                """
-            )
-            res = await session.execute(q_good)
-            outcomes = {row[0]: int(row[1]) for row in res.fetchall()}
-
-            # Sessions without outcome_rewards
-            q_missing = text(
-                """
-                SELECT s.session_id
-                FROM session_traces s
-                LEFT JOIN outcome_rewards o ON s.session_id = o.session_id
-                WHERE o.session_id IS NULL
-                """
-            )
-            res2 = await session.execute(q_missing)
-            missing = [row[0] for row in res2.fetchall()]
-
-            # Aggregate event_rewards per session (informational)
-            q_event = text(
-                """
-                SELECT session_id, COALESCE(SUM(reward_value), 0.0) as sum_rewards
-                FROM event_rewards
-                GROUP BY session_id
-                """
-            )
-            res3 = await session.execute(q_event)
-            event_sums: Dict[str, float] = {row[0]: float(row[1]) for row in res3.fetchall()}
-
-        print(f"Sessions with outcome_rewards: {len(outcomes)}")
-        print(f"Sessions missing outcome_rewards: {len(missing)}")
-        if missing:
-            print("Missing session_ids:", ", ".join(missing[:10]) + (" ..." if len(missing) > 10 else ""))
-
-        # Threshold check
-        qualifying = {sid: r for sid, r in outcomes.items() if r >= min_reward}
-        print(f"Sessions with total_reward >= {min_reward}: {len(qualifying)}")
-
-        # Show a small comparison snapshot
-        sample = list(qualifying.items())[:5]
-        for sid, tot in sample:
-            er = event_sums.get(sid, 0.0)
-            print(f"  {sid}: outcome={tot}, sum(event_rewards)={er:.2f}")
-
-        # Exit non-zero if any sessions are missing outcome rewards
-        if missing:
-            return 2
-        if min_reward > 0 and not qualifying:
-            return 3
-        return 0
-    finally:
-        await mgr.close()
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser(description="Verify reward persistence in traces DB")
-    ap.add_argument("--db", required=True, help="Path to traces SQLite DB (aiosqlite)")
-    ap.add_argument("--min-reward", type=int, default=0, help="Minimum total_reward to consider qualifying")
-    args = ap.parse_args()
-
-    return asyncio.run(verify(args.db, args.min_reward))
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
-
-

synth_ai/task/__init__.py

@@ -1,10 +0,0 @@
-from .validators import validate_task_app_url
-from .health import task_app_health
-from .contracts import TaskAppContract, TaskAppEndpoints
-
-__all__ = [
-    "validate_task_app_url",
-    "task_app_health",
-    "TaskAppContract",
-    "TaskAppEndpoints",
-]

synth_ai/task/contracts.py

@@ -1,120 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Optional, Any, Dict, List
-from pydantic import BaseModel
-
-
-@dataclass(frozen=True)
-class TaskAppEndpoints:
-    """Canonical Task App endpoint shapes used by RL trainers.
-
-    The Task App is an HTTP service (often deployed on Modal) that exposes:
-    - Health: GET /health
-      • Requires header X-API-Key (when ENVIRONMENT_API_KEY is configured)
-      • Returns { healthy: true }
-    - Environment lifecycle:
-      • POST /env/{env_name}/initialize → { env_id, observation }
-      • POST /env/{env_name}/step      → { observation, reward, done, info }
-      • POST /env/{env_name}/terminate → { ok: true }
-    - Rollout (optional, unified schema):
-      • POST /rollout → { run_id, trajectories[], metrics, ... }
-    - Proxy (optional):
-      • POST /proxy/v1/chat/completions (for direct OpenAI calls from Task App)
-    """
-
-    health: str = "/health"
-    rollout: str = "/rollout"
-    proxy_chat_completions: str = "/proxy/v1/chat/completions"
-    env_initialize: str = "/env/{env_name}/initialize"
-    env_step: str = "/env/{env_name}/step"
-    env_terminate: str = "/env/{env_name}/terminate"
-
-
-@dataclass(frozen=True)
-class TaskAppContract:
-    """Requirements and expectations for a Task App used by RL trainers.
-
-    - Auth: ENVIRONMENT_API_KEY must be set in the Task App environment; requests include X-API-Key.
-    - Health: /health returns 200 and JSON; may verify X-API-Key header.
-    - Env API: initialize/step/terminate are present for the target env (e.g., CrafterClassic).
-    - Rollout API: optional; provides a single-call rollout for convenience/testing.
-    - Inference routing: policy config passes an inference_url (Synth backend or OpenAI proxy).
-    - URL: base must be reachable via HTTPS and should be under .modal.run in production.
-    """
-
-    base_url: str
-    env_name: Optional[str] = None
-    requires_api_key_header: bool = True
-
-
-# --- Unified rollout schema used by Task App services and SDK utilities ---
-
-class RolloutEnvSpec(BaseModel):
-    env_id: Optional[str] = None
-    env_name: Optional[str] = None
-    config: Dict[str, Any] = {}
-    seed: Optional[int] = None
-
-
-class RolloutPolicySpec(BaseModel):
-    policy_id: Optional[str] = None
-    policy_name: Optional[str] = None
-    config: Dict[str, Any] = {}
-
-
-class RolloutRecordConfig(BaseModel):
-    trajectories: bool = True
-    logprobs: bool = False
-    value: bool = False
-
-
-class RolloutSafetyConfig(BaseModel):
-    max_ops: int = 100000
-    max_time_s: float = 3600.0
-
-
-class RolloutRequest(BaseModel):
-    run_id: str
-    env: RolloutEnvSpec
-    policy: RolloutPolicySpec
-    ops: List[Dict[str, Any]] | List[str]
-    record: RolloutRecordConfig = RolloutRecordConfig()
-    on_done: str = "reset"
-    safety: RolloutSafetyConfig = RolloutSafetyConfig()
-    training_session_id: Optional[str] = None
-    synth_base_url: Optional[str] = None
-
-
-class RolloutStep(BaseModel):
-    obs: Dict[str, Any]
-    tool_calls: List[Dict[str, Any]]
-    reward: Optional[float] = None
-    done: bool = False
-    truncated: Optional[bool] = None
-    info: Optional[Dict[str, Any]] = None
-
-
-class RolloutTrajectory(BaseModel):
-    env_id: str
-    policy_id: str
-    steps: List[RolloutStep]
-    final: Optional[Dict[str, Any]] = None
-    length: int
-
-
-class RolloutMetrics(BaseModel):
-    episode_returns: List[float]
-    mean_return: float
-    num_steps: int
-    num_episodes: int = 0
-
-
-class RolloutResponse(BaseModel):
-    run_id: str
-    trajectories: List[RolloutTrajectory]
-    branches: Dict[str, List[str]] = {}
-    metrics: RolloutMetrics
-    aborted: bool = False
-    ops_executed: int = 0
-

synth_ai/task/health.py

@@ -1,28 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Dict
-import aiohttp
-
-
-async def task_app_health(task_app_url: str) -> Dict[str, Any]:
-    """Probe a Task App base URL for basic reachability.
-
-    Behavior:
-    - Try HEAD first (follows redirects)
-    - Fallback to GET if HEAD is unsupported
-    - Returns {ok: bool, status?: int, error?: str}
-    """
-    try:
-        async with aiohttp.ClientSession() as session:
-            async with session.head(task_app_url, allow_redirects=True) as r:
-                if 200 <= r.status < 400:
-                    return {"ok": True, "status": r.status}
-        async with aiohttp.ClientSession() as session:
-            async with session.get(task_app_url, allow_redirects=True) as r2:
-                if 200 <= r2.status < 400:
-                    return {"ok": True, "status": r2.status}
-        return {"ok": False, "status": None}
-    except Exception as e:
-        return {"ok": False, "error": f"{type(e).__name__}: {e}"}
-
-

synth_ai/task/validators.py

@@ -1,12 +0,0 @@
-from __future__ import annotations
-
-from urllib.parse import urlparse
-
-
-def validate_task_app_url(url: str, *, name: str = "TASK_APP_BASE_URL") -> None:
-    """Validate a Task App base URL (scheme + host present)."""
-
-    p = urlparse(url)
-    if p.scheme not in ("http", "https") or not p.netloc:
-        raise ValueError(f"Invalid {name}: malformed: {url}")
-

synth_ai/tracing/__init__.py

@@ -1,30 +0,0 @@
-import importlib as _importlib
-import sys as _sys
-
-_pkg = _importlib.import_module("synth_ai.v0.tracing")
-_sys.modules[__name__] = _pkg
-
-_SUBMODULES = [
-    "abstractions",
-    "base_client",
-    "client_manager",
-    "config",
-    "context",
-    "decorators",
-    "immediate_client",
-    "local",
-    "log_client_base",
-    "retry_queue",
-    "trackers",
-    "upload",
-    "utils",
-]
-for _m in _SUBMODULES:
-    _sys.modules[f"{__name__}.{_m}"] = _importlib.import_module(f"synth_ai.v0.tracing.{_m}")
-
-_events_pkg = _importlib.import_module("synth_ai.v0.tracing.events")
-_sys.modules[f"{__name__}.events"] = _events_pkg
-for _m in ["manage", "scope", "store"]:
-    _sys.modules[f"{__name__}.events.{_m}"] = _importlib.import_module(
-        f"synth_ai.v0.tracing.events.{_m}"
-    )

synth_ai/tracing_v1/__init__.py

@@ -1,33 +0,0 @@
-import importlib as _importlib
-import sys as _sys
-
-# Forward top-level package
-_pkg = _importlib.import_module("synth_ai.v0.tracing_v1")
-_sys.modules[__name__] = _pkg
-
-# Explicitly forward submodules so `synth_ai.tracing_v1.X` works
-_SUBMODULES = [
-    "abstractions",
-    "base_client",
-    "client_manager",
-    "config",
-    "context",
-    "decorators",
-    "immediate_client",
-    "local",
-    "log_client_base",
-    "retry_queue",
-    "trackers",
-    "upload",
-    "utils",
-]
-for _m in _SUBMODULES:
-    _sys.modules[f"{__name__}.{_m}"] = _importlib.import_module(f"synth_ai.v0.tracing_v1.{_m}")
-
-# Forward events package and its submodules
-_events_pkg = _importlib.import_module("synth_ai.v0.tracing_v1.events")
-_sys.modules[f"{__name__}.events"] = _events_pkg
-for _m in ["manage", "scope", "store"]:
-    _sys.modules[f"{__name__}.events.{_m}"] = _importlib.import_module(
-        f"synth_ai.v0.tracing_v1.events.{_m}"
-    )

synth_ai/tracing_v3/config.py

@@ -1,84 +0,0 @@
-"""Configuration for tracing v3 with Turso/sqld."""
-
-import os
-from dataclasses import dataclass
-
-
-@dataclass
-class TursoConfig:
-    """Configuration for Turso/sqld connection."""
-
-    # Default values matching serve.sh
-    DEFAULT_DB_FILE = "traces/v3/synth_ai.db"
-    DEFAULT_HTTP_PORT = 8080
-
-    # Local embedded database for async SQLAlchemy
-    # Resolve to the actual SQLite file used by sqld if the base path is a directory
-    def _resolve_sqlite_db_url() -> str:  # type: ignore[no-redef]
-        base_path = os.path.abspath(os.getenv("SQLD_DB_PATH", "traces/v3/synth_ai.db"))
-        # If sqld is managing this DB, the real SQLite file lives under dbs/default/data
-        candidate = os.path.join(base_path, "dbs", "default", "data")
-        if os.path.isdir(base_path) and os.path.exists(candidate):
-            return f"sqlite+aiosqlite:///{candidate}"
-        return f"sqlite+aiosqlite:///{base_path}"
-
-    # Use env override if provided; otherwise resolve based on SQLD layout
-    db_url: str = os.getenv("TURSO_LOCAL_DB_URL", _resolve_sqlite_db_url())
-
-    # Remote database sync configuration
-    sync_url: str = os.getenv("TURSO_DATABASE_URL", "")
-    auth_token: str = os.getenv("TURSO_AUTH_TOKEN", "")
-    sync_interval: int = int(
-        os.getenv("TURSO_SYNC_SECONDS", "2")
-    )  # 2 seconds for responsive local development
-
-    # Connection pool settings
-    pool_size: int = int(os.getenv("TURSO_POOL_SIZE", "8"))
-    max_overflow: int = int(os.getenv("TURSO_MAX_OVERFLOW", "16"))
-    pool_timeout: float = float(os.getenv("TURSO_POOL_TIMEOUT", "30.0"))
-    pool_recycle: int = int(os.getenv("TURSO_POOL_RECYCLE", "3600"))
-
-    # SQLite settings
-    foreign_keys: bool = os.getenv("TURSO_FOREIGN_KEYS", "true").lower() == "true"
-    journal_mode: str = os.getenv("TURSO_JOURNAL_MODE", "WAL")
-
-    # Performance settings
-    echo_sql: bool = os.getenv("TURSO_ECHO_SQL", "false").lower() == "true"
-    batch_size: int = int(os.getenv("TURSO_BATCH_SIZE", "1000"))
-
-    # Daemon settings (for local sqld) - match serve.sh defaults
-    sqld_binary: str = os.getenv("SQLD_BINARY", "sqld")
-    sqld_db_path: str = os.getenv("SQLD_DB_PATH", "traces/v3/synth_ai.db")
-    sqld_http_port: int = int(os.getenv("SQLD_HTTP_PORT", "8080"))
-    sqld_idle_shutdown: int = int(os.getenv("SQLD_IDLE_SHUTDOWN", "0"))  # 0 = no idle shutdown
-
-    def get_connect_args(self) -> dict:
-        """Get SQLAlchemy connection arguments."""
-        args = {}
-        if self.auth_token:
-            args["auth_token"] = self.auth_token
-        return args
-
-    def get_engine_kwargs(self) -> dict:
-        """Get SQLAlchemy engine creation kwargs."""
-        kwargs = {
-            "echo": self.echo_sql,
-            "future": True,
-        }
-
-        # Only add pool settings for non-SQLite URLs
-        if not (self.db_url.startswith("sqlite") or ":memory:" in self.db_url):
-            kwargs.update(
-                {
-                    "pool_size": self.pool_size,
-                    "max_overflow": self.max_overflow,
-                    "pool_timeout": self.pool_timeout,
-                    "pool_recycle": self.pool_recycle,
-                }
-            )
-
-        return kwargs
-
-
-# Global config instance
-CONFIG = TursoConfig()