synth-ai 0.2.9.dev5__py3-none-any.whl → 0.2.10__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,9 +70,9 @@ 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:
     1. <action>...</action> tags (original format)
     2. [action]...[/action] or [action]... format
@@ -79,44 +80,43 @@ 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)
     if matches:
         return [m.strip() for m in matches if validate_action(m.strip())]
-    
+
     # Try [action] format
     matches = re.findall(r"\[action\](.*?)(?:\[/action\]|\n|$)", action_text, re.IGNORECASE)
     if matches:
         return [m.strip() for m in matches if validate_action(m.strip())]
-    
+
     # If no tags found, try to parse plain text
     text = action_text.strip()
-    
+
     # Check if the entire text is a valid action
     if validate_action(text):
         return [text]
-    
+
     # Try splitting by newlines and checking each line
-    lines = text.split('\n')
+    lines = text.split("\n")
     actions = []
     for line in lines:
         line = line.strip()
-        
+
         # Remove various prefixes
-        for prefix in ['ACTION:', 'Action:', 'action:', 'ACTION', '-', '*', '•', '**ACTION:**']:
+        for prefix in ["ACTION:", "Action:", "action:", "ACTION", "-", "*", "•", "**ACTION:**"]:
             if line.startswith(prefix):
-                line = line[len(prefix):].strip()
+                line = line[len(prefix) :].strip()
                 break
-        
+
         # Also handle numbered lists
-        if re.match(r'^\d+\.\s*', line):
-            line = re.sub(r'^\d+\.\s*', '', line)
-        
+        if re.match(r"^\d+\.\s*", line):
+            line = re.sub(r"^\d+\.\s*", "", line)
+
         # Split by common separators to handle multiple actions on one line
-        parts = re.split(r'[,;]|\s+and\s+|\s+then\s+', line)
-        
+        parts = re.split(r"[,;]|\s+and\s+|\s+then\s+", line)
+
         for part in parts:
             part = part.strip()
             # Remove quotes if present
@@ -124,23 +124,23 @@ def parse_actions(action_text: str) -> List[str]:
                 part = part[1:-1]
             if part.startswith("'") and part.endswith("'"):
                 part = part[1:-1]
-                
+
             # Check if it's a valid action
             if part and validate_action(part):
                 actions.append(part)
-    
+
     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
     contain large numpy arrays or deeply nested structures.
     """
     if not obs_data:
         return ""
-    
+
     # Extract key information
     health = obs_data.get("health") or obs_data.get("inventory", {}).get("health", 0)
     inventory_dict = obs_data.get("inventory", {})
@@ -154,24 +154,24 @@ 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)
     inv_items = [f"{k}:{v}" for k, v in inventory_dict.items() if v > 0 and k != "health"]
     inventory_str = ", ".join(inv_items) if inv_items else "empty"
-    
+
     # Format achievements
     achieved_list = [k for k, v in achievements.items() if v]
     achievements_str = ", ".join(achieved_list) if achieved_list else "none"
-    
+
     # Format semantic map view (simplified version)
     map_view = _format_semantic_map_view(obs_data, VIEW_SIZE)
-    
+
     return (
         f"=== CRAFTER GAME STATE ===\n"
         f"Step: {step_count}/{max_steps}\n"
@@ -184,6 +184,7 @@ def format_observation(obs_data: Dict[str, Any], step_count: int = 0, max_steps:
         f"Choose your next actions.\n"
     )
 
+
 def _try_build_dynamic_mapping():
     """Attempt to build id->name mapping from a real Crafter env.
 
@@ -232,7 +233,7 @@ def _try_build_dynamic_mapping():
 # Build dynamic mapping if possible; otherwise fall back to a basic map
 _ID_TO_NAME = _try_build_dynamic_mapping()
 _FALLBACK_ID_TO_NAME = {
-    0: "none",      # None from materials
+    0: "none",  # None from materials
     1: "water",
     2: "grass",
     3: "stone",
@@ -254,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.
@@ -279,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]):
@@ -297,6 +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]
-    return "\nLocal Map View (" + str(view_size) + "x" + str(view_size) + "):\n" + "\n".join(grid_rows)
+    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/envs/crafter/tools.py

@@ -44,4 +44,4 @@ TOOLS_SCHEMA = [
             },
         },
     }
-]
+]

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,16 +15,14 @@ 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"
         )
-        self.vllm_base_url = vllm_base_url or os.getenv(
-            "VLLM_BASE_URL", "http://localhost:8001"
-        )
+        self.vllm_base_url = vllm_base_url or os.getenv("VLLM_BASE_URL", "http://localhost:8001")
         self.default_model = default_model or os.getenv("DEFAULT_MODEL")
 
 
@@ -69,55 +67,51 @@ 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"])
 
     # Policy routes are optional; skip if optional envs are missing in this build
     try:
         from .policy_routes import router as policy_router
+
         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"])
@@ -153,10 +147,10 @@ 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
+
         allowed_keys = allowed_environment_api_keys()
         if not allowed_keys:
             # Server-side misconfiguration; rollout would fail with 503
@@ -167,28 +161,34 @@ def create_app(allowed_environments: list[str] = None) -> FastAPI:
                     "detail": "Auth not configured: missing ENVIRONMENT_API_KEY in task service environment",
                 },
             )
-        
+
         # Authorize using all header variants without typed Header params (avoid 422s)
         from synth_ai.task.auth import is_api_key_header_authorized
+
         authorized = is_api_key_header_authorized(request)
         if not authorized:
             # Soft-pass 200 with authorized=False to avoid failing CLI preflight
             primary_key = list(allowed_keys)[0] if allowed_keys else None
-            prefix = (primary_key[: max(1, len(primary_key) // 2)] if primary_key else None)
+            prefix = primary_key[: max(1, len(primary_key) // 2)] if primary_key else None
             content = {"status": "healthy", "authorized": False}
             if prefix:
                 content["expected_api_key_prefix"] = prefix
             return JSONResponse(status_code=200, content=content)
-        return {"status": "healthy", "authorized": True, "service": {"base_url": task_app.service_base_url}}
+        return {
+            "status": "healthy",
+            "authorized": True,
+            "service": {"base_url": task_app.service_base_url},
+        }
 
     # Log and surface 422 validation errors with header presence
     from fastapi.exceptions import RequestValidationError
+
     @app.exception_handler(RequestValidationError)
     async def _on_validation_error(request: Request, exc: RequestValidationError):
         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")),
@@ -197,6 +197,8 @@ def create_app(allowed_environments: list[str] = None) -> FastAPI:
             print("[422] validation", snapshot, flush=True)
         except Exception:
             pass
-        return JSONResponse(status_code=422, content={"status": "invalid", "detail": exc.errors()[:5]})
+        return JSONResponse(
+            status_code=422, content={"status": "invalid", "detail": exc.errors()[:5]}
+        )
 
     return app

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

@@ -2,4 +2,4 @@
 
 from .openai_client import OpenAIClient, create_inference_client
 
-__all__ = ["OpenAIClient", "create_inference_client"]
+__all__ = ["OpenAIClient", "create_inference_client"]