synth-ai 0.2.9.dev11__py3-none-any.whl → 0.4.1__py3-none-any.whl

synth_ai/api/train/supported_algos.py

@@ -1,139 +0,0 @@
-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,195 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Iterable
-from dataclasses import dataclass
-
-import click
-import requests
-
-from .utils import CLIResult, http_get, run_cli
-
-
-@dataclass(slots=True)
-class TaskAppHealth:
-    ok: bool
-    health_status: int | None
-    task_info_status: int | None
-    detail: str | None = None
-
-
-def _health_response_ok(resp: requests.Response | None) -> tuple[bool, str]:
-    if resp is None:
-        return False, ""
-    status = resp.status_code
-    if status == 200:
-        return True, ""
-    if status in {401, 403}:
-        try:
-            payload = resp.json()
-        except ValueError:
-            payload = {}
-        prefix = payload.get("expected_api_key_prefix")
-        detail = str(payload.get("detail", ""))
-        if prefix or "expected prefix" in detail.lower():
-            note = "auth-optional"
-            if prefix:
-                note += f" (expected-prefix={prefix})"
-            return True, note
-    return False, ""
-
-
-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]
-    if aliases:
-        keys.extend([p.strip() for p in aliases.split(",") if p.strip()])
-    if keys:
-        headers["X-API-Keys"] = ",".join(keys)
-        headers.setdefault("Authorization", f"Bearer {api_key}")
-    base = base_url.rstrip("/")
-    detail_parts: list[str] = []
-
-    health_resp: requests.Response | None = None
-    health_ok = False
-    try:
-        health_resp = http_get(f"{base}/health", headers=headers, timeout=timeout)
-        health_ok, note = _health_response_ok(health_resp)
-        suffix = f" ({note})" if note else ""
-        # On non-200, include brief JSON detail if present
-        if not health_ok and health_resp is not None:
-            try:
-                hjs = health_resp.json()
-                # pull a few helpful fields without dumping everything
-                expected = hjs.get("expected_api_key_prefix")
-                authorized = hjs.get("authorized")
-                detail = hjs.get("detail")
-                extras = []
-                if authorized is not None:
-                    extras.append(f"authorized={authorized}")
-                if expected:
-                    extras.append(f"expected_prefix={expected}")
-                if detail:
-                    extras.append(f"detail={str(detail)[:80]}")
-                if extras:
-                    suffix += " [" + ", ".join(extras) + "]"
-            except Exception:
-                pass
-        detail_parts.append(f"/health={health_resp.status_code}{suffix}")
-    except requests.RequestException as exc:
-        detail_parts.append(f"/health_error={exc}")
-
-    task_resp: requests.Response | None = None
-    task_ok = False
-    try:
-        task_resp = http_get(f"{base}/task_info", headers=headers, timeout=timeout)
-        task_ok = bool(task_resp.status_code == 200)
-        if not task_ok and task_resp is not None:
-            try:
-                tjs = task_resp.json()
-                msg = tjs.get("detail") or tjs.get("status")
-                detail_parts.append(f"/task_info={task_resp.status_code} ({str(msg)[:80]})")
-            except Exception:
-                detail_parts.append(f"/task_info={task_resp.status_code}")
-        else:
-            detail_parts.append(f"/task_info={task_resp.status_code}")
-    except requests.RequestException as exc:
-        detail_parts.append(f"/task_info_error={exc}")
-
-    ok = bool(health_ok and task_ok)
-    detail = ", ".join(detail_parts)
-    return TaskAppHealth(
-        ok=ok,
-        health_status=None if health_resp is None else health_resp.status_code,
-        task_info_status=None if task_resp is None else task_resp.status_code,
-        detail=detail,
-    )
-
-
-@dataclass(slots=True)
-class ModalSecret:
-    name: str
-    value: str
-
-
-@dataclass(slots=True)
-class ModalApp:
-    app_id: str
-    label: str
-    url: str
-
-
-def _run_modal(args: Iterable[str]) -> CLIResult:
-    return run_cli(["modal", *args], timeout=30.0)
-
-
-def list_modal_secrets(pattern: str | None = None) -> list[str]:
-    result = _run_modal(["secret", "list"])
-    if result.code != 0:
-        raise click.ClickException(f"modal secret list failed: {result.stderr or result.stdout}")
-    names: list[str] = []
-    for line in result.stdout.splitlines():
-        line = line.strip()
-        if not line or line.startswith("NAME"):
-            continue
-        parts = line.split()
-        name = parts[0]
-        if pattern and pattern.lower() not in name.lower():
-            continue
-        names.append(name)
-    return names
-
-
-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}"
-        )
-    value = result.stdout.strip()
-    if not value:
-        raise click.ClickException(f"Secret {name} is empty")
-    return value
-
-
-def list_modal_apps(pattern: str | None = None) -> list[ModalApp]:
-    result = _run_modal(["app", "list"])
-    if result.code != 0:
-        raise click.ClickException(f"modal app list failed: {result.stderr or result.stdout}")
-    apps: list[ModalApp] = []
-    for line in result.stdout.splitlines():
-        line = line.strip()
-        if not line or line.startswith("APP"):
-            continue
-        parts = line.split()
-        if len(parts) < 3:
-            continue
-        app_id, label, url = parts[0], parts[1], parts[-1]
-        if pattern and pattern.lower() not in (label.lower() + url.lower() + app_id.lower()):
-            continue
-        apps.append(ModalApp(app_id=app_id, label=label, url=url))
-    return apps
-
-
-def format_modal_apps(apps: list[ModalApp]) -> str:
-    rows = [f"{idx}) {app.label} {app.url}" for idx, app in enumerate(apps, start=1)]
-    return "\n".join(rows)
-
-
-def format_modal_secrets(names: list[str]) -> str:
-    return "\n".join(f"{idx}) {name}" for idx, name in enumerate(names, start=1))
-
-
-__all__ = [
-    "ModalApp",
-    "ModalSecret",
-    "check_task_app_health",
-    "format_modal_apps",
-    "format_modal_secrets",
-    "get_modal_secret_value",
-    "list_modal_apps",
-    "list_modal_secrets",
-]

synth_ai/api/train/utils.py

@@ -1,217 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-import re
-import subprocess
-import tempfile
-import time
-import tomllib
-from collections.abc import Iterable, Mapping
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any
-
-import requests
-from synth_ai.learning.sft import collect_sft_jsonl_errors
-
-REPO_ROOT = Path(__file__).resolve().parents[3]
-
-
-class TrainError(RuntimeError):
-    """Raised for interactive CLI failures."""
-
-
-def load_toml(path: Path) -> dict[str, Any]:
-    try:
-        with path.open("rb") as fh:
-            return tomllib.load(fh)
-    except FileNotFoundError as exc:  # pragma: no cover - guarded by CLI
-        raise TrainError(f"Config not found: {path}") from exc
-    except tomllib.TOMLDecodeError as exc:  # pragma: no cover - malformed input
-        raise TrainError(f"Failed to parse TOML: {path}\n{exc}") from exc
-
-
-def mask_value(value: str | None) -> str:
-    if not value:
-        return "<unset>"
-    value = str(value)
-    if len(value) <= 6:
-        return "****"
-    return f"{value[:4]}…{value[-2:]}"
-
-
-_ENV_LINE = re.compile(r"^\s*(?:export\s+)?(?P<key>[A-Za-z0-9_]+)\s*=\s*(?P<value>.*)$")
-
-
-def read_env_file(path: Path) -> dict[str, str]:
-    if not path.exists():
-        return {}
-    data: dict[str, str] = {}
-    for line in path.read_text(encoding="utf-8", errors="ignore").splitlines():
-        m = _ENV_LINE.match(line)
-        if not m:
-            continue
-        raw = m.group("value").strip()
-        if raw and raw[0] == raw[-1] and raw[0] in {'"', "'"} and len(raw) >= 2:
-            raw = raw[1:-1]
-        data[m.group("key")] = raw
-    return data
-
-
-def write_env_value(path: Path, key: str, value: str) -> None:
-    existing = []
-    if path.exists():
-        existing = path.read_text(encoding="utf-8", errors="ignore").splitlines()
-    updated = False
-    new_lines: list[str] = []
-    for line in existing:
-        m = _ENV_LINE.match(line)
-        if m and m.group("key") == key:
-            new_lines.append(f"{key}={value}")
-            updated = True
-        else:
-            new_lines.append(line)
-    if not updated:
-        new_lines.append(f"{key}={value}")
-    path.write_text("\n".join(new_lines) + "\n", encoding="utf-8")
-
-
-@dataclass(slots=True)
-class CLIResult:
-    code: int
-    stdout: str
-    stderr: str
-
-
-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,
-        env=dict(os.environ, **(env or {})),
-        capture_output=True,
-        text=True,
-        timeout=timeout,
-    )
-    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:
-    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:
-    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:
-    headers = {"Authorization": f"Bearer {api_key}"}
-    files = {file_field: (file_path.name, file_path.read_bytes(), "application/jsonl")}
-    data = {"purpose": purpose}
-    return requests.post(url, headers=headers, files=files, data=data, timeout=300)
-
-
-def fmt_duration(seconds: float) -> str:
-    if seconds < 60:
-        return f"{seconds:.1f}s"
-    minutes, secs = divmod(seconds, 60)
-    if minutes < 60:
-        return f"{int(minutes)}m{int(secs):02d}s"
-    hours, mins = divmod(minutes, 60)
-    return f"{int(hours)}h{int(mins):02d}m"
-
-
-def validate_sft_jsonl(path: Path, *, max_errors: int = 20) -> None:
-    if not path.exists():
-        raise TrainError(f"Dataset not found: {path}")
-
-    issues = collect_sft_jsonl_errors(path, min_messages=1, max_errors=max_errors)
-    if not issues:
-        return
-
-    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:
-    if limit <= 0:
-        raise TrainError("Example limit must be positive")
-    if not src.exists():
-        raise TrainError(f"Dataset not found: {src}")
-
-    tmp_dir = Path(tempfile.mkdtemp(prefix="sft_subset_"))
-    dest = tmp_dir / f"{src.stem}.head{limit}{src.suffix}"
-
-    written = 0
-    with src.open("r", encoding="utf-8") as fin, dest.open("w", encoding="utf-8") as fout:
-        for line in fin:
-            if not line.strip():
-                continue
-            fout.write(line)
-            written += 1
-            if written >= limit:
-                break
-
-    if written == 0:
-        raise TrainError("Subset dataset is empty; check limit value")
-
-    return dest
-
-
-def ensure_api_base(base: str) -> str:
-    base = base.rstrip("/")
-    if not base.endswith("/api"):
-        base = f"{base}/api"
-    return base
-
-
-def preview_json(data: Any, limit: int = 600) -> str:
-    try:
-        return json.dumps(data, indent=2)[:limit]
-    except Exception:
-        return str(data)[:limit]
-
-
-def sleep(seconds: float) -> None:
-    time.sleep(seconds)
-
-
-__all__ = [
-    "CLIResult",
-    "REPO_ROOT",
-    "TrainError",
-    "ensure_api_base",
-    "fmt_duration",
-    "http_get",
-    "http_post",
-    "load_toml",
-    "mask_value",
-    "post_multipart",
-    "preview_json",
-    "read_env_file",
-    "run_cli",
-    "sleep",
-    "limit_jsonl_examples",
-    "validate_sft_jsonl",
-    "write_env_value",
-]

synth_ai/cli/_modal_wrapper.py

@@ -1,28 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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]