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

examples/warming_up_to_rl/task_app/synth_envs_hosted/envs/crafter/shared.py

@@ -8,10 +8,11 @@ rendered surroundings appeared only as iron/stone due to a mismatched
 hardcoded mapping.
 """
 
-from typing import Dict, Any, List, Set
-import numpy as np
-import re
 import itertools
+import re
+from typing import Any
+
+import numpy as np
 
 VIEW_SIZE = 5  # Default view size for the map (match eval_rollout_table)
 
@@ -58,9 +59,9 @@ ACTION_ALIASES = {
     "craft_iron_sword": "make_iron_sword",
 }
 
-VALID_PRIMARY_ACTIONS: Set[str] = set(CRAFTER_ACTIONS.keys())
-VALID_ACTION_ALIASES: Set[str] = set(ACTION_ALIASES.keys())
-ALL_VALID_ACTION_STRINGS: Set[str] = VALID_PRIMARY_ACTIONS | VALID_ACTION_ALIASES
+VALID_PRIMARY_ACTIONS: set[str] = set(CRAFTER_ACTIONS.keys())
+VALID_ACTION_ALIASES: set[str] = set(ACTION_ALIASES.keys())
+ALL_VALID_ACTION_STRINGS: set[str] = VALID_PRIMARY_ACTIONS | VALID_ACTION_ALIASES
 
 
 def validate_action(action: str) -> bool:
@@ -69,7 +70,7 @@ def validate_action(action: str) -> bool:
     return normalized in ALL_VALID_ACTION_STRINGS
 
 
-def parse_actions(action_text: str) -> List[str]:
+def parse_actions(action_text: str) -> list[str]:
     """Extract actions from response text.
 
     Tries multiple parsing strategies:
@@ -79,7 +80,6 @@ def parse_actions(action_text: str) -> List[str]:
     4. Plain action names if they match valid actions
     5. Newline-separated actions
     """
-    import json
 
     # First try the original <action> tag format
     matches = re.findall(r"<action>(.*?)</action>", action_text, re.IGNORECASE)
@@ -132,7 +132,7 @@ def parse_actions(action_text: str) -> List[str]:
     return actions
 
 
-def format_observation(obs_data: Dict[str, Any], step_count: int = 0, max_steps: int = 100) -> str:
+def format_observation(obs_data: dict[str, Any], step_count: int = 0, max_steps: int = 100) -> str:
     """Format a Crafter observation dictionary into a human-readable string.
 
     This is critical for preventing massive token counts when observations
@@ -154,11 +154,11 @@ def format_observation(obs_data: Dict[str, Any], step_count: int = 0, max_steps:
         if obs_data.get("steps") is not None
         else obs_data.get("num_steps_taken")
     )
-    if isinstance(step_from_obs, (int, float)) and step_from_obs >= 0:
+    if isinstance(step_from_obs, int | float) and step_from_obs >= 0:
         step_count = int(step_from_obs)
 
     max_steps_from_obs = obs_data.get("max_steps_episode") or obs_data.get("max_steps")
-    if isinstance(max_steps_from_obs, (int, float)) and max_steps_from_obs > 0:
+    if isinstance(max_steps_from_obs, int | float) and max_steps_from_obs > 0:
         max_steps = int(max_steps_from_obs)
 
     # Format inventory (skip health as it's shown separately)
@@ -255,7 +255,7 @@ _FALLBACK_ID_TO_NAME = {
 }
 
 
-def _format_semantic_map_view(obs_data: Dict[str, Any], view_size: int = VIEW_SIZE) -> str:
+def _format_semantic_map_view(obs_data: dict[str, Any], view_size: int = VIEW_SIZE) -> str:
     """Format the semantic map into a text representation using dynamic IDs.
 
     Shows a local view around the player with nearby objects.
@@ -280,9 +280,9 @@ def _format_semantic_map_view(obs_data: Dict[str, Any], view_size: int = VIEW_SI
     use_list = isinstance(_ID_TO_NAME, list) and len(_ID_TO_NAME) > 0
 
     # Build matrix centered at player, then transpose for human-friendly view
-    matrix: List[List[str]] = []
+    matrix: list[list[str]] = []
     for dy in range(-half, half + 1):
-        row_tokens: List[str] = []
+        row_tokens: list[str] = []
         for dx in range(-half, half + 1):
             x, y = px + dx, py + dy
             if not (0 <= x < sem_arr.shape[0] and 0 <= y < sem_arr.shape[1]):
@@ -298,8 +298,8 @@ def _format_semantic_map_view(obs_data: Dict[str, Any], view_size: int = VIEW_SI
                 row_tokens.append(name)
         matrix.append(row_tokens)
 
-    transposed = list(zip(*matrix))
-    grid_rows: List[str] = [" ".join(row) for row in transposed]
+    transposed = list(zip(*matrix, strict=False))
+    grid_rows: list[str] = [" ".join(row) for row in transposed]
     return (
         "\nLocal Map View (" + str(view_size) + "x" + str(view_size) + "):\n" + "\n".join(grid_rows)
     )

examples/warming_up_to_rl/task_app/synth_envs_hosted/hosted_app.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
+import contextlib
 import os
-from typing import Optional
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
@@ -15,9 +15,9 @@ class TaskApp:
 
     def __init__(
         self,
-        service_base_url: Optional[str] = None,
-        vllm_base_url: Optional[str] = None,
-        default_model: Optional[str] = None,
+        service_base_url: str | None = None,
+        vllm_base_url: str | None = None,
+        default_model: str | None = None,
     ) -> None:
         self.service_base_url = service_base_url or os.getenv(
             "SERVICE_BASE_URL", "http://localhost:8000"
@@ -67,38 +67,39 @@ def create_app(allowed_environments: list[str] = None) -> FastAPI:
         @app.middleware("http")
         async def validate_environment(request, call_next):
             # Check if this is an environment-related request
-            if request.url.path.startswith("/env/") or request.url.path.startswith("/rollout"):
-                # Extract environment name from request body for POST requests
-                if request.method == "POST":
-                    # We need to read the body to check env_name
-                    body = await request.body()
-                    try:
-                        import json
-
-                        data = json.loads(body) if body else {}
-                        env_name = data.get("env_name", "").lower()
-
-                        # Check if environment is allowed
-                        if env_name and env_name not in [e.lower() for e in allowed_environments]:
-                            from fastapi import HTTPException
-
-                            raise HTTPException(
-                                status_code=403,
-                                detail=f"Environment '{env_name}' not allowed. This service only handles: {allowed_environments}",
-                            )
-                    except json.JSONDecodeError:
-                        pass  # Invalid JSON, let the endpoint handle it
-
-                    # Recreate request with the body we consumed
-                    request._body = body
+            path = request.url.path
+            if (
+                path.startswith("/env/") or path.startswith("/rollout")
+            ) and request.method == "POST":
+                # We need to read the body to check env_name
+                body = await request.body()
+                try:
+                    import json
+
+                    data = json.loads(body) if body else {}
+                    env_name = data.get("env_name", "").lower()
+
+                    # Check if environment is allowed
+                    if env_name and env_name not in [e.lower() for e in allowed_environments]:
+                        from fastapi import HTTPException
+
+                        raise HTTPException(
+                            status_code=403,
+                            detail=f"Environment '{env_name}' not allowed. This service only handles: {allowed_environments}",
+                        )
+                except json.JSONDecodeError:
+                    pass  # Invalid JSON, let the endpoint handle it
+
+                # Recreate request with the body we consumed
+                request._body = body
 
             response = await call_next(request)
             return response
 
     # Mount routers
+    from .branching import router as branching_router
     from .environment_routes import router as env_router
     from .rollout import router as rollout_router
-    from .branching import router as branching_router
 
     app.include_router(env_router, prefix="/env", tags=["environment"])
 
@@ -109,10 +110,8 @@ def create_app(allowed_environments: list[str] = None) -> FastAPI:
         app.include_router(policy_router, prefix="/policy", tags=["policy"])
     except Exception as _e:
         # Log lightweight message; policy endpoints will be unavailable
-        try:
+        with contextlib.suppress(Exception):
             print(f"[hosted_app] Skipping policy routes: {_e}", flush=True)
-        except Exception:
-            pass
 
     app.include_router(rollout_router, tags=["rollout"])
     app.include_router(branching_router, tags=["branching"])
@@ -148,7 +147,6 @@ def create_app(allowed_environments: list[str] = None) -> FastAPI:
         - If X-API-Key header is provided and mismatches, returns 401.
         - Otherwise returns 200 with basic info.
         """
-        import os as _os
 
         # Check if any environment API keys are configured
         from synth_ai.task.auth import allowed_environment_api_keys
@@ -190,7 +188,7 @@ def create_app(allowed_environments: list[str] = None) -> FastAPI:
         try:
             hdr = request.headers
             snapshot = {
-                "path": str(getattr(request, "url").path),
+                "path": str(request.url.path),
                 "have_x_api_key": bool(hdr.get("x-api-key")),
                 "have_x_api_keys": bool(hdr.get("x-api-keys")),
                 "have_authorization": bool(hdr.get("authorization")),

examples/warming_up_to_rl/task_app/synth_envs_hosted/inference/openai_client.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import logging
-from typing import Any, Dict, Optional
+from typing import Any
 
 import httpx
 
@@ -15,7 +16,7 @@ class OpenAIClient:
     def __init__(
         self,
         base_url: str,
-        api_key: Optional[str] = None,
+        api_key: str | None = None,
         timeout_s: float = 120.0,
     ) -> None:
         self.base_url = base_url.rstrip("/")
@@ -27,8 +28,8 @@ class OpenAIClient:
             self.headers["Authorization"] = f"Bearer {api_key}"
 
     def _fix_model_parameters(
-        self, request: Dict[str, Any], target_url: Optional[str] = None
-    ) -> Dict[str, Any]:
+        self, request: dict[str, Any], target_url: str | None = None
+    ) -> dict[str, Any]:
         """
         Fix parameter compatibility for newer OpenAI models.
 
@@ -91,9 +92,25 @@ class OpenAIClient:
                 try:
                     tools = fixed_request.get("tools")
                     if isinstance(tools, list) and tools:
+                        # Choose the first provided function name from tools schema (e.g., run_command)
+                        func_name = None
+                        for t in tools:
+                            try:
+                                cand = None
+                                if isinstance(t, dict):
+                                    f = t.get("function")
+                                    if isinstance(f, dict):
+                                        cand = f.get("name")
+                                if isinstance(cand, str) and cand:
+                                    func_name = cand
+                                    break
+                            except Exception:
+                                continue
+                        if not func_name:
+                            func_name = "run_command"
                         fixed_request["tool_choice"] = {
                             "type": "function",
-                            "function": {"name": "interact_many"},
+                            "function": {"name": func_name},
                         }
                         fixed_request["parallel_tool_calls"] = False
                 except Exception:
@@ -103,11 +120,11 @@ class OpenAIClient:
 
     async def generate(
         self,
-        request: Dict[str, Any],
-        base_url: Optional[str] = None,
-        timeout_s: Optional[float] = None,
-        extra_headers: Optional[Dict[str, str]] = None,
-    ) -> Dict[str, Any]:
+        request: dict[str, Any],
+        base_url: str | None = None,
+        timeout_s: float | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
         """
         Send a chat completion request to the inference server.
 
@@ -135,18 +152,15 @@ class OpenAIClient:
         logger.info(f"Inference POST target: {url}")
         if extra_headers:
             logger.info(f"Extra headers: {extra_headers}")
-        try:
-            keys_preview = sorted(list(processed_request.keys()))
+        with contextlib.suppress(Exception):
+            keys_preview = sorted(processed_request.keys())
             logger.info(f"Request keys: {keys_preview}")
-        except Exception:
-            pass
 
         # Final hard-guard for OpenAI: ensure unsupported field is not present
         try:
-            if "openai" in url.lower():
-                if "stop_after_tool_calls" in processed_request:
-                    processed_request.pop("stop_after_tool_calls", None)
-                    logger.info("Removed stop_after_tool_calls for OpenAI request")
+            if "openai" in url.lower() and "stop_after_tool_calls" in processed_request:
+                processed_request.pop("stop_after_tool_calls", None)
+                logger.info("Removed stop_after_tool_calls for OpenAI request")
             # Groq-specific requirement: when using JSON mode, one of the messages must contain the word 'json'
             low_url = url.lower()
             if ("groq.com" in low_url or "/openai" in low_url) and isinstance(
@@ -284,7 +298,7 @@ class OpenAIClient:
                                         processed_request.pop(k, None)
                                     # Force structured tool choice
                                     if processed_request.get("tool_choice") == "required":
-                                        func_name = "interact_many"
+                                        func_name = "run_command"
                                         try:
                                             tools_arr = processed_request.get("tools") or []
                                             if isinstance(tools_arr, list) and tools_arr:
@@ -367,9 +381,9 @@ class OpenAIClient:
 
     async def check_health(
         self,
-        base_url: Optional[str] = None,
-        timeout_s: Optional[float] = None,
-    ) -> Dict[str, Any]:
+        base_url: str | None = None,
+        timeout_s: float | None = None,
+    ) -> dict[str, Any]:
         """
         Check if the inference service is healthy.
 
@@ -403,13 +417,13 @@ class OpenAIClient:
 
     async def generate_with_retries(
         self,
-        request: Dict[str, Any],
-        base_url: Optional[str] = None,
-        timeout_s: Optional[float] = None,
+        request: dict[str, Any],
+        base_url: str | None = None,
+        timeout_s: float | None = None,
         max_retries: int = 4,
         backoff_factor: float = 2.0,
-        extra_headers: Optional[Dict[str, str]] = None,
-    ) -> Dict[str, Any]:
+        extra_headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
         """
         Generate with exponential backoff retries for transient errors.
 
@@ -482,7 +496,7 @@ class OpenAIClient:
                             ) from e
                     except Exception:
                         # If we can't parse the response, don't retry 400 errors
-                        try:
+                        with contextlib.suppress(Exception):
                             logger.error(
                                 {
                                     "non_overload_400_unparsed": True,
@@ -490,8 +504,6 @@ class OpenAIClient:
                                     "payload": processed_request,
                                 }
                             )
-                        except Exception:
-                            pass
                         raise RuntimeError(
                             f"Inference 400 response (unparsed): {e.response.text if e.response is not None else 'Bad Request'}"
                         ) from e
@@ -528,7 +540,7 @@ class OpenAIClient:
 
 def create_inference_client(
     task_app: Any,
-    api_key: Optional[str] = None,
+    api_key: str | None = None,
 ) -> OpenAIClient:
     """
     Create an inference client using TaskApp configuration.
@@ -549,6 +561,57 @@ def create_inference_client(
         except Exception:
             api_key = None
 
+    import json as _json
+    import os as _os
+    import time as _time
+
+    if _os.getenv("SYNTH_FAKE_INFERENCE", "").strip():
+
+        class _DummyClient:
+            async def generate_with_retries(
+                self,
+                request: dict[str, Any],
+                base_url: str | None = None,
+                max_retries: int = 0,
+                backoff_factor: float = 1.0,
+                extra_headers: dict[str, str] | None = None,
+            ) -> dict[str, Any]:
+                tool_call = {
+                    "id": "call_dummy",
+                    "type": "function",
+                    "function": {
+                        "name": "interact_many",
+                        "arguments": _json.dumps({"actions": ["move_right"]}),
+                    },
+                }
+                return {
+                    "id": f"cmpl-{int(_time.time())}",
+                    "object": "chat.completion",
+                    "created": int(_time.time()),
+                    "model": request.get("model") or "dummy-model",
+                    "choices": [
+                        {
+                            "index": 0,
+                            "message": {
+                                "role": "assistant",
+                                "content": "",
+                                "tool_calls": [tool_call],
+                            },
+                            "finish_reason": "tool_calls",
+                        }
+                    ],
+                    "usage": {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15},
+                }
+
+            async def check_health(
+                self,
+                base_url: str | None = None,
+                timeout_s: float | None = None,
+            ) -> dict[str, Any]:
+                return {"status": "ok", "dummy": True}
+
+        return _DummyClient()
+
     return OpenAIClient(
         base_url=task_app.vllm_base_url,
         api_key=api_key,

examples/warming_up_to_rl/task_app/synth_envs_hosted/main.py

@@ -12,7 +12,6 @@ For Modal deployment:
 from __future__ import annotations
 
 import os
-from typing import Optional
 
 import modal
 
@@ -26,7 +25,6 @@ except ImportError:
 
 from synth_envs_hosted.hosted_app import create_app
 
-
 # Local development mode
 if __name__ == "__main__":
     import uvicorn