synth-ai 0.2.8.dev4__py3-none-any.whl → 0.2.23.dev3__py3-none-any.whl

synth_ai/cli/traces.py

@@ -11,6 +11,8 @@ from rich import box
 from rich.console import Console
 from rich.table import Table
 
+from ._storage import load_storage
+
 
 def register(cli):
     @cli.command()
@@ -26,8 +28,6 @@ def register(cli):
         console = Console()
 
         async def _run():
-            from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
-
             # Discover DBs under ./synth_ai.db/dbs (or override via env)
             root = os.getenv("SYNTH_TRACES_ROOT", "./synth_ai.db/dbs")
             if not os.path.isdir(root):
@@ -51,13 +51,15 @@ def register(cli):
                     for fn in files:
                         fp = os.path.join(dp, fn)
                         import contextlib
+
                         with contextlib.suppress(OSError):
                             total += os.path.getsize(fp)
                 return total
 
             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}")
+                create_storage, storage_config = load_storage()
+                mgr = create_storage(storage_config(connection_string=f"sqlite+aiosqlite:///{data_file}"))
                 await mgr.initialize()
                 try:
                     traces_df = await mgr.query_traces("SELECT COUNT(*) AS c FROM session_traces")
@@ -73,9 +75,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/train/__init__.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from .core import register, train_command
+from .errors import TrainCliError
+from .validation import validate_train_environment
+
+__all__ = [
+    "register",
+    "train_command",
+    "TrainCliError",
+    "validate_train_environment",
+]

synth_ai/cli/train/core.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import click
+from synth_ai.api.train.cli import (
+    register as _register_with_cli,
+)
+from synth_ai.api.train.cli import (
+    train_command as _train_command,
+)
+
+__all__ = ["register", "train_command"]
+
+
+def register(cli: click.Group) -> None:
+    """Attach the train command to the root CLI."""
+    _register_with_cli(cli)
+
+
+def train_command(*args, **kwargs):
+    """Entrypoint used by the train CLI command."""
+    return _train_command(*args, **kwargs)

synth_ai/cli/train/errors.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+
+class TrainCliError(RuntimeError):
+    """Base exception for train CLI failures."""
+
+
+__all__ = ["TrainCliError"]

synth_ai/cli/train/validation.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Dict, Tuple
+
+from synth_ai.api.train.env_resolver import KeySpec, resolve_env
+
+__all__ = ["validate_train_environment"]
+
+
+def validate_train_environment(
+    *,
+    config_path: Path | None,
+    explicit_env_paths: Iterable[str],
+    required_keys: list[KeySpec],
+) -> Tuple[Path, Dict[str, str]]:
+    """Validate and resolve environment secrets used by the train command."""
+    resolved_path, resolved_keys = resolve_env(
+        config_path=config_path,
+        explicit_env_paths=explicit_env_paths,
+        required_keys=required_keys,
+    )
+    return resolved_path, resolved_keys

synth_ai/cli/train.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from synth_ai.cli.commands.train.core import register, train_command
+
+__all__ = ["register", "train_command"]

synth_ai/cli/turso.py

@@ -0,0 +1,73 @@
+"""Utility CLI command for managing Turso sqld binaries."""
+
+from __future__ import annotations
+
+import subprocess
+
+import click
+
+from .root import SQLD_VERSION, find_sqld_binary, install_sqld
+
+
+def register(cli: click.Group) -> None:
+    """Register the turso command on the main CLI group."""
+
+    cli.add_command(turso)
+
+
+def _get_sqld_version(binary: str) -> str | None:
+    """Return the version string reported by the sqld binary."""
+
+    try:
+        result = subprocess.run(
+            [binary, "--version"],
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=5,
+        )
+    except (OSError, subprocess.CalledProcessError, ValueError):
+        return None
+
+    output = result.stdout.strip() or result.stderr.strip()
+    return output or None
+
+
+@click.command()
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Reinstall the pinned sqld build even if one is already available.",
+)
+def turso(force: bool) -> None:
+    """Ensure the Turso sqld binary required for tracing v3 is installed."""
+
+    existing_path = find_sqld_binary()
+
+    if existing_path and not force:
+        version_info = _get_sqld_version(existing_path)
+        click.echo(f"✅ Turso sqld detected at {existing_path}.")
+        if version_info:
+            click.echo(f"   Reported version: {version_info}")
+        if version_info and SQLD_VERSION not in version_info:
+            click.echo(
+                f"⚠️ Pinned version is {SQLD_VERSION}. Run with --force to install the supported build."
+            )
+        else:
+            click.echo("No action taken. Use --force to reinstall the pinned build.")
+        return
+
+    if existing_path and force:
+        click.echo(f"♻️ Reinstalling Turso sqld {SQLD_VERSION} (previously at {existing_path}).")
+    else:
+        click.echo(f"📦 Installing Turso sqld {SQLD_VERSION}…")
+
+    try:
+        installed_path = install_sqld()
+    except subprocess.CalledProcessError as exc:  # pragma: no cover - surfaced as Click error
+        raise click.ClickException(
+            f"sqld installation failed (exit code {exc.returncode})."
+        ) from exc
+
+    click.echo(f"✅ sqld installed to {installed_path}")
+    click.echo("Ensure ~/.local/bin is on your PATH before running Synth AI services.")

synth_ai/cli/watch.py

@@ -16,6 +16,13 @@ from rich.console import Console, Group
 from rich.panel import Panel
 from rich.table import Table
 
+from ._storage import load_storage
+
+
+def _open_db(db_url: str):
+    create_storage, storage_config = load_storage()
+    return create_storage(storage_config(connection_string=db_url))
+
 
 class _State:
     def __init__(self):
@@ -48,9 +55,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 +119,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 +256,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 +397,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 +417,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 +450,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/demos/__init__.py

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

synth_ai/demos/core/__init__.py

@@ -1 +1,28 @@
-# Core demo CLI and helpers package
+"""
+Compatibility layer exposing the legacy demo helpers.
+
+Historically these utilities lived in ``synth_ai.demos.core`` as a module.
+Upstream refactors moved the implementation under
+``synth_ai.demos.demo_task_apps.core``.  Several call sites (including the new
+vision tests) still import the older path, so we re-export everything here.
+"""
+
+from __future__ import annotations
+
+from synth_ai.demos.demo_task_apps import core as _demo_core
+
+__all__ = [
+    name
+    for name in dir(_demo_core)
+    if not name.startswith("_")
+]
+
+globals().update({name: getattr(_demo_core, name) for name in __all__})
+
+
+def __getattr__(name: str):
+    if name in __all__:
+        value = getattr(_demo_core, name)
+        globals()[name] = value
+        return value
+    raise AttributeError(name)