synth-ai 0.2.8.dev11__py3-none-any.whl → 0.2.8.dev13__py3-none-any.whl

synth_ai/api/train/config_finder.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable
+
+import click
+
+from .utils import REPO_ROOT, load_toml, preview_json
+
+_SKIP_DIRS = {".git", "__pycache__", ".venv", "node_modules", "dist", "build"}
+
+
+@dataclass(slots=True)
+class ConfigCandidate:
+    path: Path
+    train_type: str  # "rl", "sft", or "unknown"
+
+
+def _iter_candidate_paths() -> Iterable[Path]:
+    # Prefer explicit config directories first
+    preferred = [
+        REPO_ROOT / "configs",
+        REPO_ROOT / "examples",
+        REPO_ROOT / "training",
+    ]
+    seen: set[Path] = set()
+    for base in preferred:
+        if not base.exists():
+            continue
+        for path in base.rglob("*.toml"):
+            if any(part in _SKIP_DIRS for part in path.parts):
+                continue
+            resolved = path.resolve()
+            if resolved in seen:
+                continue
+            seen.add(resolved)
+            yield resolved
+
+
+def _infer_config_type(data: dict) -> str:
+    if isinstance(data.get("training"), dict) or isinstance(data.get("hyperparameters"), dict):
+        return "sft"
+    if data.get("job_type") == "rl":
+        return "rl"
+    services = data.get("services")
+    if isinstance(services, dict) and ("task_url" in services or "environment" in services):
+        return "rl"
+    compute = data.get("compute")
+    if isinstance(compute, dict) and "gpu_type" in compute:
+        # typically FFT toml
+        return "sft"
+    return "unknown"
+
+
+def discover_configs(explicit: list[str], *, requested_type: str | None) -> list[ConfigCandidate]:
+    candidates: list[ConfigCandidate] = []
+    seen: set[Path] = set()
+
+    for raw in explicit:
+        path = Path(raw).expanduser().resolve()
+        if not path.exists():
+            raise click.ClickException(f"Config not found: {path}")
+        data = load_toml(path)
+        cfg_type = _infer_config_type(data)
+        candidates.append(ConfigCandidate(path=path, train_type=cfg_type))
+        seen.add(path)
+
+    if explicit:
+        return candidates
+
+    for path in _iter_candidate_paths():
+        if path in seen:
+            continue
+        try:
+            data = load_toml(path)
+        except Exception:
+            continue
+        cfg_type = _infer_config_type(data)
+        candidates.append(ConfigCandidate(path=path, train_type=cfg_type))
+
+    if requested_type and requested_type != "auto":
+        candidates = [c for c in candidates if c.train_type in {requested_type, "unknown"}]
+
+    # De-dupe by path and keep deterministic ordering by directory depth then name
+    candidates.sort(key=lambda c: (len(c.path.parts), str(c.path)))
+    return candidates
+
+
+def prompt_for_config(candidates: list[ConfigCandidate], *, requested_type: str | None) -> ConfigCandidate:
+    if not candidates:
+        raise click.ClickException("No training configs found. Pass --config explicitly.")
+
+    click.echo("Select a training config:")
+    for idx, cand in enumerate(candidates, start=1):
+        label = cand.train_type if cand.train_type != "unknown" else "?"
+        click.echo(f"  {idx}) [{label}] {cand.path}")
+    click.echo("  0) Abort")
+
+    choice = click.prompt("Enter choice", type=int)
+    if choice == 0:
+        raise click.ClickException("Aborted by user")
+    if choice < 0 or choice > len(candidates):
+        raise click.ClickException("Invalid selection")
+
+    selection = candidates[choice - 1]
+    try:
+        data = load_toml(selection.path)
+        preview = preview_json({k: data.get(k) for k in list(data.keys())[:4]}, limit=320)
+        click.echo(f"Loaded {selection.path}: {preview}")
+    except Exception:
+        pass
+    return selection
+
+
+__all__ = [
+    "ConfigCandidate",
+    "discover_configs",
+    "prompt_for_config",
+]

synth_ai/api/train/env_resolver.py

@@ -0,0 +1,302 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, Iterable, MutableMapping
+
+import click
+
+from . import task_app
+from .utils import REPO_ROOT, mask_value, read_env_file, write_env_value
+
+
+@dataclass(slots=True)
+class KeySpec:
+    name: str
+    description: str
+    secret: bool = True
+    allow_modal_secret: bool = False
+    allow_modal_app: bool = False
+    modal_secret_pattern: str | None = None
+    optional: bool = False
+
+
+class EnvResolver:
+    def __init__(self, initial_candidates: list[Path]) -> None:
+        if not initial_candidates:
+            raise click.ClickException("No .env candidates discovered")
+        self._candidates = initial_candidates
+        self._current = initial_candidates[0]
+        self._cache: MutableMapping[Path, dict[str, str]] = {}
+
+    @property
+    def current_path(self) -> Path:
+        return self._current
+
+    def select_new_env(self) -> None:
+        path = prompt_for_env(self._candidates, current=self._current)
+        self._current = path
+        if path not in self._candidates:
+            self._candidates.append(path)
+
+    def get_value(self, key: str) -> str | None:
+        cache = self._cache.get(self._current)
+        if cache is None:
+            cache = read_env_file(self._current)
+            self._cache[self._current] = cache
+        return cache.get(key)
+
+    def set_value(self, key: str, value: str) -> None:
+        cache = self._cache.setdefault(self._current, {})
+        cache[key] = value
+        write_env_value(self._current, key, value)
+
+
+def _collect_default_candidates(config_path: Path | None) -> list[Path]:
+    candidates: list[Path] = []
+    if config_path:
+        cfg_env = config_path.parent / ".env"
+        if cfg_env.exists():
+            candidates.append(cfg_env.resolve())
+    repo_env = REPO_ROOT / ".env"
+    if repo_env.exists():
+        candidates.append(repo_env.resolve())
+    examples_env = REPO_ROOT / "examples" / ".env"
+    if examples_env.exists():
+        candidates.append(examples_env.resolve())
+    # Search shallow depth for additional .env files
+    for sub in (REPO_ROOT / "examples").glob("**/.env"):
+        try:
+            resolved = sub.resolve()
+        except Exception:
+            continue
+        if resolved in candidates:
+            continue
+        # avoid nested venv caches
+        if any(part in {".venv", "node_modules", "__pycache__"} for part in resolved.parts):
+            continue
+        if len(candidates) >= 20:
+            break
+        candidates.append(resolved)
+    deduped: list[Path] = []
+    for path in candidates:
+        if path not in deduped:
+            deduped.append(path)
+    return deduped
+
+
+def prompt_for_env(candidates: list[Path], *, current: Path | None = None) -> Path:
+    options = list(dict.fromkeys(candidates))  # preserve order, dedupe
+    click.echo("Select an .env file:")
+    for idx, path in enumerate(options, start=1):
+        marker = " (current)" if current and path == current else ""
+        click.echo(f"  {idx}) {path}{marker}")
+    click.echo("  m) Enter path manually")
+    click.echo("  0) Abort")
+
+    choice = click.prompt("Choice", default=None)
+    if choice is None:
+        raise click.ClickException("Selection required")
+    choice = choice.strip().lower()
+    if choice == "0":
+        raise click.ClickException("Aborted by user")
+    if choice in {"m", "manual"}:
+        manual = click.prompt("Enter path to .env", type=str).strip()
+        path = Path(manual).expanduser().resolve()
+        if not path.exists():
+            raise click.ClickException(f"Env file not found: {path}")
+        return path
+    try:
+        idx = int(choice)
+    except ValueError as exc:
+        raise click.ClickException("Invalid selection") from exc
+    if idx < 1 or idx > len(options):
+        raise click.ClickException("Invalid selection")
+    return options[idx - 1]
+
+
+def resolve_env(
+    *,
+    config_path: Path | None,
+    explicit_env_paths: Iterable[str],
+    required_keys: list[KeySpec],
+) -> tuple[Path, dict[str, str]]:
+    provided = [Path(p).expanduser().resolve() for p in explicit_env_paths]
+    if provided:
+        for path in provided:
+            if not path.exists():
+                raise click.ClickException(f"Env file not found: {path}")
+        resolver = EnvResolver(provided)
+    else:
+        resolver = EnvResolver(_collect_default_candidates(config_path))
+        resolver.select_new_env()  # force user selection even if one candidate
+
+    # Preload selected .env keys into process env so downstream lookups succeed
+    try:
+        current_env_map = read_env_file(resolver.current_path)
+        for k in (
+            "SYNTH_API_KEY",
+            "ENVIRONMENT_API_KEY",
+            "dev_environment_api_key",
+            "DEV_ENVIRONMENT_API_KEY",
+            "TASK_APP_URL",
+            "TASK_APP_BASE_URL",
+        ):
+            v = current_env_map.get(k)
+            if v and not os.environ.get(k):
+                os.environ[k] = v
+    except Exception:
+        pass
+
+    resolved: dict[str, str] = {}
+    for spec in required_keys:
+        value = _resolve_key(resolver, spec)
+        if value:
+            resolved[spec.name] = value
+    return resolver.current_path, resolved
+
+
+def _resolve_key(resolver: EnvResolver, spec: KeySpec) -> str:
+    while True:
+        # Priority: existing environment variable
+        env_val = os.environ.get(spec.name) or resolver.get_value(spec.name)
+        # Allow common aliases in .env to satisfy required keys without extra prompts
+        if not env_val and spec.name == "ENVIRONMENT_API_KEY":
+            for alias in ("dev_environment_api_key", "DEV_ENVIRONMENT_API_KEY"):
+                alt = resolver.get_value(alias)
+                if alt:
+                    env_val = alt
+                    os.environ[spec.name] = alt
+                    click.echo(f"Found {spec.name} via {alias}: {mask_value(alt)}")
+                    break
+        if not env_val and spec.name == "TASK_APP_URL":
+            for alias in ("TASK_APP_BASE_URL",):
+                alt = resolver.get_value(alias)
+                if alt:
+                    env_val = alt
+                    os.environ[spec.name] = alt
+                    click.echo(f"Found {spec.name} via {alias}: {mask_value(alt)}")
+                    break
+        if env_val:
+            click.echo(f"Found {spec.name} in current sources: {mask_value(env_val)}")
+            if _prompt_yes_no(f"Use this value for {spec.name}?", default=True):
+                _maybe_persist(resolver, spec, env_val)
+                os.environ[spec.name] = env_val
+                return env_val
+        options: list[tuple[str, Callable[[], str | None]]] = []
+
+        def _enter_manual() -> str:
+            prompt = f"Enter {spec.description}" if spec.description else f"Enter {spec.name}"
+            value = click.prompt(prompt, hide_input=spec.secret).strip()
+            if not value:
+                raise click.ClickException(f"{spec.name} cannot be empty")
+            _maybe_persist(resolver, spec, value)
+            os.environ[spec.name] = value
+            return value
+
+        options.append(("Enter manually", _enter_manual))
+
+        def _pick_env() -> str | None:
+            resolver.select_new_env()
+            return None
+
+        options.append(("Choose another .env", _pick_env))
+
+        if spec.allow_modal_secret:
+            options.append(("Fetch from Modal secret", lambda: _fetch_modal_secret(resolver, spec)))
+        if spec.allow_modal_app:
+            options.append(("Choose Modal app URL", lambda: _fetch_modal_app(spec)))
+        if spec.optional:
+            options.append(("Skip", lambda: ""))
+        options.append(("Abort", lambda: (_raise_abort(spec))))
+
+        click.echo(f"Resolve {spec.name}:")
+        for idx, (label, _) in enumerate(options, start=1):
+            click.echo(f"  {idx}) {label}")
+        choice = click.prompt("Choice", type=int)
+        if choice < 1 or choice > len(options):
+            click.echo("Invalid selection; try again")
+            continue
+        action = options[choice - 1][1]
+        result = action()
+        if result is None:
+            # e.g. user switched env; restart loop
+            continue
+        return result
+
+
+def _maybe_persist(resolver: EnvResolver, spec: KeySpec, value: str) -> None:
+    if not _prompt_yes_no(f"Save {spec.name} to {resolver.current_path}?", default=True):
+        return
+    resolver.set_value(spec.name, value)
+    click.echo(f"Saved {spec.name} to {resolver.current_path}")
+
+
+def _prompt_yes_no(message: str, *, default: bool) -> bool:
+    """Prompt the user for a yes/no answer, accepting numeric variants."""
+
+    default_token = "y" if default else "n"
+    suffix = "[Y/n]" if default else "[y/N]"
+    while True:
+        response = click.prompt(f"{message} {suffix}", default=default_token, show_default=False)
+        normalized = str(response).strip().lower()
+        if normalized in {"", "y", "yes", "1", "true", "t"}:
+            return True
+        if normalized in {"n", "no", "0", "false", "f"}:
+            return False
+        click.echo("Invalid input; enter 'y' or 'n'.")
+
+
+def _fetch_modal_secret(resolver: EnvResolver, spec: KeySpec) -> str | None:
+    try:
+        names = task_app.list_modal_secrets(spec.modal_secret_pattern)
+    except click.ClickException as exc:
+        click.echo(str(exc))
+        return None
+    if not names:
+        click.echo("No Modal secrets matched")
+        return None
+    click.echo(task_app.format_modal_secrets(names))
+    idx = click.prompt("Select secret (0 to cancel)", type=int)
+    if idx == 0:
+        return None
+    if idx < 1 or idx > len(names):
+        click.echo("Invalid selection")
+        return None
+    name = names[idx - 1]
+    value = task_app.get_modal_secret_value(name)
+    _maybe_persist(resolver, spec, value)
+    os.environ[spec.name] = value
+    return value
+
+
+def _fetch_modal_app(spec: KeySpec) -> str | None:
+    try:
+        apps = task_app.list_modal_apps("task-app")
+    except click.ClickException as exc:
+        click.echo(str(exc))
+        return None
+    if not apps:
+        click.echo("No Modal apps matched")
+        return None
+    click.echo(task_app.format_modal_apps(apps))
+    idx = click.prompt("Select app (0 to cancel)", type=int)
+    if idx == 0:
+        return None
+    if idx < 1 or idx > len(apps):
+        click.echo("Invalid selection")
+        return None
+    url = apps[idx - 1].url
+    os.environ[spec.name] = url
+    return url
+
+
+def _raise_abort(spec: KeySpec) -> None:
+    raise click.ClickException(f"Missing required value for {spec.name}")
+
+
+__all__ = [
+    "KeySpec",
+    "resolve_env",
+]

synth_ai/api/train/pollers.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+import click
+
+from .utils import ensure_api_base, fmt_duration, http_get, sleep
+
+
+@dataclass(slots=True)
+class PollOutcome:
+    status: str
+    payload: Mapping[str, Any]
+
+
+class JobPoller:
+    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
+        self.timeout = timeout
+
+    def _headers(self) -> dict[str, str]:
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+    def poll(self, path: str) -> PollOutcome:
+        elapsed = 0.0
+        status = "unknown"
+        info: Mapping[str, Any] = {}
+        click.echo("Polling job status...")
+        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 {}
+                status = (info.get("status") or info.get("state") or "").lower()
+                click.echo(f"[poll] {elapsed:.0f}s status={status}")
+                if status in {"succeeded", "failed", "cancelled", "canceled", "completed"}:
+                    break
+            except Exception as exc:  # pragma: no cover - network failures
+                click.echo(f"[poll] error: {exc}")
+            sleep(self.interval)
+            elapsed += self.interval
+        else:
+            click.echo(f"[poll] timeout after {fmt_duration(self.timeout)}")
+        return PollOutcome(status=status, payload=info)
+
+
+class RLJobPoller(JobPoller):
+    def poll_job(self, job_id: str) -> PollOutcome:
+        return super().poll(f"/rl/jobs/{job_id}")
+
+
+class SFTJobPoller(JobPoller):
+    def poll_job(self, job_id: str) -> PollOutcome:
+        return super().poll(f"/learning/jobs/{job_id}")
+
+
+__all__ = [
+    "PollOutcome",
+    "RLJobPoller",
+    "SFTJobPoller",
+]

synth_ai/api/train/task_app.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Iterable
+
+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 check_task_app_health(base_url: str, api_key: str, *, timeout: float = 10.0) -> TaskAppHealth:
+    headers = {"X-API-Key": api_key}
+    base = base_url.rstrip("/")
+    health_resp = None
+    detail_parts: list[str] = []
+    try:
+        health_resp = http_get(f"{base}/health", headers=headers, timeout=timeout)
+        detail_parts.append(f"/health={health_resp.status_code}")
+    except requests.RequestException as exc:
+        detail_parts.append(f"/health_error={exc}")
+    task_resp = None
+    try:
+        task_resp = http_get(f"{base}/task_info", headers=headers, timeout=timeout)
+        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_resp and health_resp.status_code == 200 and task_resp and task_resp.status_code == 200)
+    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",
+]