synth-ai 0.2.9.dev7__py3-none-any.whl → 0.2.9.dev8__py3-none-any.whl

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

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]
 
@@ -139,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
 
@@ -105,3 +112,4 @@ 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["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"
 

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

@@ -101,7 +101,8 @@ 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)
 

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 = """

synth_ai/cli/rl_demo.py

@@ -37,7 +37,8 @@ def register(cli):
         """RL Demo commands (separate from legacy demo)."""
 
     # Help pyright understand dynamic Click group attributes
-    from typing import Any, cast as _cast
+    from typing import Any
+    from typing import cast as _cast
 
     _rlg = _cast(Any, rl_demo)
 

synth_ai/cli/root.py

@@ -5,6 +5,7 @@ Canonical CLI entrypoint for Synth AI (moved from synth_ai/cli.py).
 
 from __future__ import annotations
 
+import contextlib
 import logging
 import os
 import shutil
@@ -18,7 +19,8 @@ import time
 import click
 
 try:
-    from importlib.metadata import PackageNotFoundError, version as _pkg_version
+    from importlib.metadata import PackageNotFoundError
+    from importlib.metadata import version as _pkg_version
 
     try:
         __pkg_version__ = _pkg_version("synth-ai")
@@ -91,9 +93,8 @@ def install_sqld() -> str:
 
     click.echo("📥 Downloading sqld via 'turso dev' (this may take a few seconds)…")
 
-    temp_db = tempfile.NamedTemporaryFile(prefix="synth_sqld_", suffix=".db", delete=False)
-    temp_db_path = temp_db.name
-    temp_db.close()
+    with tempfile.NamedTemporaryFile(prefix="synth_sqld_", suffix=".db", delete=False) as temp_db:
+        temp_db_path = temp_db.name
 
     env = os.environ.copy()
     env.setdefault("TURSO_NONINTERACTIVE", "1")
@@ -129,15 +130,12 @@ def install_sqld() -> str:
                 proc.kill()
                 stdout_data, stderr_data = proc.communicate()
     finally:
-        if proc and proc.returncode not in (0, None):
-            if stdout_data or stderr_data:
-                logging.getLogger(__name__).debug(
-                    "turso dev stdout: %s\nstderr: %s", stdout_data, stderr_data
-                )
-        try:
+        if proc and proc.returncode not in (0, None) and (stdout_data or stderr_data):
+            logging.getLogger(__name__).debug(
+                "turso dev stdout: %s\nstderr: %s", stdout_data, stderr_data
+            )
+        with contextlib.suppress(OSError):
             os.unlink(temp_db_path)
-        except OSError:
-            pass
 
     sqld_path = find_sqld_binary()
     if sqld_path:
@@ -171,7 +169,7 @@ def _forward_to_demo(args: list[str]) -> None:
     except Exception as e:  # pragma: no cover
         click.echo(f"Failed to import demo CLI: {e}")
         sys.exit(1)
-    rc = int(getattr(demo_cli, "main")(args) or 0)  # type: ignore[attr-defined]
+    rc = int(demo_cli.main(args) or 0)  # type: ignore[attr-defined]
     if rc != 0:
         sys.exit(rc)
 

synth_ai/cli/status.py

@@ -14,9 +14,9 @@ from rich.table import Table
 
 
 async def _db_stats(db_url: str) -> dict:
-    from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
+    from synth_ai.tracing_v3.storage.factory import StorageConfig, create_storage
 
-    db = AsyncSQLTraceManager(db_url)
+    db = create_storage(StorageConfig(connection_string=db_url))
     await db.initialize()
     try:
         out: dict = {}