synth-ai 0.2.9.dev7__py3-none-any.whl → 0.2.10__py3-none-any.whl

synth_ai/cli/traces.py

@@ -26,7 +26,7 @@ def register(cli):
         console = Console()
 
         async def _run():
-            from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
+            from synth_ai.tracing_v3.storage.factory import StorageConfig, create_storage
 
             # Discover DBs under ./synth_ai.db/dbs (or override via env)
             root = os.getenv("SYNTH_TRACES_ROOT", "./synth_ai.db/dbs")
@@ -58,7 +58,7 @@ def register(cli):
 
             async def db_counts(db_dir: str) -> tuple[int, dict[str, int], int, str | None, int]:
                 data_file = os.path.join(db_dir, "data")
-                mgr = AsyncSQLTraceManager(f"sqlite+aiosqlite:///{data_file}")
+                mgr = create_storage(StorageConfig(connection_string=f"sqlite+aiosqlite:///{data_file}"))
                 await mgr.initialize()
                 try:
                     traces_df = await mgr.query_traces("SELECT COUNT(*) AS c FROM session_traces")
@@ -74,9 +74,11 @@ def register(cli):
                         system_counts = (
                             {
                                 str(r["system_type"] or "-"): int(r["c"] or 0)
-                                for _, r in (systems_df or []).iterrows()
+                                for _, r in systems_df.iterrows()
                             }
-                            if systems_df is not None and not systems_df.empty
+                            if systems_df is not None
+                            and hasattr(systems_df, "iterrows")
+                            and not systems_df.empty
                             else {}
                         )
                     except Exception:

synth_ai/cli/watch.py

@@ -16,6 +16,12 @@ from rich.console import Console, Group
 from rich.panel import Panel
 from rich.table import Table
 
+from synth_ai.tracing_v3.storage.factory import StorageConfig, create_storage
+
+
+def _open_db(db_url: str):
+    return create_storage(StorageConfig(connection_string=db_url))
+
 
 class _State:
     def __init__(self):
@@ -48,9 +54,7 @@ def _format_int(value: Any) -> str:
 
 
 async def _fetch_experiments(db_url: str):
-    from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
-
-    db = AsyncSQLTraceManager(db_url)
+    db = _open_db(db_url)
     await db.initialize()
     try:
         df = await db.query_traces(
@@ -114,9 +118,7 @@ def _experiments_table(df, limit: int | None = None) -> Table:
 
 
 async def _experiment_detail(db_url: str, experiment_id: str) -> dict[str, Any]:
-    from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
-
-    db = AsyncSQLTraceManager(db_url)
+    db = _open_db(db_url)
     await db.initialize()
     try:
         exp_df = await db.query_traces(
@@ -253,9 +255,7 @@ def register(cli):
         console = Console()
 
         async def _run():
-            from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
-
-            db = AsyncSQLTraceManager(db_url)
+            db = _open_db(db_url)
             await db.initialize()
             try:
                 df = await db.get_model_usage(model_name=model_name)
@@ -396,9 +396,7 @@ def _parse_hours(args: list[str]) -> float | None:
 
 
 async def _usage_table(db_url: str, model_name: str | None):
-    from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
-
-    db = AsyncSQLTraceManager(db_url)
+    db = _open_db(db_url)
     await db.initialize()
     try:
         df = await db.get_model_usage(model_name=model_name)
@@ -418,9 +416,7 @@ async def _usage_table(db_url: str, model_name: str | None):
 
 
 async def _traces_table(db_url: str, limit: int):
-    from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
-
-    db = AsyncSQLTraceManager(db_url)
+    db = _open_db(db_url)
     await db.initialize()
     try:
         df = await db.query_traces("SELECT * FROM session_summary ORDER BY created_at DESC")
@@ -453,10 +449,8 @@ async def _recent_table(db_url: str, hours: float, limit: int):
     # Inline the recent query to avoid cross-module coupling
     from datetime import timedelta
 
-    from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
-
     start_time = datetime.now() - timedelta(hours=hours)
-    db = AsyncSQLTraceManager(db_url)
+    db = _open_db(db_url)
     await db.initialize()
     try:
         query = """

synth_ai/demo_registry.py

@@ -3,9 +3,9 @@
 from __future__ import annotations
 
 import textwrap
+from collections.abc import Callable, Iterable
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Callable, Iterable
 
 REPO_ROOT = Path(__file__).resolve().parents[1]
 

synth_ai/demos/core/cli.py

@@ -1,25 +1,26 @@
 from __future__ import annotations
 
 import argparse
+import contextlib
 import json
 import os
-import sys
-import time
-from pathlib import Path
-from typing import Any, Dict, Callable
 import shutil
 import stat
+import sys
 import textwrap
+import time
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
 
-from synth_ai.demos.demo_task_apps import core as demo_core
-from synth_ai.demos.demo_task_apps.core import DemoEnv, DEFAULT_TASK_APP_SECRET_NAME
 from synth_ai.demo_registry import (
-    CopySpec,
     DemoTemplate,
     get_demo_template,
     list_demo_templates,
 )
-from synth_ai.handshake import run_handshake, HandshakeError
+from synth_ai.demos.demo_task_apps import core as demo_core
+from synth_ai.demos.demo_task_apps.core import DEFAULT_TASK_APP_SECRET_NAME, DemoEnv
+from synth_ai.handshake import HandshakeError, run_handshake
 
 
 def _key_preview(value: str, label: str) -> str:
@@ -59,7 +60,6 @@ def cmd_setup(_args: argparse.Namespace) -> int:
     try:
         print("\n⏳ Connecting SDK to your browser session…")
         res = run_handshake()
-        user = res.get("user") or {}
         org = res.get("org") or {}
         keys = res.get("keys") or {}
         synth_key = str(keys.get("synth") or "").strip()
@@ -107,8 +107,8 @@ def cmd_setup(_args: argparse.Namespace) -> int:
     demo_core.persist_env_file_path(dotenv_path)
 
     # 2) Reload env after handshake to pick up values from .env (suppress env prints)
-    import io
     import contextlib
+    import io
 
     _buf = io.StringIO()
     with contextlib.redirect_stdout(_buf):
@@ -126,9 +126,7 @@ def cmd_setup(_args: argparse.Namespace) -> int:
             return
         current = env.task_app_base_url
         needs_lookup = False
-        if not current:
-            needs_lookup = True
-        elif not _is_modal_public_url(current):
+        if not current or not _is_modal_public_url(current):
             needs_lookup = True
         if not needs_lookup:
             return
@@ -173,16 +171,14 @@ def cmd_setup(_args: argparse.Namespace) -> int:
 
     _maybe_fix_task_url()
 
-    ok_backend = False
-    ok_task = False
     if env.dev_backend_url:
         api = env.dev_backend_url.rstrip("/") + (
             "" if env.dev_backend_url.endswith("/api") else "/api"
         )
-        ok_backend = demo_core.assert_http_ok(api + "/health", method="GET")
+        demo_core.assert_http_ok(api + "/health", method="GET")
         # Intentionally suppress backend health print for concise output
     if env.task_app_base_url:
-        ok_task = demo_core.assert_http_ok(
+        demo_core.assert_http_ok(
             env.task_app_base_url.rstrip("/") + "/health", method="GET"
         ) or demo_core.assert_http_ok(env.task_app_base_url.rstrip("/"), method="GET")
         # Intentionally suppress task app health print
@@ -723,7 +719,6 @@ def _ensure_task_app_ready(env: DemoEnv, synth_key: str, *, label: str) -> DemoE
     if openai_key:
         os.environ["OPENAI_API_KEY"] = openai_key
 
-    rollout_url = task_url.rstrip("/") + "/health/rollout"
     print(f"[{label}] Verifying rollout health:")
     try:
         ek = (env_key or "").strip()
@@ -738,7 +733,6 @@ def _ensure_task_app_ready(env: DemoEnv, synth_key: str, *, label: str) -> DemoE
         print(f"[{label}] GET", h)
         rc, body = _http("GET", h, headers={"X-API-Key": env_key})
         if rc == 200:
-            rollout_url = h
             break
     print(f"[{label}] status: {rc}")
     try:
@@ -750,10 +744,8 @@ def _ensure_task_app_ready(env: DemoEnv, synth_key: str, *, label: str) -> DemoE
     print(f"[{label}] body:", preview)
     if rc != 200:
         print(f"[{label}] Warning: rollout health check failed ({rc}). Response: {body}")
-        try:
+        with contextlib.suppress(Exception):
             print(f"[{label}] Sent header X-API-Key → {_key_preview(env_key, 'X-API-Key')}")
-        except Exception:
-            pass
     else:
         print(f"[{label}] Task app rollout health check OK.")
 
@@ -883,7 +875,7 @@ def cmd_deploy(args: argparse.Namespace) -> int:
                         env_key = None
 
                 if env_key is None:
-                    from synth_ai.rl.secrets import mint_environment_api_key
+                    from synth_ai.learning.rl.secrets import mint_environment_api_key
 
                     env_key = mint_environment_api_key()
                     demo_core.persist_env_api_key(env_key)
@@ -921,14 +913,14 @@ def cmd_deploy(args: argparse.Namespace) -> int:
                     if choice.startswith("y"):
                         try:
                             print(f"[deploy] Uploading ENVIRONMENT_API_KEY to {non_api_base} …")
-                            from synth_ai.rl.env_keys import setup_environment_api_key
+                            from synth_ai.learning.rl.env_keys import setup_environment_api_key
 
                             setup_environment_api_key(non_api_base, synth_key, token=env_key)
                             print("[deploy] Backend sealed-box upload complete.")
                         except Exception as upload_err:
                             print(f"[deploy] Failed to upload ENVIRONMENT_API_KEY: {upload_err}")
                             print(
-                                'Hint: run `uvx python -c "from synth_ai.rl.env_keys import setup_environment_api_key as s;'
+                                'Hint: run `uvx python -c "from synth_ai.learning.rl.env_keys import setup_environment_api_key as s;'
                                 " s('<backend>', '<synth_api_key>')\"` once the backend is reachable."
                             )
 
@@ -1126,14 +1118,14 @@ def _ensure_modal_installed() -> None:
     if auth_ok:
         print(f"✓ Modal authenticated: {auth_msg}")
     else:
-        print(f"\n⚠️  Modal authentication required")
+        print("\n⚠️  Modal authentication required")
         print(f"   Status: {auth_msg}")
-        print(f"\n   To authenticate Modal, run:")
-        print(f"     modal setup")
-        print(f"\n   Or set environment variables:")
-        print(f"     export MODAL_TOKEN_ID=your-token-id")
-        print(f"     export MODAL_TOKEN_SECRET=your-token-secret")
-        print(f"\n   You can deploy later after authenticating.\n")
+        print("\n   To authenticate Modal, run:")
+        print("     modal setup")
+        print("\n   Or set environment variables:")
+        print("     export MODAL_TOKEN_ID=your-token-id")
+        print("     export MODAL_TOKEN_SECRET=your-token-secret")
+        print("\n   You can deploy later after authenticating.\n")
 
 
 def cmd_init(args: argparse.Namespace) -> int:
@@ -1289,7 +1281,7 @@ def cmd_init(args: argparse.Namespace) -> int:
             should_write = True
             if env_path.exists() and not directory_cleared:
                 try:
-                    response = input(f"File .env exists. Overwrite? [y/N]: ").strip().lower()
+                    response = input("File .env exists. Overwrite? [y/N]: ").strip().lower()
                 except (EOFError, KeyboardInterrupt):
                     print("\nCancelled.")
                     return 1
@@ -1353,9 +1345,12 @@ def cmd_init(args: argparse.Namespace) -> int:
 
 
 def _http(
-    method: str, url: str, headers: Dict[str, str] | None = None, body: Dict[str, Any] | None = None
-) -> tuple[int, Dict[str, Any] | str]:
-    import urllib.request, urllib.error, json as _json, ssl
+    method: str, url: str, headers: dict[str, str] | None = None, body: dict[str, Any] | None = None
+) -> tuple[int, dict[str, Any] | str]:
+    import json as _json
+    import ssl
+    import urllib.error
+    import urllib.request
 
     data = None
     if body is not None:
@@ -1402,7 +1397,7 @@ def cmd_run(args: argparse.Namespace) -> int:
 
     env = demo_core.load_env()
     cwd_env_path = os.path.join(os.getcwd(), ".env")
-    local_env = demo_core.load_dotenv_file(cwd_env_path)
+    demo_core.load_dotenv_file(cwd_env_path)
 
     synth_key = (env.synth_api_key or "").strip()
     if not synth_key:
@@ -1487,7 +1482,7 @@ def cmd_run(args: argparse.Namespace) -> int:
     # Fallback: legacy jobs API flow
     with open(cfg_path, "rb") as fh:
         inline_cfg = tomllib.load(fh)
-    with open(cfg_path, "r") as fh2:
+    with open(cfg_path) as fh2:
         toml_text = fh2.read()
     if args.batch_size is not None:
         inline_cfg.setdefault("training", {})["batch_size"] = int(args.batch_size)
@@ -1498,13 +1493,11 @@ def cmd_run(args: argparse.Namespace) -> int:
     # Print backend and key preview before request for clearer diagnostics
     try:
         sk = (env.synth_api_key or "").strip()
-        sk_len = len(sk)
-        sk_tail = sk[-5:] if sk_len >= 5 else sk
         print(f"[run] Backend API: {api}")
         print(f"[run] {_key_preview(sk, 'SYNTH_API_KEY')}")
     except Exception:
         pass
-    data_fragment: Dict[str, Any] = {
+    data_fragment: dict[str, Any] = {
         "model": model_name,
         "endpoint_base_url": env.task_app_base_url,
         "config": inline_cfg,
@@ -1529,7 +1522,7 @@ def cmd_run(args: argparse.Namespace) -> int:
         if ":" in gshape:
             t, c = gshape.split(":", 1)
             compute = {"gpu_type": t.upper(), "gpu_count": int(c)}
-    body: Dict[str, Any] = {
+    body: dict[str, Any] = {
         "job_type": "rl",
         "data": data_fragment,
     }
@@ -1588,7 +1581,7 @@ def cmd_run(args: argparse.Namespace) -> int:
                     pass
                 try:
                     sent_keys = detail.get("sent_keys")
-                    if isinstance(sent_keys, (list, tuple)):
+                    if isinstance(sent_keys, list | tuple):
                         previews = []
                         for idx, val in enumerate(sent_keys):
                             if isinstance(val, str):

synth_ai/demos/demo_task_apps/__init__.py

@@ -1,7 +1,7 @@
 """Namespace for demo task apps (math, etc.)."""
 
+import contextlib
+
 # Ensure registry entries are loaded for CLI discovery.
-try:  # pragma: no cover - optional on downstream installs
+with contextlib.suppress(Exception):  # pragma: no cover - optional on downstream installs
     from .math import task_app_entry  # noqa: F401
-except Exception:
-    pass

synth_ai/demos/demo_task_apps/core.py

@@ -3,15 +3,12 @@ from __future__ import annotations
 import json
 import os
 import subprocess
-import sys
-from dataclasses import dataclass
-from typing import Any, Dict, Optional, Tuple
-
 import urllib.request
+from dataclasses import dataclass
+from typing import Any
 
 from synth_ai.config.base_url import PROD_BASE_URL_DEFAULT
 
-
 DEFAULT_TASK_APP_SECRET_NAME = "hendrycks-math-task-app-secret"
 
 
@@ -35,7 +32,7 @@ def _state_path() -> str:
     return os.path.expanduser("~/.synth-ai/demo.json")
 
 
-def _read_state() -> Dict[str, Any]:
+def _read_state() -> dict[str, Any]:
     try:
         path = _state_path()
         if os.path.isfile(path):
@@ -47,7 +44,7 @@ def _read_state() -> Dict[str, Any]:
     return {}
 
 
-def _write_state(data: Dict[str, Any]) -> None:
+def _write_state(data: dict[str, Any]) -> None:
     try:
         path = _state_path()
         os.makedirs(os.path.dirname(path), exist_ok=True)
@@ -57,8 +54,8 @@ def _write_state(data: Dict[str, Any]) -> None:
         pass
 
 
-def load_dotenv_file(path: str) -> Dict[str, str]:
-    out: Dict[str, str] = {}
+def load_dotenv_file(path: str) -> dict[str, str]:
+    out: dict[str, str] = {}
     try:
         with open(path) as fh:
             for raw in fh:
@@ -72,7 +69,7 @@ def load_dotenv_file(path: str) -> Dict[str, str]:
     return out
 
 
-def _persist_dotenv_values(path: str, values: Dict[str, str]) -> None:
+def _persist_dotenv_values(path: str, values: dict[str, str]) -> None:
     """Ensure ``values`` are present in ``path`` (.env style)."""
 
     try:
@@ -82,7 +79,7 @@ def _persist_dotenv_values(path: str, values: Dict[str, str]) -> None:
                 existing_lines = fh.read().splitlines()
         else:
             os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
-        mapping: Dict[str, str] = {}
+        mapping: dict[str, str] = {}
         order: list[str] = []
         for line in existing_lines:
             if not line or line.startswith("#") or "=" not in line:
@@ -110,7 +107,7 @@ def _persist_dotenv_values(path: str, values: Dict[str, str]) -> None:
         pass
 
 
-def persist_dotenv_values(values: Dict[str, str], *, cwd: str | None = None) -> str:
+def persist_dotenv_values(values: dict[str, str], *, cwd: str | None = None) -> str:
     path = os.path.join(cwd or os.getcwd(), ".env")
     _persist_dotenv_values(path, values)
     return path
@@ -148,14 +145,15 @@ def load_env_file_path() -> str | None:
     return data.get("ENV_FILE_PATH")
 
 
-def modal_auth_status() -> Tuple[bool, str]:
+def modal_auth_status() -> tuple[bool, str]:
     """Return (ok, message) describing Modal CLI credential status."""
 
     env_token_id = (os.environ.get("MODAL_TOKEN_ID") or "").strip()
     env_token_secret = (os.environ.get("MODAL_TOKEN_SECRET") or "").strip()
 
     try:
-        from modal.config import config as modal_config, user_config_path
+        from modal.config import config as modal_config
+        from modal.config import user_config_path
     except Exception as exc:  # pragma: no cover - modal optional in some envs
         return False, f"Modal client unavailable ({exc})"
 
@@ -210,7 +208,7 @@ def load_env() -> DemoEnv:
     """
     env = DemoEnv()
 
-    os_env: Dict[str, str] = dict(os.environ)
+    os_env: dict[str, str] = dict(os.environ)
 
     # CWD .env
     cwd_env_path = os.path.join(os.getcwd(), ".env")
@@ -245,15 +243,12 @@ def load_env() -> DemoEnv:
         or pkg_env.get("DEV_BACKEND_URL")
         or ""
     ).strip()
-    use_dev = False
     if backend_override:
         dev_url = backend_override
-        use_dev = True
     elif dev_env:
         lower = dev_env.lower()
         if "localhost" in lower or "127.0.0.1" in lower or lower.endswith(":8000"):
             dev_url = dev_env
-            use_dev = True
         else:
             dev_url = prod_default
     else:
@@ -426,16 +421,13 @@ def run_job(
     env: DemoEnv,
     config_toml_path: str,
     *,
-    batch_size: Optional[int] = None,
-    group_size: Optional[int] = None,
-    model: Optional[str] = None,
+    batch_size: int | None = None,
+    group_size: int | None = None,
+    model: str | None = None,
 ) -> None:
     """Create and stream a short RL job using the backend API (placeholder: prints cURL to execute)."""
     backend = env.dev_backend_url.rstrip("/")
-    if backend.endswith("/api"):
-        api_base = backend
-    else:
-        api_base = backend + "/api"
+    api_base = backend if backend.endswith("/api") else backend + "/api"
     print("\nTo create an RL job, run:")
     print(
         'curl -s -X POST "' + api_base + '/rl/jobs" '

synth_ai/demos/demo_task_apps/crafter/grpo_crafter_task_app.py

@@ -9,16 +9,15 @@ Prefer using `uvx synth-ai serve grpo-crafter` for local development and testing
 from __future__ import annotations
 
 import argparse
+import importlib.util
 from pathlib import Path
 
 from fastapi.exceptions import RequestValidationError
 from fastapi.responses import JSONResponse
 from starlette.requests import Request
-
 from synth_ai.task.apps import ModalDeploymentConfig, registry
 from synth_ai.task.auth import is_api_key_header_authorized, normalize_environment_api_key
 from synth_ai.task.server import TaskAppConfig, create_task_app, run_task_app
-import importlib.util
 
 
 def _load_build_config():
@@ -40,7 +39,7 @@ def _load_build_config():
         raise ImportError(f"Could not load task app module at {module_path}")
     module = importlib.util.module_from_spec(spec)
     spec.loader.exec_module(module)
-    return getattr(module, "build_config")
+    return module.build_config
 
 
 build_config = _load_build_config()
@@ -130,7 +129,7 @@ def fastapi_app():
         try:
             hdr = request.headers
             snapshot = {
-                "path": str(getattr(request, "url").path),
+                "path": str(request.url.path),
                 "have_x_api_key": bool(hdr.get("x-api-key")),
                 "have_x_api_keys": bool(hdr.get("x-api-keys")),
                 "have_authorization": bool(hdr.get("authorization")),

synth_ai/demos/demo_task_apps/math/app.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+
 from fastapi import FastAPI
 from starlette.middleware.cors import CORSMiddleware
 
@@ -11,7 +12,7 @@ except Exception:  # fallback path when imported from repo root
     try:
         from examples.rl.task_app import make_app as make_rl_app  # type: ignore
     except Exception as e:  # pragma: no cover
-        raise ImportError(f"Unable to import RL task app: {e}")
+        raise ImportError(f"Unable to import RL task app: {e}") from e
 
 
 def create_app() -> FastAPI:

synth_ai/demos/demo_task_apps/math/deploy_modal.py

@@ -2,10 +2,9 @@ from __future__ import annotations
 
 import os
 import subprocess
-from typing import Optional
 
 
-def _parse_public_url_from_log(log_path: str) -> Optional[str]:
+def _parse_public_url_from_log(log_path: str) -> str | None:
     try:
         with open(log_path) as fh:
             for line in fh:
@@ -16,7 +15,7 @@ def _parse_public_url_from_log(log_path: str) -> Optional[str]:
     return None
 
 
-def deploy(script_path: Optional[str] = None, *, env_api_key: Optional[str] = None) -> str:
+def deploy(script_path: str | None = None, *, env_api_key: str | None = None) -> str:
     """
     Deploy the Math Task App to Modal and return the public URL.
 
@@ -55,4 +54,4 @@ def deploy(script_path: Optional[str] = None, *, env_api_key: Optional[str] = No
         raise RuntimeError(
             f"No deploy script provided and Python-based deploy failed: {e}. "
             "Pass --script /path/to/deploy_task_app.sh to demo.deploy."
-        )
+        ) from e