synth-ai 0.2.9.dev7__py3-none-any.whl → 0.2.9.dev9__py3-none-any.whl

examples/warming_up_to_rl/run_eval.py

@@ -7,16 +7,19 @@ Baseline evaluation script (public-friendly skeleton)
 """
 
 from __future__ import annotations
-import os
+
+import argparse
+import asyncio
+import contextlib
 import json
+import os
 import re
-from typing import Any, Dict, List, Optional
-from collections import Counter
-import asyncio
-import httpx
-import argparse
 import tomllib
+from collections import Counter
 from pathlib import Path
+from typing import Any
+
+import httpx
 
 
 class TaskAppClient:
@@ -25,12 +28,12 @@ class TaskAppClient:
     This is a public-friendly shim for examples, pending SDK surface consolidation.
     """
 
-    def __init__(self, base_url: str, api_key: Optional[str] = None) -> None:
+    def __init__(self, base_url: str, api_key: str | None = None) -> None:
         self.base_url = base_url.rstrip("/")
         self.api_key = api_key
-        self._client: Optional[httpx.AsyncClient] = None
+        self._client: httpx.AsyncClient | None = None
 
-    async def __aenter__(self) -> "TaskAppClient":
+    async def __aenter__(self) -> TaskAppClient:
         headers = {}
         if self.api_key:
             headers["X-API-Key"] = self.api_key
@@ -56,9 +59,9 @@ class TaskAppClient:
             )
         return self._client
 
-    async def initialize(self, env_name: str, config: Dict[str, Any]) -> Dict[str, Any]:
+    async def initialize(self, env_name: str, config: dict[str, Any]) -> dict[str, Any]:
         """POST /env/{env_name}/initialize (compat route supported in task app)."""
-        payload: Dict[str, Any] = {
+        payload: dict[str, Any] = {
             "seed": config.get("seed"),
         }
         # Allow both world_config and config inputs; env routes will normalize difficulty
@@ -71,30 +74,30 @@ class TaskAppClient:
         return resp.json()
 
     async def step(
-        self, env_name: str, env_id: str, tool_calls: List[Dict[str, Any]]
-    ) -> Dict[str, Any]:
+        self, env_name: str, env_id: str, tool_calls: list[dict[str, Any]]
+    ) -> dict[str, Any]:
         """POST /env/{env_name}/step with wrapped tool_calls in action."""
         payload = {"env_id": env_id, "action": {"tool_calls": tool_calls}}
         resp = await self.client.post(f"/env/{env_name}/step", json=payload)
         resp.raise_for_status()
         return resp.json()
 
-    async def terminate(self, env_name: str, env_id: str) -> Dict[str, Any]:
+    async def terminate(self, env_name: str, env_id: str) -> dict[str, Any]:
         resp = await self.client.post(f"/env/{env_name}/terminate", json={"env_id": env_id})
         resp.raise_for_status()
         return resp.json()
 
-    async def get_info(self) -> Dict[str, Any]:
+    async def get_info(self) -> dict[str, Any]:
         resp = await self.client.get("/info")
         resp.raise_for_status()
         return resp.json()
 
-    async def proxy_groq_chat(self, payload: Dict[str, Any]) -> Dict[str, Any]:
+    async def proxy_groq_chat(self, payload: dict[str, Any]) -> dict[str, Any]:
         resp = await self.client.post("/proxy/groq/v1/chat/completions", json=payload)
         resp.raise_for_status()
         return resp.json()
 
-    async def vllm_chat(self, vllm_base_url: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+    async def vllm_chat(self, vllm_base_url: str, payload: dict[str, Any]) -> dict[str, Any]:
         async with httpx.AsyncClient(base_url=vllm_base_url.rstrip("/"), timeout=60.0) as c:
             resp = await c.post("/v1/chat/completions", json=payload)
             # Do not raise for status to surface body in errors
@@ -114,13 +117,13 @@ class TaskAppClient:
         seed: int,
         difficulty: str,
         policy_name: str,
-        policy_config: Dict[str, Any],
+        policy_config: dict[str, Any],
         max_turns: int,
-    ) -> Dict[str, Any]:
-        ops: List[str] = []
+    ) -> dict[str, Any]:
+        ops: list[str] = []
         for _ in range(max_turns):
             ops.extend(["agent", "env"])
-        payload: Dict[str, Any] = {
+        payload: dict[str, Any] = {
             "run_id": run_id,
             "env": {
                 "env_name": env_name,
@@ -150,7 +153,7 @@ MAX_TURNS = int(os.getenv("MAX_TURNS", "10"))
 CONCURRENCY = int(os.getenv("CONCURRENCY", "1"))
 
 
-def _interact_tool_schema() -> List[Dict[str, Any]]:
+def _interact_tool_schema() -> list[dict[str, Any]]:
     return [
         {
             "type": "function",
@@ -171,13 +174,12 @@ def _interact_tool_schema() -> List[Dict[str, Any]]:
 
 
 def _build_messages_from_observation(
-    observation: Dict[str, Any], history: List[Dict[str, Any]]
-) -> List[Dict[str, Any]]:
+    observation: dict[str, Any], history: list[dict[str, Any]]
+) -> list[dict[str, Any]]:
     inv = observation.get("inventory") or {}
     pos = observation.get("player_position") or []
     ach = observation.get("achievements_status") or {}
-    turns_taken = observation.get("num_steps_taken") or 0
-    user_lines: List[str] = []
+    user_lines: list[str] = []
     user_lines.append("Environment: CrafterClassic")
     user_lines.append(f"Player position: {pos}")
     user_lines.append(f"Inventory: {json.dumps(inv, ensure_ascii=False)}")
@@ -193,7 +195,7 @@ def _build_messages_from_observation(
     return [{"role": "user", "content": content}]
 
 
-def _parse_tool_calls_from_openai_response(data: Dict[str, Any]) -> List[str]:
+def _parse_tool_calls_from_openai_response(data: dict[str, Any]) -> list[str]:
     try:
         choices = data.get("choices")
         if isinstance(choices, list) and choices:
@@ -248,11 +250,11 @@ async def _choose_actions_via_llm(
     client: TaskAppClient,
     provider: str,
     model: str,
-    observation: Dict[str, Any],
-    history: List[Dict[str, Any]],
-) -> List[str]:
+    observation: dict[str, Any],
+    history: list[dict[str, Any]],
+) -> list[str]:
     messages = _build_messages_from_observation(observation, history)
-    payload: Dict[str, Any] = {
+    payload: dict[str, Any] = {
         "model": model,
         "messages": messages,
         "tools": _interact_tool_schema(),
@@ -279,8 +281,8 @@ async def _choose_actions_via_llm(
     return actions or []
 
 
-def _expand_actions_to_tool_calls(actions: List[str]) -> List[Dict[str, Any]]:
-    out: List[Dict[str, Any]] = []
+def _expand_actions_to_tool_calls(actions: list[str]) -> list[dict[str, Any]]:
+    out: list[dict[str, Any]] = []
     for a in actions[:5]:
         out.append({"tool": "interact", "args": {"action": a}})
     return out
@@ -293,9 +295,7 @@ def _detect_provider(model: str) -> str:
     return "vllm"
 
 
-def _rollout_inference_url_from_cfg(
-    cfg: Dict[str, Any], default_vllm: Optional[str]
-) -> Optional[str]:
+def _rollout_inference_url_from_cfg(cfg: dict[str, Any], default_vllm: str | None) -> str | None:
     # Prefer explicit inference_url in TOML; else fall back to discovered vLLM base
     url = cfg.get("inference_url")
     if isinstance(url, str) and url:
@@ -303,14 +303,14 @@ def _rollout_inference_url_from_cfg(
     return default_vllm
 
 
-async def eval_episode(client: TaskAppClient, seed: int) -> Dict[str, Any]:
+async def eval_episode(client: TaskAppClient, seed: int) -> dict[str, Any]:
     env_name = "CrafterClassic"
-    history: List[Dict[str, Any]] = []
+    history: list[dict[str, Any]] = []
     achievements: set[str] = set()
     turns = 0
 
     # Initialize environment
-    init_cfg: Dict[str, Any] = {
+    init_cfg: dict[str, Any] = {
         "seed": seed,
         "world_config": {"difficulty": os.getenv("DIFFICULTY", "easy")},
     }
@@ -343,10 +343,8 @@ async def eval_episode(client: TaskAppClient, seed: int) -> Dict[str, Any]:
                 if isinstance(nxt, dict):
                     observation = nxt
     finally:
-        try:
+        with contextlib.suppress(Exception):
             await client.terminate(env_name, env_id)
-        except Exception:
-            pass
 
     return {"seed": seed, "turns": turns, "achievements": sorted(achievements)}
 
@@ -377,7 +375,7 @@ async def main() -> None:
     args = parser.parse_args()
 
     global TASK_APP_URL, MODEL, NUM_EPISODES, MAX_TURNS, CONCURRENCY
-    cfg: Dict[str, Any] = {}
+    cfg: dict[str, Any] = {}
     if args.toml:
         with open(args.toml, "rb") as f:
             cfg = tomllib.load(f)
@@ -418,7 +416,7 @@ async def main() -> None:
                     try:
                         run_id = f"eval-{seed}"
                         # Build policy config from TOML (explicit control; no server-side guessing)
-                        policy_cfg: Dict[str, Any] = {
+                        policy_cfg: dict[str, Any] = {
                             "model": cfg.get("model", MODEL),
                             "inference_url": inf_url,
                         }

examples/warming_up_to_rl/run_fft_and_save.py

@@ -6,14 +6,12 @@ import json
 import os
 import sys
 import time
+import tomllib
 from pathlib import Path
-from typing import Any, Dict, Tuple, List
+from typing import Any
 
-import tomllib
-import re
 import requests
 from dotenv import load_dotenv
-
 from synth_ai.config.base_url import PROD_BASE_URL_DEFAULT
 
 
@@ -25,7 +23,7 @@ def mask(val: str) -> str:
 
 def post_multipart(
     base: str, api_key: str, path: str, file_field: str, filepath: Path
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Upload a file, trying backend-specific endpoints with fallbacks.
 
     Priority:
@@ -40,7 +38,7 @@ def post_multipart(
         f"{base.rstrip('/')}/{path.lstrip('/')}",  # e.g., /learning/files
         f"{base.rstrip('/')}/files",  # OpenAI-style
     ]
-    last_err: Dict[str, Any] | None = None
+    last_err: dict[str, Any] | None = None
     for ep in endpoints:
         try:
             r = requests.post(ep, headers=headers, files=files, data=data, timeout=300)
@@ -72,7 +70,7 @@ def post_multipart(
     return last_err or {"error": True, "detail": "upload_failed_all_endpoints"}
 
 
-def post_json(base: str, api_key: str, path: str, body: Dict[str, Any]) -> Dict[str, Any]:
+def post_json(base: str, api_key: str, path: str, body: dict[str, Any]) -> dict[str, Any]:
     url = f"{base.rstrip('/')}/{path.lstrip('/')}"
     headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
     r = requests.post(url, headers=headers, data=json.dumps(body), timeout=120)
@@ -82,7 +80,7 @@ def post_json(base: str, api_key: str, path: str, body: Dict[str, Any]) -> Dict[
         return {"status": r.status_code, "text": r.text[:400]}
 
 
-def get_json(base: str, api_key: str, path: str) -> Dict[str, Any]:
+def get_json(base: str, api_key: str, path: str) -> dict[str, Any]:
     url = f"{base.rstrip('/')}/{path.lstrip('/')}"
     headers = {"Authorization": f"Bearer {api_key}"}
     r = requests.get(url, headers=headers, timeout=30)
@@ -92,9 +90,9 @@ def get_json(base: str, api_key: str, path: str) -> Dict[str, Any]:
         return {"status": r.status_code, "text": r.text[:400]}
 
 
-def _find_fft_configs() -> List[Path]:
+def _find_fft_configs() -> list[Path]:
     """Find FFT TOML configs in standard locations."""
-    candidates: List[Path] = []
+    candidates: list[Path] = []
 
     # Check current directory configs/
     cwd = Path.cwd()
@@ -206,10 +204,7 @@ def main() -> None:
             # Try relative to cwd first, then relative to config directory
             cwd_relative = Path.cwd() / p
             config_relative = config_path.parent / p
-            if cwd_relative.exists():
-                p = cwd_relative.resolve()
-            else:
-                p = config_relative.resolve()
+            p = cwd_relative.resolve() if cwd_relative.exists() else config_relative.resolve()
         data_file = p
     if data_file is None:
         print("Missing dataset path in --data or [job].data", file=sys.stderr)
@@ -274,7 +269,7 @@ def main() -> None:
                 )
 
     # 2) Build job payload
-    hp_block: Dict[str, Any] = {
+    hp_block: dict[str, Any] = {
         "n_epochs": int(hp_cfg.get("n_epochs") or 1),
     }
     # Optional extras if present
@@ -295,7 +290,7 @@ def main() -> None:
     if parallel:
         hp_block["parallelism"] = parallel
 
-    compute_block: Dict[str, Any] = {}
+    compute_block: dict[str, Any] = {}
     for k in ("gpu_type", "gpu_count", "nodes"):
         if k in compute_cfg:
             compute_block[k] = compute_cfg[k]

examples/warming_up_to_rl/run_local_rollout.py

@@ -7,14 +7,12 @@ import argparse
 import asyncio
 import json
 import os
+import sys
 from pathlib import Path
 from typing import Any
 
-import sys
-
 import httpx
 from dotenv import load_dotenv
-
 from synth_ai.task import (
     RolloutEnvSpec,
     RolloutPolicySpec,

examples/warming_up_to_rl/run_local_rollout_modal.py

@@ -7,14 +7,12 @@ import argparse
 import asyncio
 import json
 import os
+import sys
 from pathlib import Path
 from typing import Any
 
-import sys
-
 import httpx
 from dotenv import load_dotenv
-
 from synth_ai.task import (
     RolloutEnvSpec,
     RolloutPolicySpec,
@@ -122,7 +120,7 @@ async def main() -> None:
     base_url = args.base_url
     if args.base_url == "http://localhost:8010":
         print("\nTask app configuration:")
-        base_url_input = input(f"Task app base URL [http://localhost:8001]: ").strip()
+        base_url_input = input("Task app base URL [http://localhost:8001]: ").strip()
         base_url = base_url_input if base_url_input else "http://localhost:8001"
 
     model = args.model

examples/warming_up_to_rl/run_local_rollout_parallel.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 
 import argparse
 import asyncio
-import json
 import os
 from collections import Counter
 from pathlib import Path
@@ -13,15 +12,13 @@ from statistics import mean, median
 from typing import Any
 
 from dotenv import load_dotenv
-
-from synth_ai.task import TaskAppClient
-
 from synth_ai.task import (
     RolloutEnvSpec,
     RolloutPolicySpec,
     RolloutRecordConfig,
     RolloutRequest,
     RolloutSafetyConfig,
+    TaskAppClient,
 )
 
 

examples/warming_up_to_rl/run_local_rollout_traced.py

@@ -7,13 +7,11 @@ import argparse
 import asyncio
 import json
 import os
+import sys
 from pathlib import Path
 from typing import Any
 
-import sys
-
 import httpx
-
 from synth_ai.task import (
     RolloutEnvSpec,
     RolloutPolicySpec,
@@ -331,7 +329,7 @@ async def main() -> None:
     base_url = args.base_url
     if args.base_url == "http://localhost:8001":
         print("\nTask app configuration:")
-        base_url_input = input(f"Task app base URL [http://localhost:8001]: ").strip()
+        base_url_input = input("Task app base URL [http://localhost:8001]: ").strip()
         base_url = base_url_input if base_url_input else "http://localhost:8001"
 
     api_key = args.api_key or os.getenv("ENVIRONMENT_API_KEY")
@@ -379,7 +377,7 @@ async def main() -> None:
     print("\nRollout configuration:")
     max_llm_calls = args.max_llm_calls
     if args.max_llm_calls == 1:
-        max_llm_calls_input = input(f"Max LLM calls [10]: ").strip()
+        max_llm_calls_input = input("Max LLM calls [10]: ").strip()
         max_llm_calls = int(max_llm_calls_input) if max_llm_calls_input else 10
 
     # Override args with prompted values

examples/warming_up_to_rl/run_rl_and_save.py

@@ -5,16 +5,15 @@ import argparse
 import json
 import os
 import sys
+import tomllib
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any
 
-import tomllib
 import requests
-
 from synth_ai.config.base_url import PROD_BASE_URL_DEFAULT
 
 
-def _load_toml(path: Path) -> Dict[str, Any]:
+def _load_toml(path: Path) -> dict[str, Any]:
     if not path.exists():
         print(f"config not found: {path}", file=sys.stderr)
         sys.exit(2)
@@ -74,7 +73,7 @@ def main() -> None:
         sys.exit(2)
 
     # Build create-job payload. Send full TOML under data.config, plus endpoint_base_url.
-    payload: Dict[str, Any] = {
+    payload: dict[str, Any] = {
         "job_type": "rl",
         # Optional: compute pass-through
         "compute": cfg.get("compute", {}) if isinstance(cfg.get("compute"), dict) else {},
@@ -87,7 +86,7 @@ def main() -> None:
 
     backend = str(args.backend).rstrip("/")
     url = f"{backend}/rl/jobs"
-    api_key = (os.getenv("SYNTH_API_KEY") or os.getenv("synth_key") or "").strip()
+    api_key = (os.getenv("SYNTH_API_KEY") or os.getenv("SYNTH_KEY") or "").strip()
     if not api_key:
         print("Missing SYNTH_API_KEY in env", file=sys.stderr)
         sys.exit(2)

examples/warming_up_to_rl/run_rollout_remote.py

@@ -10,6 +10,14 @@ import os
 import sys
 
 import httpx
+from synth_ai.task import (
+    RolloutEnvSpec,
+    RolloutPolicySpec,
+    RolloutRecordConfig,
+    RolloutRequest,
+    RolloutSafetyConfig,
+    TaskAppClient,
+)
 
 
 def check_health(base_url: str, api_key: str) -> None:
@@ -30,16 +38,6 @@ def check_health(base_url: str, api_key: str) -> None:
         print(f"warning: failed to call /health: {exc}")
 
 
-from synth_ai.task import (
-    RolloutEnvSpec,
-    RolloutPolicySpec,
-    RolloutRecordConfig,
-    RolloutRequest,
-    RolloutSafetyConfig,
-    TaskAppClient,
-)
-
-
 def build_request(
     *,
     run_id: str,

examples/warming_up_to_rl/task_app/README.md

@@ -25,8 +25,12 @@ uvx synth-ai deploy grpo-crafter --name grpo-crafter-task-app
 
 Requirements:
 - Modal CLI installed and authenticated (`modal token new`).
-- Secrets `crafter-environment-sdk`, `groq-api-key`, and `openai-api-key`
-  available in your Modal account.
+- Either provide an `.env` with `ENVIRONMENT_API_KEY`, `GROQ_API_KEY`, and `OPENAI_API_KEY`
+  (recommended; pass via `--env-file`). The deploy command injects these values via an inline
+  Modal secret plus `Secret.from_dotenv`, so the minted environment key stays in sync with
+  what the CLI sends.
+- Or ensure Modal secrets `groq-api-key` and `openai-api-key` exist and continue to supply
+  model vendor credentials that way.
 
 The CLI generates a Modal entrypoint on the fly using the shared
 `TaskAppConfig`, ensuring the container matches the local FastAPI behavior.