synth-ai 0.2.9.dev4__py3-none-any.whl → 0.2.9.dev6__py3-none-any.whl

synth_ai/learning/validators.py

@@ -1,36 +1,37 @@
 from __future__ import annotations
 
-from pathlib import Path
 import json
-from typing import Any, Dict
-from urllib.parse import urlparse
+from pathlib import Path
+from typing import Any
+
+from synth_ai.learning.sft import SFTDataError, parse_jsonl_line
 
 
 def validate_training_jsonl(path: str | Path, *, sample_lines: int = 50) -> None:
     p = Path(path)
     if not p.exists():
         raise FileNotFoundError(str(p))
-    lines = p.read_text().splitlines()
-    if not lines:
+
+    max_samples = max(1, sample_lines)
+    non_empty_lines = 0
+
+    with p.open("r", encoding="utf-8") as fh:
+        for lineno, raw_line in enumerate(fh, start=1):
+            stripped = raw_line.strip()
+            if not stripped:
+                continue
+            non_empty_lines += 1
+            if non_empty_lines > max_samples:
+                break
+            try:
+                parse_jsonl_line(stripped, min_messages=2)
+            except json.JSONDecodeError as exc:
+                raise ValueError(f"invalid json on line {lineno}: {exc}") from exc
+            except SFTDataError as exc:
+                raise ValueError(f"line {lineno}: {exc}") from exc
+
+    if non_empty_lines == 0:
         raise ValueError("empty JSONL")
-    for i, line in enumerate(lines[: max(1, sample_lines) ], start=1):
-        if not line.strip():
-            continue
-        try:
-            obj = json.loads(line)
-        except Exception as e:
-            raise ValueError(f"invalid json on line {i}: {e}") from e
-        msgs = obj.get("messages")
-        if not isinstance(msgs, list) or len(msgs) < 2:
-            raise ValueError(f"line {i}: missing messages[] with at least 2 turns")
-        roles = [m.get("role") for m in msgs if isinstance(m, dict)]
-        if not roles or not isinstance(roles[0], str):
-            raise ValueError(f"line {i}: missing first role")
-        for m in msgs:
-            if not isinstance(m, dict):
-                raise ValueError(f"line {i}: non-dict message")
-            if not isinstance(m.get("role"), str) or not isinstance(m.get("content"), str) or not m["content"].strip():
-                raise ValueError(f"line {i}: invalid role/content")
 
 
 def validate_task_app_url(url: str, *, name: str = "TASK_APP_BASE_URL") -> None:
@@ -39,7 +40,7 @@ def validate_task_app_url(url: str, *, name: str = "TASK_APP_BASE_URL") -> None:
     _vt(url, name=name)
 
 
-def validate_trainer_cfg_rl(trainer: Dict[str, Any]) -> None:
+def validate_trainer_cfg_rl(trainer: dict[str, Any]) -> None:
     bs = int(trainer.get("batch_size", 1))
     gs = int(trainer.get("group_size", 2))
     if bs < 1:

synth_ai/lm/__init__.py

@@ -1,51 +1,25 @@
-"""
-Synth AI Language Model Interface.
+"""Deprecated shim forwarding to synth_ai.v0.lm."""
 
-Provides a unified interface for multiple LLM providers including OpenAI and Synth.
-"""
+import importlib as _importlib
+import pkgutil as _pkgutil
+import sys as _sys
+from pathlib import Path as _Path
 
-from .config import OpenAIConfig, SynthConfig
-from .core.main_v3 import LM
-from .unified_interface import (
-    OpenAIProvider,
-    SynthProvider,
-    UnifiedLMClient,
-    UnifiedLMProvider,
-    create_provider,
-)
-from .vendors.synth_client import (
-    AsyncSynthClient,
-    SyncSynthClient,
-    create_async_client,
-    create_chat_completion_async,
-    create_chat_completion_sync,
-    create_sync_client,
-)
-from .warmup import get_warmup_status, warmup_synth_model
+_TARGET_PREFIX = "synth_ai.v0.lm"
+_ALIAS_PREFIX = __name__
 
-__all__ = [
-    # Configuration
-    "SynthConfig",
-    "OpenAIConfig",
-    # Warmup utilities
-    "warmup_synth_model",
-    "get_warmup_status",
-    # Unified interface
-    "UnifiedLMProvider",
-    "OpenAIProvider",
-    "SynthProvider",
-    "UnifiedLMClient",
-    "create_provider",
-    # Synth client
-    "AsyncSynthClient",
-    "SyncSynthClient",
-    "create_async_client",
-    "create_sync_client",
-    "create_chat_completion_async",
-    "create_chat_completion_sync",
-    # Core LM class
-    "LM",
-]
+_alias_path = _Path(__file__).resolve().parents[1] / "v0" / "lm"
+__path__ = [str(_alias_path)]  # type: ignore[assignment]
 
-# Version info
-__version__ = "0.1.0"
+_pkg = _importlib.import_module(_TARGET_PREFIX)
+_sys.modules[_ALIAS_PREFIX] = _pkg
+
+for _finder, _name, _ispkg in _pkgutil.walk_packages(_pkg.__path__, prefix=_TARGET_PREFIX + "."):  # type: ignore[attr-defined]
+    try:
+        _module = _importlib.import_module(_name)
+    except Exception:  # pragma: no cover - best effort
+        continue
+    _alias = _ALIAS_PREFIX + _name[len(_TARGET_PREFIX) :]
+    _sys.modules[_alias] = _module
+
+del _finder, _name, _ispkg, _module, _alias, _TARGET_PREFIX, _ALIAS_PREFIX, _alias_path

synth_ai/task/__init__.py

@@ -1,59 +1,58 @@
-from .validators import validate_task_app_url
-from .health import task_app_health
+from .auth import (
+    is_api_key_header_authorized,
+    normalize_environment_api_key,
+    require_api_key_dependency,
+)
+from .client import TaskAppClient
 from .contracts import (
-    TaskAppContract,
-    TaskAppEndpoints,
     RolloutEnvSpec,
+    RolloutMetrics,
     RolloutPolicySpec,
     RolloutRecordConfig,
-    RolloutSafetyConfig,
     RolloutRequest,
     RolloutResponse,
-    RolloutTrajectory,
+    RolloutSafetyConfig,
     RolloutStep,
-    RolloutMetrics,
+    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 .auth import (
-    normalize_environment_api_key,
-    is_api_key_header_authorized,
-    require_api_key_dependency,
-)
-from .vendors import (
-    normalize_vendor_keys,
-    get_openai_key_or_503,
-    get_groq_key_or_503,
-)
 from .proxy import (
     INTERACT_TOOL_SCHEMA,
-    prepare_for_openai,
-    prepare_for_groq,
-    inject_system_hint,
     extract_message_text,
+    inject_system_hint,
     parse_tool_call_from_text,
+    prepare_for_groq,
+    prepare_for_openai,
     synthesize_tool_call_if_missing,
 )
-from .datasets import TaskDatasetSpec, TaskDatasetRegistry
 from .rubrics import (
     Criterion,
     Rubric,
-    load_rubric,
     blend_rubrics,
+    load_rubric,
     score_events_against_rubric,
     score_outcome_against_rubric,
 )
-from .client import TaskAppClient
-from .errors import error_payload, http_exception, json_error_response
-
-
 from .server import (
-    TaskAppConfig,
     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",

synth_ai/task/apps/__init__.py

@@ -1,13 +1,12 @@
-from __future__ import annotations
-
 """Registry for Task Apps exposed via the shared FastAPI harness."""
 
+from __future__ import annotations
+
 import importlib
-import os
 import sys
+from collections.abc import Callable, Iterable, Sequence
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Callable, Dict, Iterable, List, Sequence
 
 from ..server import TaskAppConfig
 
@@ -45,8 +44,8 @@ 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] = {}
+        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:
@@ -63,12 +62,12 @@ class TaskAppRegistry:
             raise KeyError(f"Unknown task app id: {app_id}")
         return self._entries[resolved]
 
-    def list(self) -> List[TaskAppEntry]:
+    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()
@@ -85,42 +84,42 @@ def register_task_app(*, entry: TaskAppEntry) -> None:
 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_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('__'):
+            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)
-            
+            module_name = ".".join(module_parts)
+
             try:
                 # Import the module to trigger registration
                 importlib.import_module(module_name)
-            except Exception as exc:
+            except Exception:
                 # Silently skip modules that can't be imported
                 # This allows for graceful handling of missing dependencies
                 continue
-                
+
     finally:
         sys.path[:] = original_path
 

synth_ai/task/auth.py

@@ -1,9 +1,11 @@
-from __future__ import annotations
-
 """Authentication helpers shared by Task Apps."""
 
+from __future__ import annotations
+
 import os
-from typing import Iterable, Optional, Any, Set
+from collections.abc import Iterable
+from contextlib import suppress
+from typing import Any
 
 from .errors import http_exception
 
@@ -12,7 +14,9 @@ _DEV_API_KEY_ENVS = ("dev_environment_api_key", "DEV_ENVIRONMENT_API_KEY")
 _API_KEY_HEADER = "x-api-key"
 _API_KEYS_HEADER = "x-api-keys"
 _AUTH_HEADER = "authorization"
-_API_KEY_ALIASES_ENV = "ENVIRONMENT_API_KEY_ALIASES"  # comma-separated list of additional valid keys
+_API_KEY_ALIASES_ENV = (
+    "ENVIRONMENT_API_KEY_ALIASES"  # comma-separated list of additional valid keys
+)
 
 
 def _mask(value: str, *, prefix: int = 4) -> str:
@@ -22,7 +26,7 @@ def _mask(value: str, *, prefix: int = 4) -> str:
     return f"{visible}{'…' if len(value) > prefix else ''}"
 
 
-def normalize_environment_api_key() -> Optional[str]:
+def normalize_environment_api_key() -> str | None:
     """Ensure `ENVIRONMENT_API_KEY` is populated from dev fallbacks.
 
     Returns the resolved key (if any) so callers can branch on configuration.
@@ -43,7 +47,7 @@ def normalize_environment_api_key() -> Optional[str]:
     return None
 
 
-def allowed_environment_api_keys() -> Set[str]:
+def allowed_environment_api_keys() -> set[str]:
     """Return the set of valid environment API keys for this Task App.
 
     Includes:
@@ -120,7 +124,9 @@ def require_api_key_dependency(request: Any) -> None:
 
     allowed = allowed_environment_api_keys()
     if not allowed:
-        raise http_exception(503, "missing_environment_api_key", "ENVIRONMENT_API_KEY is not configured")
+        raise http_exception(
+            503, "missing_environment_api_key", "ENVIRONMENT_API_KEY is not configured"
+        )
     # Build candidate list for verbose diagnostics
     single = list(_header_values(request, _API_KEY_HEADER))
     multi = list(_header_values(request, _API_KEYS_HEADER))
@@ -131,23 +137,29 @@ def require_api_key_dependency(request: Any) -> None:
             bearer.append(a.split(" ", 1)[1].strip())
     candidates = _split_csv(single + multi + bearer)
     if not any(candidate in allowed for candidate in candidates):
-        try:
-            print({
-                "task_auth_failed": True,
+        with suppress(Exception):
+            print(
+                {
+                    "task_auth_failed": True,
+                    "allowed_first15": [k[:15] for k in allowed],
+                    "allowed_count": len(allowed),
+                    "got_first15": [c[:15] for c in candidates],
+                    "got_lens": [len(c) for c in candidates],
+                    "have_x_api_key": bool(single),
+                    "have_x_api_keys": bool(multi),
+                    "have_authorization": bool(auths),
+                },
+                flush=True,
+            )
+        # Use 400 to make failures unmistakable during preflight
+        raise http_exception(
+            400,
+            "unauthorised",
+            "API key missing or invalid",
+            extra={
                 "allowed_first15": [k[:15] for k in allowed],
                 "allowed_count": len(allowed),
                 "got_first15": [c[:15] for c in candidates],
                 "got_lens": [len(c) for c in candidates],
-                "have_x_api_key": bool(single),
-                "have_x_api_keys": bool(multi),
-                "have_authorization": bool(auths),
-            }, flush=True)
-        except Exception:
-            pass
-        # Use 400 to make failures unmistakable during preflight
-        raise http_exception(400, "unauthorised", "API key missing or invalid", extra={
-            "allowed_first15": [k[:15] for k in allowed],
-            "allowed_count": len(allowed),
-            "got_first15": [c[:15] for c in candidates],
-            "got_lens": [len(c) for c in candidates],
-        })
+            },
+        )

synth_ai/task/client.py

@@ -1,10 +1,10 @@
-from __future__ import annotations
-
 """Async HTTP client for interacting with Task Apps."""
 
+from __future__ import annotations
+
 import asyncio
-from typing import Any, Dict, Iterable, List, Optional
 import os
+from typing import Any
 
 import httpx
 from pydantic import BaseModel
@@ -37,7 +37,7 @@ class TaskAppClient:
         self._client: httpx.AsyncClient | None = None
         self.env = _TaskAppEnvironmentClient(self)
 
-    async def __aenter__(self) -> "TaskAppClient":
+    async def __aenter__(self) -> TaskAppClient:
         await self._ensure_client()
         return self
 
@@ -53,8 +53,8 @@ class TaskAppClient:
             )
         return self._client
 
-    def _headers(self) -> Dict[str, str]:
-        headers: Dict[str, str] = {}
+    def _headers(self) -> dict[str, str]:
+        headers: dict[str, str] = {}
         # Primary key
         primary = (self.api_key or "").strip()
         if primary:
@@ -85,7 +85,7 @@ class TaskAppClient:
         method: str,
         path: str,
         *,
-        params: Optional[Dict[str, Any] | List[tuple[str, Any]]] = None,
+        params: dict[str, Any] | list[tuple[str, Any]] | None = None,
         json_payload: Any = None,
     ) -> httpx.Response:
         client = await self._ensure_client()
@@ -118,16 +118,16 @@ class TaskAppClient:
             raise last_exc
         raise RuntimeError("Unreachable code in TaskAppClient._request")
 
-    async def health(self) -> Dict[str, Any]:
+    async def health(self) -> dict[str, Any]:
         response = await self._request("GET", "/health")
         return response.json()
 
-    async def info(self) -> Dict[str, Any]:
+    async def info(self) -> dict[str, Any]:
         response = await self._request("GET", "/info")
         return response.json()
 
     async def task_info(self, seeds: list[int] | None = None) -> TaskInfo | list[TaskInfo]:
-        params: Optional[List[tuple[str, Any]]] = None
+        params: list[tuple[str, Any]] | None = None
         if seeds:
             params = [("seed", seed) for seed in seeds]
         response = await self._request("GET", "/task_info", params=params)
@@ -146,19 +146,21 @@ class _TaskAppEnvironmentClient:
     def __init__(self, client: TaskAppClient) -> None:
         self._client = client
 
-    async def initialize(self, env_name: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+    async def initialize(self, env_name: str, payload: dict[str, Any]) -> dict[str, Any]:
         response = await self._client._request(
             "POST", f"/env/{env_name}/initialize", json_payload=payload
         )
         return response.json()
 
-    async def step(self, env_name: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+    async def step(self, env_name: str, payload: dict[str, Any]) -> dict[str, Any]:
         response = await self._client._request(
             "POST", f"/env/{env_name}/step", json_payload=payload
         )
         return response.json()
 
-    async def terminate(self, env_name: str, payload: Dict[str, Any] | None = None) -> Dict[str, Any]:
+    async def terminate(
+        self, env_name: str, payload: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
         response = await self._client._request(
             "POST", f"/env/{env_name}/terminate", json_payload=payload or {}
         )

synth_ai/task/contracts.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Optional, Any, Dict, List, Literal
+from typing import Any, Literal
+
 from pydantic import BaseModel, Field
 
 
@@ -40,23 +41,24 @@ class TaskAppContract:
     """
 
     base_url: str
-    env_name: Optional[str] = None
+    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: Optional[str] = None
-    env_name: Optional[str] = None
-    config: Dict[str, Any] = {}
-    seed: Optional[int] = None
+    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: Optional[str] = None
-    policy_name: Optional[str] = None
-    config: Dict[str, Any] = {}
+    policy_id: str | None = None
+    policy_name: str | None = None
+    config: dict[str, Any] = Field(default_factory=dict)
 
 
 class RolloutRecordConfig(BaseModel):
@@ -76,60 +78,60 @@ class RolloutRequest(BaseModel):
     run_id: str
     env: RolloutEnvSpec
     policy: RolloutPolicySpec
-    ops: List[Dict[str, Any]] | List[str]
+    ops: list[dict[str, Any]] | list[str]
     record: RolloutRecordConfig = RolloutRecordConfig()
     on_done: str = "reset"
     safety: RolloutSafetyConfig = RolloutSafetyConfig()
-    training_session_id: Optional[str] = None
-    synth_base_url: Optional[str] = None
+    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: Optional[float] = None
+    obs: dict[str, Any]
+    tool_calls: list[dict[str, Any]]
+    reward: float | None = None
     done: bool = False
-    truncated: Optional[bool] = None
-    info: Optional[Dict[str, Any]] = None
+    truncated: bool | None = None
+    info: dict[str, Any] | None = None
 
 
 class RolloutTrajectory(BaseModel):
     env_id: str
     policy_id: str
-    steps: List[RolloutStep]
-    final: Optional[Dict[str, Any]] = None
+    steps: list[RolloutStep]
+    final: dict[str, Any] | None = None
     length: int
 
 
 class RolloutMetrics(BaseModel):
-    episode_returns: List[float]
+    episode_returns: list[float]
     mean_return: float
     num_steps: int
     num_episodes: int = 0
-    outcome_score: Optional[float] = None
-    events_score: Optional[float] = None
-    details: Dict[str, Any] = Field(default_factory=dict)
+    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]] = {}
+    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
+    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]
+    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,8 +1,9 @@
-from __future__ import annotations
-
 """Dataset registry and helpers shared by Task Apps."""
 
-from typing import Any, Callable, Dict, Hashable, Tuple
+from __future__ import annotations
+
+from collections.abc import Callable, Hashable
+from typing import Any
 
 from pydantic import BaseModel, Field, field_validator
 
@@ -34,10 +35,12 @@ 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] = {}
+        self._entries: dict[str, tuple[TaskDatasetSpec, RegistryLoader, bool]] = {}
+        self._cache: dict[Hashable, Any] = {}
 
-    def register(self, spec: TaskDatasetSpec, loader: RegistryLoader, *, cache: bool = True) -> None:
+    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)