synth-ai 0.2.9.dev5__py3-none-any.whl → 0.2.9.dev6__py3-none-any.whl

synth_ai/api/train/pollers.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
+from collections.abc import Mapping
 from dataclasses import dataclass
-from typing import Any, Mapping
+from datetime import datetime
+from typing import Any
 
 import click
 
@@ -15,7 +17,9 @@ class PollOutcome:
 
 
 class JobPoller:
-    def __init__(self, base_url: str, api_key: str, *, interval: float = 5.0, timeout: float = 3600.0) -> None:
+    def __init__(
+        self, base_url: str, api_key: str, *, interval: float = 5.0, timeout: float = 3600.0
+    ) -> None:
         self.base_url = ensure_api_base(base_url)
         self.api_key = api_key
         self.interval = interval
@@ -35,9 +39,14 @@ class JobPoller:
         while elapsed <= self.timeout:
             try:
                 resp = http_get(f"{self.base_url}{path}", headers=self._headers())
-                info = resp.json() if resp.headers.get("content-type", "").startswith("application/json") else {}
+                info = (
+                    resp.json()
+                    if resp.headers.get("content-type", "").startswith("application/json")
+                    else {}
+                )
                 status = (info.get("status") or info.get("state") or "").lower()
-                click.echo(f"[poll] {elapsed:.0f}s status={status}")
+                timestamp = datetime.now().strftime("%H:%M:%S")
+                click.echo(f"[poll] {timestamp} {elapsed:.0f}s status={status}")
                 if status in {"succeeded", "failed", "cancelled", "canceled", "completed"}:
                     break
             except Exception as exc:  # pragma: no cover - network failures

synth_ai/api/train/supported_algos.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+
+from synth_ai.api.models.supported import (
+    RL_SUPPORTED_MODELS,
+    SFT_SUPPORTED_MODELS,
+    training_modes_for_model,
+)
+
+
+@dataclass(frozen=True)
+class AlgorithmSpec:
+    algo_type: str
+    method: str
+    variety: str
+    label: str  # Human readable identifier (e.g. "RL / GSPO")
+    required_training_mode: str  # Expected training mode on the model record (e.g. "rl", "sft")
+
+
+def _normalize(value: object) -> str:
+    if value is None:
+        return ""
+    return str(value).strip().lower()
+
+RL_ALGORITHM_MODEL_IDS: tuple[str, ...] = tuple(sorted(RL_SUPPORTED_MODELS))
+RL_ALGORITHM_MODEL_SET: frozenset[str] = frozenset(RL_ALGORITHM_MODEL_IDS)
+
+SFT_ALGORITHM_MODEL_IDS: tuple[str, ...] = tuple(sorted(SFT_SUPPORTED_MODELS))
+SFT_ALGORITHM_MODEL_SET: frozenset[str] = frozenset(SFT_ALGORITHM_MODEL_IDS)
+
+
+SUPPORTED_ALGORITHMS: tuple[AlgorithmSpec, ...] = (
+    AlgorithmSpec(
+        "online", "policy_gradient", "gspo", "online policy_gradient / gspo", "rl"
+    ),
+    AlgorithmSpec(
+        "offline", "supervised_finetune", "fft", "offline supervised_finetune / fft", "sft"
+    ),
+    AlgorithmSpec("offline", "sft", "fft", "offline sft / fft", "sft"),
+    # Accept explicit LoRA variety for SFT as a first-class alias of FFT SFT.
+    # This allows configs to declare intent with variety="lora" while still
+    # using SFT training mode; actual adapter selection is driven by [training].
+    AlgorithmSpec("offline", "sft", "lora", "offline sft / lora", "sft"),
+)
+
+_SUPPORTED_LOOKUP = {
+    (spec.algo_type, spec.method, spec.variety): spec for spec in SUPPORTED_ALGORITHMS
+}
+
+
+class AlgorithmValidationError(ValueError):
+    """Raised when an algorithm block contains unsupported combinations."""
+
+
+def validate_algorithm_config(
+    algorithm_block: Mapping[str, object] | None,
+    *,
+    expected_family: str | None = None,
+) -> AlgorithmSpec:
+    """Validate the [algorithm] section of a training config.
+
+    Args:
+        algorithm_block: Parsed mapping from the TOML config.
+        expected_family: Optional expected family label ("rl" or "sft").
+
+    Returns:
+        The matched AlgorithmSpec describing the supported combination.
+
+    Raises:
+        AlgorithmValidationError: if the combination is missing or unsupported.
+    """
+
+    if algorithm_block is None:
+        raise AlgorithmValidationError("Missing required [algorithm] section in config.")
+    if not isinstance(algorithm_block, Mapping):
+        raise AlgorithmValidationError("[algorithm] section must be a mapping/object.")
+
+    algo_type = _normalize(algorithm_block.get("type"))
+    method = _normalize(algorithm_block.get("method"))
+    variety = _normalize(algorithm_block.get("variety"))
+
+    key = (algo_type, method, variety)
+    spec = _SUPPORTED_LOOKUP.get(key)
+    if spec is None:
+        supported = "; ".join(
+            f"type='{entry.algo_type}', method='{entry.method}', variety='{entry.variety}'"
+            for entry in SUPPORTED_ALGORITHMS
+        )
+        raise AlgorithmValidationError(
+            "Unsupported algorithm configuration:\n"
+            f"  type={algo_type!r}, method={method!r}, variety={variety!r}\n"
+            f"Supported combinations are: {supported}"
+        )
+
+    if expected_family:
+        expected_family = expected_family.lower()
+        family_map = {
+            ("online", "policy_gradient", "gspo"): "rl",
+            ("offline", "supervised_finetune", "fft"): "sft",
+            ("offline", "sft", "fft"): "sft",
+            ("offline", "sft", "lora"): "sft",
+        }
+        family = family_map.get(key)
+        if family != expected_family:
+            raise AlgorithmValidationError(
+                f"Config contains algorithm {spec.label!r}, "
+                f"but the current command expects {expected_family.upper()}."
+            )
+
+    return spec
+
+
+def ensure_model_supported_for_algorithm(model_id: str, spec: AlgorithmSpec) -> None:
+    """Ensure that the given model supports the training mode required by *spec*."""
+
+    modes = {mode.lower() for mode in training_modes_for_model(model_id)}
+    required = spec.required_training_mode.lower()
+    if required not in modes:
+        if required == "rl":
+            allowed = ", ".join(RL_ALGORITHM_MODEL_IDS)
+        else:
+            allowed = ", ".join(SFT_ALGORITHM_MODEL_IDS)
+        raise AlgorithmValidationError(
+            f"Model '{model_id}' does not support {spec.label} workloads "
+            f"(missing training mode '{required}'). Supported model IDs: {allowed}"
+        )
+
+
+__all__ = [
+    "AlgorithmSpec",
+    "AlgorithmValidationError",
+    "RL_ALGORITHM_MODEL_IDS",
+    "SFT_ALGORITHM_MODEL_IDS",
+    "SUPPORTED_ALGORITHMS",
+    "validate_algorithm_config",
+    "ensure_model_supported_for_algorithm",
+]

synth_ai/api/train/task_app.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
 
-import json
+from collections.abc import Iterable
 from dataclasses import dataclass
-from typing import Iterable
 
 import click
 import requests
@@ -42,6 +41,7 @@ def _health_response_ok(resp: requests.Response | None) -> tuple[bool, str]:
 def check_task_app_health(base_url: str, api_key: str, *, timeout: float = 10.0) -> TaskAppHealth:
     # Send ALL known environment keys so the server can authorize any valid one
     import os
+
     headers = {"X-API-Key": api_key}
     aliases = (os.getenv("ENVIRONMENT_API_KEY_ALIASES") or "").strip()
     keys: list[str] = [api_key]
@@ -146,7 +146,9 @@ def list_modal_secrets(pattern: str | None = None) -> list[str]:
 def get_modal_secret_value(name: str) -> str:
     result = _run_modal(["secret", "get", name])
     if result.code != 0:
-        raise click.ClickException(f"modal secret get {name} failed: {result.stderr or result.stdout}")
+        raise click.ClickException(
+            f"modal secret get {name} failed: {result.stderr or result.stdout}"
+        )
     value = result.stdout.strip()
     if not value:
         raise click.ClickException(f"Secret {name} is empty")

synth_ai/api/train/utils.py

@@ -4,15 +4,16 @@ import json
 import os
 import re
 import subprocess
-import sys
 import tempfile
 import time
+import tomllib
+from collections.abc import Iterable, Mapping
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Iterable, Mapping
+from typing import Any
 
 import requests
-import tomllib
+from synth_ai.learning.sft import collect_sft_jsonl_errors
 
 REPO_ROOT = Path(__file__).resolve().parents[3]
 
@@ -83,7 +84,13 @@ class CLIResult:
     stderr: str
 
 
-def run_cli(args: Iterable[str], *, cwd: Path | None = None, env: Mapping[str, str] | None = None, timeout: float | None = None) -> CLIResult:
+def run_cli(
+    args: Iterable[str],
+    *,
+    cwd: Path | None = None,
+    env: Mapping[str, str] | None = None,
+    timeout: float | None = None,
+) -> CLIResult:
     proc = subprocess.run(
         list(args),
         cwd=cwd,
@@ -95,17 +102,27 @@ def run_cli(args: Iterable[str], *, cwd: Path | None = None, env: Mapping[str, s
     return CLIResult(code=proc.returncode, stdout=proc.stdout.strip(), stderr=proc.stderr.strip())
 
 
-def http_post(url: str, *, headers: Mapping[str, str] | None = None, json_body: Any | None = None, timeout: float = 60.0) -> requests.Response:
+def http_post(
+    url: str,
+    *,
+    headers: Mapping[str, str] | None = None,
+    json_body: Any | None = None,
+    timeout: float = 60.0,
+) -> requests.Response:
     resp = requests.post(url, headers=dict(headers or {}), json=json_body, timeout=timeout)
     return resp
 
 
-def http_get(url: str, *, headers: Mapping[str, str] | None = None, timeout: float = 30.0) -> requests.Response:
+def http_get(
+    url: str, *, headers: Mapping[str, str] | None = None, timeout: float = 30.0
+) -> requests.Response:
     resp = requests.get(url, headers=dict(headers or {}), timeout=timeout)
     return resp
 
 
-def post_multipart(url: str, *, api_key: str, file_field: str, file_path: Path, purpose: str = "fine-tune") -> requests.Response:
+def post_multipart(
+    url: str, *, api_key: str, file_field: str, file_path: Path, purpose: str = "fine-tune"
+) -> requests.Response:
     headers = {"Authorization": f"Bearer {api_key}"}
     files = {file_field: (file_path.name, file_path.read_bytes(), "application/jsonl")}
     data = {"purpose": purpose}
@@ -123,49 +140,17 @@ def fmt_duration(seconds: float) -> str:
 
 
 def validate_sft_jsonl(path: Path, *, max_errors: int = 20) -> None:
-    errors: list[str] = []
-    try:
-        fh = path.open("r", encoding="utf-8")
-    except FileNotFoundError as exc:  # pragma: no cover - upstream ensures existence
-        raise TrainError(f"Dataset not found: {path}") from exc
-
-    with fh:
-        for idx, line in enumerate(fh, start=1):
-            stripped = line.strip()
-            if not stripped:
-                continue
-            try:
-                record = json.loads(stripped)
-            except json.JSONDecodeError as exc:
-                errors.append(f"Line {idx}: invalid JSON ({exc.msg})")
-                if len(errors) >= max_errors:
-                    break
-                continue
-
-            messages = record.get("messages")
-            if not isinstance(messages, list) or not messages:
-                errors.append(f"Line {idx}: missing or empty 'messages' list")
-                if len(errors) >= max_errors:
-                    break
-                continue
+    if not path.exists():
+        raise TrainError(f"Dataset not found: {path}")
 
-            for msg_idx, msg in enumerate(messages):
-                if not isinstance(msg, dict):
-                    errors.append(f"Line {idx}: message {msg_idx} is not an object")
-                    break
-                if "role" not in msg or "content" not in msg:
-                    errors.append(f"Line {idx}: message {msg_idx} missing 'role' or 'content'")
-                    break
-                if not isinstance(msg["role"], str) or not isinstance(msg["content"], str):
-                    errors.append(f"Line {idx}: message {msg_idx} has non-string role/content")
-                    break
-            if len(errors) >= max_errors:
-                break
+    issues = collect_sft_jsonl_errors(path, min_messages=1, max_errors=max_errors)
+    if not issues:
+        return
 
-    if errors:
-        suffix = "" if len(errors) < max_errors else f" (showing first {max_errors} issues)"
-        details = "\n - ".join(errors)
-        raise TrainError(f"Dataset validation failed{suffix}:\n - {details}")
+    truncated = max_errors is not None and len(issues) >= max_errors
+    suffix = "" if not truncated else f" (showing first {max_errors} issues)"
+    details = "\n - ".join(issues)
+    raise TrainError(f"{path}: Dataset validation failed{suffix}:\n - {details}")
 
 
 def limit_jsonl_examples(src: Path, limit: int) -> Path:

synth_ai/cli/__init__.py

@@ -17,6 +17,13 @@ except Exception:
     # dotenv is optional at runtime; proceed if unavailable
     pass
 
+try:
+    from ._typer_patch import patch_typer_make_metavar
+
+    patch_typer_make_metavar()
+except Exception:
+    pass
+
 
 from .root import cli  # new canonical CLI entrypoint
 
@@ -69,6 +76,12 @@ try:
     _demo.register(cli)
 except Exception:
     pass
+try:
+    from . import turso as _turso
+
+    _turso.register(cli)
+except Exception:
+    pass
 try:
     from . import rl_demo as _rl_demo
 
@@ -83,18 +96,20 @@ except Exception:
     pass
 
 
-
 from .task_apps import task_app_group
+
 cli.add_command(task_app_group, name="task-app")
 
 
 try:
     from . import task_apps as _task_apps
+
     _task_apps.register(cli)
 except Exception:
     pass
 
-cli.add_command(task_app_group.commands['serve'], name='serve')
-cli.add_command(task_app_group.commands['deploy'], name='deploy')
+cli.add_command(task_app_group.commands["serve"], name="serve")
+cli.add_command(task_app_group.commands["deploy"], name="deploy")
 
-cli.add_command(task_app_group.commands['modal-serve'], name='modal-serve')
+cli.add_command(task_app_group.commands["modal-serve"], name="modal-serve")
+cli.add_command(task_app_group.commands["info"], name="info")

synth_ai/cli/_modal_wrapper.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import sys
+
+
+def main() -> int:
+    # Apply Typer compatibility patch before Modal CLI bootstraps Click/Typer internals.
+    try:
+        from ._typer_patch import patch_typer_make_metavar
+
+        patch_typer_make_metavar()
+    except Exception:
+        pass
+
+    from modal.__main__ import main as modal_main
+
+    # Present ourselves as the upstream `modal` CLI so Typer/Click parsing stays intact.
+    if sys.argv:
+        sys.argv[0] = "modal"
+    else:
+        sys.argv = ["modal"]
+
+    return modal_main()
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+

synth_ai/cli/_typer_patch.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from click import Parameter
+
+
+def patch_typer_make_metavar() -> None:
+    try:
+        from typer.main import TyperArgument, TyperOption
+    except Exception:
+        return
+
+    def _call_get_metavar(param_type: object, param: Parameter) -> str | None:
+        getter = getattr(param_type, "get_metavar", None)
+        if getter is None:
+            return None
+        try:
+            return getter(param)
+        except TypeError:
+            try:
+                return getter(param, None)
+            except TypeError:
+                return None
+
+    def _patched_argument_make_metavar(self, ctx=None) -> str:
+        if self.metavar is not None:
+            return self.metavar
+        var = (self.name or "").upper()
+        if not self.required:
+            var = f"[{var}]"
+        type_var = _call_get_metavar(self.type, self)
+        if type_var:
+            var += f":{type_var}"
+        if self.nargs != 1:
+            var += "..."
+        return var
+
+    def _patched_option_make_metavar(self, ctx=None) -> str:
+        if self.metavar is not None:
+            return self.metavar
+        metavar = _call_get_metavar(self.type, self)
+        if not metavar:
+            name = getattr(self.type, "name", "") or ""
+            metavar = name.upper()
+        if self.nargs != 1:
+            metavar += "..."
+        return metavar
+
+    TyperArgument.make_metavar = _patched_argument_make_metavar  # type: ignore[assignment]
+    TyperOption.make_metavar = _patched_option_make_metavar  # type: ignore[assignment]

synth_ai/cli/balance.py

@@ -6,7 +6,6 @@ CLI: check remaining credit balance from Synth backend.
 from __future__ import annotations
 
 import os
-from urllib.parse import urlparse
 
 import click
 import requests
@@ -15,7 +14,7 @@ from rich import box
 from rich.console import Console
 from rich.table import Table
 
-from synth_ai.config.base_url import get_backend_from_env, PROD_BASE_URL_DEFAULT
+from synth_ai.config.base_url import PROD_BASE_URL_DEFAULT, get_backend_from_env
 
 PROD_BACKEND_BASE = f"{PROD_BASE_URL_DEFAULT.rstrip('/')}/api/v1"
 
@@ -29,7 +28,7 @@ def _get_default_base_url() -> str:
     base, _ = get_backend_from_env()
     base = base.rstrip("/")
     if base.endswith("/api"):
-        base = base[:-len("/api")]
+        base = base[: -len("/api")]
     return f"{base}/api/v1"
 
 

synth_ai/cli/calc.py

@@ -30,7 +30,7 @@ def _safe_eval(expr: str) -> float:
     def _eval(n):
         if isinstance(n, ast.Expression):
             return _eval(n.body)
-        if isinstance(n, ast.Num):  # 3.8 and earlier
+        if hasattr(ast, "Num") and isinstance(n, ast.Num):  # 3.8 and earlier
             return n.n
         if isinstance(n, ast.Constant):  # 3.8+
             if isinstance(n.value, int | float):

synth_ai/cli/demo.py

@@ -23,6 +23,7 @@ def _find_demo_scripts(root: Path) -> list[Path]:
 
 def _forward_to_new(args: list[str]) -> None:
     import sys
+
     try:
         from synth_ai.demos.core import cli as demo_cli  # type: ignore
     except Exception as e:  # pragma: no cover
@@ -35,7 +36,9 @@ def _forward_to_new(args: list[str]) -> None:
 
 def register(cli):
     @cli.group("demo", invoke_without_command=True)
-    @click.option("--force", is_flag=True, help="Overwrite existing files in CWD when initializing demo")
+    @click.option(
+        "--force", is_flag=True, help="Overwrite existing files in CWD when initializing demo"
+    )
     @click.option("--list", "list_only", is_flag=True, help="List available legacy demos and exit")
     @click.option("-f", "filter_term", default="", help="Filter legacy demos by substring")
     @click.pass_context
@@ -98,14 +101,26 @@ def register(cli):
     # (prepare command removed; configure now prepares baseline TOML)
 
     # Help pyright understand dynamic Click group attributes
-    from typing import Any, cast as _cast
+    from typing import Any
+    from typing import cast as _cast
+
     _dg = _cast(Any, demo)
 
     @_dg.command("deploy")
     @click.option("--local", is_flag=True, help="Run local FastAPI instead of Modal deploy")
-    @click.option("--app", type=click.Path(), default=None, help="Path to Modal app.py for uv run modal deploy")
+    @click.option(
+        "--app",
+        type=click.Path(),
+        default=None,
+        help="Path to Modal app.py for uv run modal deploy",
+    )
     @click.option("--name", type=str, default="synth-math-demo", help="Modal app name")
-    @click.option("--script", type=click.Path(), default=None, help="Path to deploy_task_app.sh (optional legacy)")
+    @click.option(
+        "--script",
+        type=click.Path(),
+        default=None,
+        help="Path to deploy_task_app.sh (optional legacy)",
+    )
     def demo_deploy(local: bool, app: str | None, name: str, script: str | None):
         args: list[str] = ["rl_demo.deploy"]
         if local:
@@ -120,11 +135,11 @@ def register(cli):
 
     @_dg.command("configure")
     def demo_configure():
-        _forward_to_new(["rl_demo.configure"]) 
+        _forward_to_new(["rl_demo.configure"])
 
     @_dg.command("setup")
     def demo_setup():
-        _forward_to_new(["rl_demo.setup"]) 
+        _forward_to_new(["rl_demo.setup"])
 
     @_dg.command("run")
     @click.option("--batch-size", type=int, default=None)

synth_ai/cli/recent.py

@@ -34,11 +34,11 @@ def _fmt_time(v) -> str:
 
 
 async def _fetch_recent(db_url: str, hours: float):
-    from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
+from synth_ai.tracing_v3.storage.factory import create_storage, StorageConfig
 
     start_time = datetime.now() - timedelta(hours=hours)
 
-    db = AsyncSQLTraceManager(db_url)
+    db = create_storage(StorageConfig(connection_string=db_url))
     await db.initialize()
     try:
         query = """