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

synth_ai/task/__init__.py

@@ -1,102 +0,0 @@
-from .auth import (
-    is_api_key_header_authorized,
-    normalize_environment_api_key,
-    require_api_key_dependency,
-)
-from .client import TaskAppClient
-from .contracts import (
-    RolloutEnvSpec,
-    RolloutMetrics,
-    RolloutPolicySpec,
-    RolloutRecordConfig,
-    RolloutRequest,
-    RolloutResponse,
-    RolloutSafetyConfig,
-    RolloutStep,
-    RolloutTrajectory,
-    TaskAppContract,
-    TaskAppEndpoints,
-    TaskInfo,
-)
-from .datasets import TaskDatasetRegistry, TaskDatasetSpec
-from .errors import error_payload, http_exception, json_error_response
-from .health import task_app_health
-from .json import to_jsonable
-from .proxy import (
-    INTERACT_TOOL_SCHEMA,
-    extract_message_text,
-    inject_system_hint,
-    parse_tool_call_from_text,
-    prepare_for_groq,
-    prepare_for_openai,
-    synthesize_tool_call_if_missing,
-)
-from .rubrics import (
-    Criterion,
-    Rubric,
-    blend_rubrics,
-    load_rubric,
-    score_events_against_rubric,
-    score_outcome_against_rubric,
-)
-from .server import (
-    ProxyConfig,
-    RubricBundle,
-    TaskAppConfig,
-    create_task_app,
-    run_task_app,
-)
-from .validators import validate_task_app_url
-from .vendors import (
-    get_groq_key_or_503,
-    get_openai_key_or_503,
-    normalize_vendor_keys,
-)
-
-__all__ = [
-    "validate_task_app_url",
-    "task_app_health",
-    "TaskAppContract",
-    "TaskAppEndpoints",
-    "RolloutEnvSpec",
-    "RolloutPolicySpec",
-    "RolloutRecordConfig",
-    "RolloutSafetyConfig",
-    "RolloutRequest",
-    "RolloutResponse",
-    "RolloutTrajectory",
-    "RolloutStep",
-    "RolloutMetrics",
-    "TaskInfo",
-    "to_jsonable",
-    "normalize_environment_api_key",
-    "is_api_key_header_authorized",
-    "require_api_key_dependency",
-    "normalize_vendor_keys",
-    "get_openai_key_or_503",
-    "get_groq_key_or_503",
-    "INTERACT_TOOL_SCHEMA",
-    "prepare_for_openai",
-    "prepare_for_groq",
-    "inject_system_hint",
-    "extract_message_text",
-    "parse_tool_call_from_text",
-    "synthesize_tool_call_if_missing",
-    "TaskDatasetSpec",
-    "TaskDatasetRegistry",
-    "Criterion",
-    "Rubric",
-    "load_rubric",
-    "blend_rubrics",
-    "score_events_against_rubric",
-    "score_outcome_against_rubric",
-    "TaskAppClient",
-    "error_payload",
-    "http_exception",
-    "json_error_response",
-    "run_task_app",
-    "create_task_app",
-    "RubricBundle",
-    "ProxyConfig",
-    "TaskAppConfig",
-]

synth_ai/task/apps/__init__.py

@@ -1,128 +0,0 @@
-"""Registry for Task Apps exposed via the shared FastAPI harness."""
-
-from __future__ import annotations
-
-import importlib
-import sys
-from collections.abc import Callable, Iterable, Sequence
-from dataclasses import dataclass, field
-from pathlib import Path
-
-from ..server import TaskAppConfig
-
-
-@dataclass(slots=True)
-class ModalDeploymentConfig:
-    """Modal deployment defaults for a task app."""
-
-    app_name: str
-    python_version: str = "3.11"
-    pip_packages: Sequence[str] = field(default_factory=tuple)
-    extra_local_dirs: Sequence[tuple[str, str]] = field(default_factory=tuple)
-    secret_names: Sequence[str] = field(default_factory=tuple)
-    volume_mounts: Sequence[tuple[str, str]] = field(default_factory=tuple)
-    timeout: int = 600
-    memory: int = 4096
-    cpu: float = 2.0
-    min_containers: int = 1
-    max_containers: int = 4
-
-
-@dataclass(slots=True)
-class TaskAppEntry:
-    """Metadata describing a registered task app."""
-
-    app_id: str
-    description: str
-    config_factory: Callable[[], TaskAppConfig]
-    aliases: Sequence[str] = field(default_factory=tuple)
-    env_files: Sequence[str] = field(default_factory=tuple)
-    modal: ModalDeploymentConfig | None = None
-
-
-class TaskAppRegistry:
-    """In-memory registry of known task apps."""
-
-    def __init__(self) -> None:
-        self._entries: dict[str, TaskAppEntry] = {}
-        self._alias_to_id: dict[str, str] = {}
-
-    def register(self, entry: TaskAppEntry) -> None:
-        if entry.app_id in self._entries:
-            raise ValueError(f"Task app already registered: {entry.app_id}")
-        self._entries[entry.app_id] = entry
-        for alias in entry.aliases:
-            if alias in self._alias_to_id:
-                raise ValueError(f"Alias already registered: {alias}")
-            self._alias_to_id[alias] = entry.app_id
-
-    def get(self, app_id: str) -> TaskAppEntry:
-        resolved = self._alias_to_id.get(app_id, app_id)
-        if resolved not in self._entries:
-            raise KeyError(f"Unknown task app id: {app_id}")
-        return self._entries[resolved]
-
-    def list(self) -> list[TaskAppEntry]:
-        return sorted(self._entries.values(), key=lambda entry: entry.app_id)
-
-    def __iter__(self) -> Iterable[TaskAppEntry]:
-        return iter(self.list())
-
-    def clear(self) -> None:
-        """Clear all registered task apps."""
-        self._entries.clear()
-        self._alias_to_id.clear()
-
-
-registry = TaskAppRegistry()
-
-
-def register_task_app(*, entry: TaskAppEntry) -> None:
-    registry.register(entry)
-
-
-def discover_task_apps_from_cwd() -> None:
-    """Discover and register task apps from the current working directory and subdirectories."""
-    cwd = Path.cwd()
-
-    # Look for task app files in common patterns
-    patterns = [
-        "**/task_app/*.py",
-        "**/task_apps/*.py",
-        "**/*_task_app.py",
-        "**/grpo_crafter.py",
-        "**/math_single_step.py",
-    ]
-
-    discovered_files = []
-    for pattern in patterns:
-        discovered_files.extend(cwd.glob(pattern))
-
-    # Add current directory to Python path temporarily
-    original_path = sys.path.copy()
-    try:
-        sys.path.insert(0, str(cwd))
-
-        for file_path in discovered_files:
-            if file_path.name.startswith("__"):
-                continue
-
-            # Convert file path to module name
-            relative_path = file_path.relative_to(cwd)
-            module_parts = list(relative_path.parts[:-1]) + [relative_path.stem]
-            module_name = ".".join(module_parts)
-
-            try:
-                # Import the module to trigger registration
-                importlib.import_module(module_name)
-            except Exception:
-                # Silently skip modules that can't be imported
-                # This allows for graceful handling of missing dependencies
-                continue
-
-    finally:
-        sys.path[:] = original_path
-
-
-# Note: Task apps are now discovered dynamically by the CLI, not auto-registered
-# This allows for better separation between SDK and example-specific implementations

synth_ai/task/contracts.py

@@ -1,137 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any, Literal
-
-from pydantic import BaseModel, Field
-
-
-@dataclass(frozen=True)
-class TaskAppEndpoints:
-    """Canonical Task App endpoint shapes used by RL trainers.
-
-    Task Apps run as lightweight HTTP services (often on Modal) that expose a
-    consistent set of endpoints for health, metadata, environment lifecycle,
-    rollouts, and optional proxy access to vendor models. The endpoint strings
-    defined here act as defaults and documentation for clients.
-    """
-
-    root: str = "/"
-    health: str = "/health"
-    info: str = "/info"
-    task_info: str = "/task_info"
-    rollout: str = "/rollout"
-    proxy_chat_completions: str = "/proxy/v1/chat/completions"
-    proxy_groq_chat_completions: str = "/proxy/groq/v1/chat/completions"
-    env_initialize: str = "/env/{env_name}/initialize"
-    env_step: str = "/env/{env_name}/step"
-    env_terminate: str = "/env/{env_name}/terminate"
-
-
-@dataclass(frozen=True)
-class TaskAppContract:
-    """Requirements and expectations for a Task App used by RL trainers.
-
-    - Auth: ENVIRONMENT_API_KEY must be set in the Task App environment; requests include X-API-Key.
-    - Health: /health returns 200 and JSON; may verify X-API-Key header.
-    - Env API: initialize/step/terminate are present for the target env (e.g., CrafterClassic).
-    - Rollout API: optional; provides a single-call rollout for convenience/testing.
-    - Inference routing: policy config passes an inference_url (Synth backend or OpenAI proxy).
-    - URL: base must be reachable via HTTPS and should be under .modal.run in production.
-    """
-
-    base_url: str
-    env_name: str | None = None
-    requires_api_key_header: bool = True
-
-
-# --- Unified rollout schema used by Task App services and SDK utilities ---
-
-
-class RolloutEnvSpec(BaseModel):
-    env_id: str | None = None
-    env_name: str | None = None
-    config: dict[str, Any] = Field(default_factory=dict)
-    seed: int | None = None
-
-
-class RolloutPolicySpec(BaseModel):
-    policy_id: str | None = None
-    policy_name: str | None = None
-    config: dict[str, Any] = Field(default_factory=dict)
-
-
-class RolloutRecordConfig(BaseModel):
-    trajectories: bool = True
-    logprobs: bool = False
-    value: bool = False
-    return_trace: bool = False
-    trace_format: Literal["compact", "full"] = "compact"
-
-
-class RolloutSafetyConfig(BaseModel):
-    max_ops: int = 100000
-    max_time_s: float = 3600.0
-
-
-class RolloutRequest(BaseModel):
-    run_id: str
-    env: RolloutEnvSpec
-    policy: RolloutPolicySpec
-    ops: list[dict[str, Any]] | list[str]
-    record: RolloutRecordConfig = RolloutRecordConfig()
-    on_done: str = "reset"
-    safety: RolloutSafetyConfig = RolloutSafetyConfig()
-    training_session_id: str | None = None
-    synth_base_url: str | None = None
-
-
-class RolloutStep(BaseModel):
-    obs: dict[str, Any]
-    tool_calls: list[dict[str, Any]]
-    reward: float | None = None
-    done: bool = False
-    truncated: bool | None = None
-    info: dict[str, Any] | None = None
-
-
-class RolloutTrajectory(BaseModel):
-    env_id: str
-    policy_id: str
-    steps: list[RolloutStep]
-    final: dict[str, Any] | None = None
-    length: int
-
-
-class RolloutMetrics(BaseModel):
-    episode_returns: list[float]
-    mean_return: float
-    num_steps: int
-    num_episodes: int = 0
-    outcome_score: float | None = None
-    events_score: float | None = None
-    details: dict[str, Any] = Field(default_factory=dict)
-
-
-class RolloutResponse(BaseModel):
-    run_id: str
-    trajectories: list[RolloutTrajectory]
-    branches: dict[str, list[str]] = Field(default_factory=dict)
-    metrics: RolloutMetrics
-    aborted: bool = False
-    ops_executed: int = 0
-    trace: dict[str, Any] | None = None
-
-
-class TaskInfo(BaseModel):
-    """Static metadata describing the capabilities of a Task App task."""
-
-    task: dict[str, Any]
-    environments: list[str]
-    action_space: dict[str, Any]
-    observation: dict[str, Any]
-    dataset: dict[str, Any]
-    rubric: dict[str, Any]
-    inference: dict[str, Any]
-    capabilities: dict[str, Any]
-    limits: dict[str, Any]

synth_ai/task/datasets.py

@@ -1,108 +0,0 @@
-"""Dataset registry and helpers shared by Task Apps."""
-
-from __future__ import annotations
-
-from collections.abc import Callable, Hashable
-from typing import Any
-
-from pydantic import BaseModel, Field, field_validator
-
-
-class TaskDatasetSpec(BaseModel):
-    """Declarative metadata describing a dataset that a Task App exposes."""
-
-    id: str
-    name: str
-    version: str | None = None
-    splits: list[str] = Field(default_factory=list)
-    default_split: str | None = None
-    cardinality: int | None = None
-    description: str | None = None
-
-    @field_validator("default_split")
-    @classmethod
-    def _validate_default_split(cls, value: str | None, info):
-        values = info.data if hasattr(info, "data") else {}  # type: ignore[attr-defined]
-        if value and value not in (values.get("splits") or []):
-            raise ValueError("default_split must be one of splits when provided")
-        return value
-
-
-RegistryLoader = Callable[[TaskDatasetSpec], Any]
-
-
-class TaskDatasetRegistry:
-    """Lightweight registry mapping dataset specs to loader callables."""
-
-    def __init__(self) -> None:
-        self._entries: dict[str, tuple[TaskDatasetSpec, RegistryLoader, bool]] = {}
-        self._cache: dict[Hashable, Any] = {}
-
-    def register(
-        self, spec: TaskDatasetSpec, loader: RegistryLoader, *, cache: bool = True
-    ) -> None:
-        """Register a dataset loader and its metadata."""
-
-        self._entries[spec.id] = (spec, loader, cache)
-
-    def describe(self, dataset_id: str) -> TaskDatasetSpec:
-        if dataset_id not in self._entries:
-            raise KeyError(f"Dataset not registered: {dataset_id}")
-        spec, _, _ = self._entries[dataset_id]
-        return spec
-
-    def list(self) -> list[TaskDatasetSpec]:
-        return [entry[0] for entry in self._entries.values()]
-
-    def get(self, spec: TaskDatasetSpec | str) -> Any:
-        """Return dataset materialisation (with optional caching)."""
-
-        if isinstance(spec, str):
-            if spec not in self._entries:
-                raise KeyError(f"Dataset not registered: {spec}")
-            base_spec, loader, cache_enabled = self._entries[spec]
-            effective_spec = base_spec
-        else:
-            if spec.id not in self._entries:
-                raise KeyError(f"Dataset not registered: {spec.id}")
-            base_spec, loader, cache_enabled = self._entries[spec.id]
-            effective_spec = base_spec.model_copy(update=spec.model_dump(exclude_unset=True))
-
-        cache_key: Hashable = (
-            effective_spec.id,
-            effective_spec.version,
-            effective_spec.default_split,
-        )
-        if cache_enabled:
-            if cache_key not in self._cache:
-                self._cache[cache_key] = loader(effective_spec)
-            return self._cache[cache_key]
-        return loader(effective_spec)
-
-    @staticmethod
-    def ensure_split(spec: TaskDatasetSpec, split: str | None) -> str:
-        """Validate that `split` exists on the spec; return a concrete split."""
-
-        if not spec.splits:
-            return split or spec.default_split or "default"
-        if split is None:
-            if spec.default_split:
-                return spec.default_split
-            raise ValueError(f"split must be provided for dataset {spec.id}")
-        if split not in spec.splits:
-            raise ValueError(f"Unknown split '{split}' for dataset {spec.id}")
-        return split
-
-    @staticmethod
-    def normalise_seed(seed: Any, *, cardinality: int | None = None) -> int:
-        """Normalise arbitrary seed input into a bounded non-negative integer."""
-
-        try:
-            value = int(seed)
-        except Exception as exc:  # pragma: no cover - defensive
-            raise ValueError(f"Seed must be convertible to int (got {seed!r})") from exc
-        if value < 0:
-            value = abs(value)
-        if cardinality and cardinality > 0:
-            value = value % cardinality
-        return value