synth-ai 0.2.12__py3-none-any.whl → 0.2.13.dev2__py3-none-any.whl

synth_ai/api/train/configs/rl.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+from pydantic import model_validator
+
+from ..utils import load_toml
+from .shared import AlgorithmConfig, ComputeConfig, ExtraModel
+
+
+class RLServicesConfig(ExtraModel):
+    task_url: str
+    judge_url: str | None = None
+
+
+class ModelConfig(ExtraModel):
+    source: str | None = None
+    base: str | None = None
+    trainer_mode: str
+    label: str
+
+    @model_validator(mode="after")
+    def _ensure_exactly_one_source_or_base(self) -> ModelConfig:
+        if bool(self.source) == bool(self.base):
+            raise ValueError("Config must set exactly one of [model].source or [model].base")
+        return self
+
+
+class RolloutConfig(ExtraModel):
+    env_name: str
+    policy_name: str
+    env_config: dict[str, Any] | None = None
+    policy_config: dict[str, Any] | None = None
+    max_turns: int
+    episodes_per_batch: int
+    max_concurrent_rollouts: int
+    batches_per_step: int | None = None
+    ops: list[str] | None = None
+
+
+class WeightSyncConfig(ExtraModel):
+    enable: bool | None = None
+    targets: list[str] | None = None
+    mode: str | None = None
+    direct: bool | None = None
+    verify_every_k: int | None = None
+
+
+class RLTrainingConfig(ExtraModel):
+    num_epochs: int
+    iterations_per_epoch: int
+    gradient_accumulation_steps: int | None = None
+    max_accumulated_minibatch: int | None = None
+    max_turns: int
+    batch_size: int
+    group_size: int
+    learning_rate: float
+    log_interval: int | None = None
+    weight_sync_interval: int | None = None
+    step_rewards_enabled: bool | None = None
+    step_rewards_mode: str | None = None
+    step_rewards_indicator_lambda: float | None = None
+    step_rewards_beta: float | None = None
+    step_rewards_strategy: str | None = None
+    event_rewards_kind: str | None = None
+    weight_sync: WeightSyncConfig | None = None
+
+
+class EvaluationConfig(ExtraModel):
+    instances: int
+    every_n_iters: int
+    seeds: list[int]
+
+
+class JudgeOptionsConfig(ExtraModel):
+    event: bool | None = None
+    outcome: bool | None = None
+    provider: str | None = None
+    model: str | None = None
+    rubric_id: str | None = None
+    rubric_overrides: dict[str, Any] | None = None
+    tracks: list[str] | None = None
+    weights: dict[str, float] | None = None
+    max_concurrency: int | None = None
+
+
+class JudgeConfig(ExtraModel):
+    type: str | None = None
+    timeout_s: int | None = None
+    options: JudgeOptionsConfig | None = None
+
+
+class RLConfig(ExtraModel):
+    algorithm: AlgorithmConfig
+    services: RLServicesConfig
+    compute: ComputeConfig | None = None
+    topology: dict[str, Any] | None = None
+    vllm: dict[str, Any] | None = None
+    reference: dict[str, Any] | None = None
+    model: ModelConfig
+    lora: dict[str, Any] | None = None
+    rollout: RolloutConfig | None = None
+    evaluation: EvaluationConfig | None = None
+    training: RLTrainingConfig | None = None
+    rubric: dict[str, Any] | None = None
+    judge: JudgeConfig | None = None
+    tags: dict[str, Any] | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return self.model_dump(mode="python", exclude_none=True)
+
+    @classmethod
+    def from_mapping(cls, data: Mapping[str, Any]) -> RLConfig:
+        return cls.model_validate(dict(data))
+
+    @classmethod
+    def from_path(cls, path: Path) -> RLConfig:
+        content = load_toml(path)
+        return cls.from_mapping(content)
+
+
+__all__ = [
+    "EvaluationConfig",
+    "JudgeConfig",
+    "JudgeOptionsConfig",
+    "ModelConfig",
+    "RLConfig",
+    "RLServicesConfig",
+    "RLTrainingConfig",
+    "RolloutConfig",
+    "WeightSyncConfig",
+]

synth_ai/api/train/configs/sft.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+from pydantic import Field
+
+from ..utils import load_toml
+from .shared import AlgorithmConfig, ComputeConfig, ExtraModel
+
+
+class JobConfig(ExtraModel):
+    model: str
+    data: str | None = None
+    data_path: str | None = None
+    poll_seconds: int | None = None
+
+
+class SFTDataConfig(ExtraModel):
+    topology: dict[str, Any] | None = None
+    validation_path: str | None = None
+
+
+class TrainingValidationConfig(ExtraModel):
+    enabled: bool | None = None
+    evaluation_strategy: str | None = None
+    eval_steps: int | None = None
+    save_best_model_at_end: bool | None = None
+    metric_for_best_model: str | None = None
+    greater_is_better: bool | None = None
+
+
+class TrainingConfig(ExtraModel):
+    mode: str | None = None
+    use_qlora: bool | None = None
+    validation: TrainingValidationConfig | None = None
+
+
+class HyperparametersParallelism(ExtraModel):
+    use_deepspeed: bool | None = None
+    deepspeed_stage: int | None = None
+    fsdp: bool | None = None
+    bf16: bool | None = None
+    fp16: bool | None = None
+    activation_checkpointing: bool | None = None
+    tensor_parallel_size: int | None = None
+    pipeline_parallel_size: int | None = None
+
+
+class HyperparametersConfig(ExtraModel):
+    n_epochs: int = 1
+    batch_size: int | None = None
+    global_batch: int | None = None
+    per_device_batch: int | None = None
+    gradient_accumulation_steps: int | None = None
+    sequence_length: int | None = None
+    learning_rate: float | None = None
+    warmup_ratio: float | None = None
+    train_kind: str | None = None
+    weight_decay: float | None = None
+    parallelism: HyperparametersParallelism | None = None
+
+
+class SFTConfig(ExtraModel):
+    algorithm: AlgorithmConfig | None = None
+    job: JobConfig
+    compute: ComputeConfig | None = None
+    data: SFTDataConfig | None = None
+    training: TrainingConfig | None = None
+    hyperparameters: HyperparametersConfig = Field(default_factory=HyperparametersConfig)
+    tags: dict[str, Any] | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return self.model_dump(mode="python", exclude_none=True)
+
+    @classmethod
+    def from_mapping(cls, data: Mapping[str, Any]) -> SFTConfig:
+        return cls.model_validate(dict(data))
+
+    @classmethod
+    def from_path(cls, path: Path) -> SFTConfig:
+        content = load_toml(path)
+        return cls.from_mapping(content)
+
+
+__all__ = [
+    "HyperparametersConfig",
+    "HyperparametersParallelism",
+    "JobConfig",
+    "SFTConfig",
+    "SFTDataConfig",
+    "TrainingConfig",
+    "TrainingValidationConfig",
+]

synth_ai/api/train/configs/shared.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict
+
+
+class ExtraModel(BaseModel):
+    """Base model that tolerates unknown keys so configs keep forward compatibility."""
+
+    model_config = ConfigDict(extra="allow")
+
+
+class AlgorithmConfig(ExtraModel):
+    type: str
+    method: str
+    variety: str
+
+
+class ComputeConfig(ExtraModel):
+    gpu_type: str
+    gpu_count: int
+    nodes: int | None = None
+
+
+__all__ = ["ExtraModel", "AlgorithmConfig", "ComputeConfig"]

synth_ai/api/train/env_resolver.py

@@ -5,6 +5,7 @@ import os
 from collections.abc import Callable, Iterable, MutableMapping
 from dataclasses import dataclass
 from pathlib import Path
+from typing import Any, cast
 
 import click
 
@@ -14,8 +15,10 @@ from .utils import REPO_ROOT, mask_value, read_env_file, write_env_value
 
 def _load_saved_env_path() -> Path | None:
     try:
-        module = importlib.import_module("synth_ai.demos.demo_task_apps.core")
-        loader = module.load_env_file_path
+        module = cast(
+            Any, importlib.import_module("synth_ai.demos.demo_task_apps.core")
+        )
+        loader = cast(Callable[[], str | None], module.load_env_file_path)
         saved_path = loader()
         if saved_path:
             return Path(saved_path)

synth_ai/api/train/supported_algos.py

@@ -1,14 +1,19 @@
 from __future__ import annotations
 
 import importlib
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass
+from typing import Any, cast
 
 try:
-    _models_module = importlib.import_module("synth_ai.api.models.supported")
-    RL_SUPPORTED_MODELS = _models_module.RL_SUPPORTED_MODELS
-    SFT_SUPPORTED_MODELS = _models_module.SFT_SUPPORTED_MODELS
-    training_modes_for_model = _models_module.training_modes_for_model
+    _models_module = cast(
+        Any, importlib.import_module("synth_ai.api.models.supported")
+    )
+    RL_SUPPORTED_MODELS = cast(tuple[str, ...], _models_module.RL_SUPPORTED_MODELS)
+    SFT_SUPPORTED_MODELS = cast(tuple[str, ...], _models_module.SFT_SUPPORTED_MODELS)
+    training_modes_for_model = cast(
+        Callable[[str], tuple[str, ...]], _models_module.training_modes_for_model
+    )
 except Exception as exc:  # pragma: no cover - critical dependency
     raise RuntimeError("Unable to load supported model metadata") from exc
 

synth_ai/api/train/utils.py

@@ -8,15 +8,18 @@ import subprocess
 import tempfile
 import time
 import tomllib
-from collections.abc import Iterable, Mapping
+from collections.abc import Callable, Iterable, Mapping
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any
+from typing import Any, cast
 
 import requests
 
 try:
-    collect_sft_jsonl_errors = importlib.import_module("synth_ai.learning.sft").collect_sft_jsonl_errors
+    sft_module = cast(Any, importlib.import_module("synth_ai.learning.sft"))
+    collect_sft_jsonl_errors = cast(
+        Callable[..., list[dict[str, Any]]], sft_module.collect_sft_jsonl_errors
+    )
 except Exception as exc:  # pragma: no cover - critical dependency
     raise RuntimeError("Unable to load SFT JSONL helpers") from exc
 
@@ -154,7 +157,7 @@ def validate_sft_jsonl(path: Path, *, max_errors: int = 20) -> None:
 
     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)
+    details = "\n - ".join(cast("list[str]", issues))
     raise TrainError(f"{path}: Dataset validation failed{suffix}:\n - {details}")
 
 

synth_ai/cli/__init__.py

@@ -8,6 +8,8 @@ pyproject entry point `synth_ai.cli:cli`.
 from __future__ import annotations
 
 import importlib
+from collections.abc import Callable
+from typing import Any, cast
 
 # Load environment variables from a local .env if present (repo root)
 try:
@@ -30,48 +32,8 @@ except Exception:
 from .root import cli  # new canonical CLI entrypoint
 
 # Register subcommands from this package onto the group
-try:
-    from . import watch as _watch
-
-    _watch.register(cli)
-except Exception:
-    pass
-try:
-    from . import balance as _balance
-
-    _balance.register(cli)
-except Exception:
-    pass
-try:
-    from . import man as _man
-
-    _man.register(cli)
-except Exception:
-    pass
-try:
-    from . import traces as _traces
-
-    _traces.register(cli)
-except Exception:
-    pass
-try:
-    from . import recent as _recent
-
-    _recent.register(cli)
-except Exception:
-    pass
-try:
-    from . import calc as _calc
-
-    _calc.register(cli)
-except Exception:
-    pass
-try:
-    from . import status as _status
-
-    _status.register(cli)
-except Exception:
-    pass
+# Deprecated/legacy commands intentionally not registered: watch/experiments, balance, calc,
+# man, recent, status, traces
 try:
     from . import demo as _demo
 
@@ -85,14 +47,8 @@ try:
 except Exception:
     pass
 try:
-    from . import rl_demo as _rl_demo
-
-    _rl_demo.register(cli)
-except Exception:
-    pass
-try:
-    _train_module = importlib.import_module("synth_ai.api.train")
-    _train_register = _train_module.register
+    _train_module = cast(Any, importlib.import_module("synth_ai.api.train"))
+    _train_register = cast(Callable[[Any], None], _train_module.register)
     _train_register(cli)
 except Exception:
     pass
@@ -114,4 +70,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")
+# Top-level 'info' alias removed; use `synth-ai task-app info` instead

synth_ai/cli/_storage.py

@@ -8,12 +8,13 @@ allowing type checkers to resolve the symbols dynamically.
 from __future__ import annotations
 
 import importlib
-from typing import Any
+from collections.abc import Callable
+from typing import Any, cast
 
 
 def load_storage() -> tuple[Any, Any]:
     """Return (create_storage, StorageConfig) from tracing_v3.storage."""
-    storage_module = importlib.import_module("synth_ai.tracing_v3.storage")
-    create_storage = storage_module.create_storage
+    storage_module = cast(Any, importlib.import_module("synth_ai.tracing_v3.storage"))
+    create_storage = cast(Callable[..., Any], storage_module.create_storage)
     storage_config = storage_module.StorageConfig
     return create_storage, storage_config

synth_ai/cli/_validate_task_app.py

@@ -0,0 +1,11 @@
+"""Task app validation utilities - imported by task_apps.py"""
+
+# This module provides the validate_task_app function for CLI use
+# The actual implementation is imported from the task module
+
+from synth_ai.task.validators import (
+    validate_task_app_endpoint as validate_task_app,  # type: ignore[attr-defined]
+)
+
+__all__ = ["validate_task_app"]
+

synth_ai/cli/balance.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 import importlib
 import os
 from collections.abc import Callable
+from typing import Any, cast
 
 import click
 import requests
@@ -19,9 +20,9 @@ from rich.table import Table
 
 def _load_base_url_module() -> tuple[str, Callable[[], tuple[str, str]]]:
     try:
-        module = importlib.import_module("synth_ai.config.base_url")
-        default = module.PROD_BASE_URL_DEFAULT
-        getter = module.get_backend_from_env
+        module = cast(Any, importlib.import_module("synth_ai.config.base_url"))
+        default = cast(str, module.PROD_BASE_URL_DEFAULT)
+        getter = cast(Callable[[], tuple[str, str]], module.get_backend_from_env)
         return str(default), getter
     except Exception:
         return "https://agent-learning.onrender.com", lambda: ("https://agent-learning.onrender.com", "")

synth_ai/cli/calc.py

@@ -35,13 +35,13 @@ def _safe_eval(expr: str) -> float:
         if isinstance(n, ast.Expression):
             return _eval(n.body)
         if isinstance(n, ast.Constant):
-            if isinstance(n.value, (int, float)):
+            if isinstance(n.value, int | float):
                 return float(n.value)
             raise ValueError("Only numeric constants are allowed")
         num_node = getattr(ast, "Num", None)
         if num_node is not None and isinstance(n, num_node):  # pragma: no cover
             numeric_value = getattr(n, "n", None)
-            if isinstance(numeric_value, (int, float)):
+            if isinstance(numeric_value, int | float):
                 return float(numeric_value)
             raise ValueError("Only numeric constants are allowed")
         if isinstance(n, ast.BinOp):

synth_ai/cli/demo.py

@@ -1,18 +1,25 @@
 #!/usr/bin/env python3
 """
-CLI: interactive launcher for example demos and forwarders for new RL demo.
+CLI: interactive launcher for example demos and RL demo helpers.
 
-- `synth-ai demo` (no subcommand) -> legacy examples/ runner (run_demo.sh picker)
-- `synth-ai demo deploy|configure|run` -> forwards to synth_ai.demos.core.cli
+- `synth-ai demo` (no subcommand) -> initialize RL demo files into ./synth_demo/
+- `synth-ai demo deploy|configure|run` -> invoke RL demo helpers directly.
 """
 
 from __future__ import annotations
 
+import importlib
 import os
 import subprocess
 from pathlib import Path
+from typing import Any, cast
 
 import click
+from click.exceptions import Exit
+
+demo_commands = cast(
+    Any, importlib.import_module("synth_ai.demos.core.cli")
+)
 
 
 def _find_demo_scripts(root: Path) -> list[Path]:
@@ -21,17 +28,23 @@ def _find_demo_scripts(root: Path) -> list[Path]:
     return sorted([p for p in root.rglob("run_demo.sh") if p.is_file()])
 
 
-def _forward_to_new(args: list[str]) -> None:
-    import sys
+def _run_demo_command(func, *args, **kwargs) -> None:
+    """Invoke a demo command and exit via Click on non-zero status codes."""
 
     try:
-        from synth_ai.demos.core import cli as demo_cli  # type: ignore
-    except Exception as e:  # pragma: no cover
-        click.echo(f"Failed to import demo CLI: {e}")
-        sys.exit(1)
-    rc = int(demo_cli.main(args) or 0)
-    if rc != 0:
-        sys.exit(rc)
+        result = func(*args, **kwargs)
+    except SystemExit as exc:  # pragma: no cover - defensive
+        raise Exit(exc.code or 1) from exc
+
+    if result is None:
+        return
+
+    try:
+        code = int(result)
+    except (TypeError, ValueError):
+        return
+    if code != 0:
+        raise Exit(code)
 
 
 def register(cli):
@@ -92,19 +105,13 @@ def register(cli):
                 click.echo("\n🛑 Demo interrupted by user")
             return
 
-        # Default: forward to RL demo init behavior, optionally with --force
-        args: list[str] = ["rl_demo.init"]
-        if force:
-            args.append("--force")
-        _forward_to_new(args)
+        # Default: initialize RL demo files via new command
+        _run_demo_command(demo_commands.init, force=force)
 
     # (prepare command removed; configure now prepares baseline TOML)
 
     # Help pyright understand dynamic Click group attributes
-    from typing import Any
-    from typing import cast as _cast
-
-    _dg = _cast(Any, demo)
+    _dg = cast(Any, demo)
 
     @_dg.command("deploy")
     @click.option("--local", is_flag=True, help="Run local FastAPI instead of Modal deploy")
@@ -122,24 +129,21 @@ def register(cli):
         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:
-            args.append("--local")
-        if app:
-            args.extend(["--app", app])
-        if name:
-            args.extend(["--name", name])
-        if script:
-            args.extend(["--script", script])
-        _forward_to_new(args)
+        _run_demo_command(
+            demo_commands.deploy,
+            local=local,
+            app=app,
+            name=name,
+            script=script,
+        )
 
     @_dg.command("configure")
     def demo_configure():
-        _forward_to_new(["rl_demo.configure"])
+        _run_demo_command(demo_commands.run)
 
     @_dg.command("setup")
     def demo_setup():
-        _forward_to_new(["rl_demo.setup"])
+        _run_demo_command(demo_commands.setup)
 
     @_dg.command("run")
     @click.option("--batch-size", type=int, default=None)
@@ -147,13 +151,15 @@ def register(cli):
     @click.option("--model", type=str, default=None)
     @click.option("--timeout", type=int, default=600)
     def demo_run(batch_size: int | None, group_size: int | None, model: str | None, timeout: int):
-        args = ["rl_demo.run"]
-        if batch_size is not None:
-            args.extend(["--batch-size", str(batch_size)])
-        if group_size is not None:
-            args.extend(["--group-size", str(group_size)])
-        if model:
-            args.extend(["--model", model])
-        if timeout:
-            args.extend(["--timeout", str(timeout)])
-        _forward_to_new(args)
+        _run_demo_command(
+            demo_commands.run,
+            batch_size=batch_size,
+            group_size=group_size,
+            model=model,
+            timeout=timeout,
+        )
+
+    @cli.command("setup")
+    def setup_alias():
+        """Perform SDK handshake and write keys to .env."""
+        _run_demo_command(demo_commands.setup)

synth_ai/cli/legacy_root_backup.py

@@ -235,7 +235,7 @@ def view(url: str):
     """Launch the interactive TUI dashboard."""
     try:
         module = importlib.import_module(".tui.dashboard", __package__)
-        synth_dashboard_cls = module.SynthDashboard
+        synth_dashboard_cls = getattr(module, "SynthDashboard")
         app = synth_dashboard_cls(db_url=url)
         app.run()
     except ImportError: