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/storage/__init__.py

@@ -2,4 +2,4 @@
 
 from .volume import VolumeStorage, storage
 
-__all__ = ["VolumeStorage", "storage"]
+__all__ = ["VolumeStorage", "storage"]

examples/warming_up_to_rl/task_app/synth_envs_hosted/storage/volume.py

@@ -8,15 +8,15 @@ import tarfile
 import tempfile
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any
 
 
 class VolumeStorage:
     """Helpers for Modal Volume storage operations."""
-    
+
     def __init__(self, base_path: str = "/data/state") -> None:
         self.base_path = Path(base_path)
-    
+
     def get_snapshot_path(
         self,
         rl_run_id: str,
@@ -27,21 +27,15 @@ class VolumeStorage:
         # Use first 2 chars of snapshot_id for sharding
         shard1 = snapshot_id[:2] if len(snapshot_id) >= 2 else "00"
         shard2 = snapshot_id[2:4] if len(snapshot_id) >= 4 else "00"
-        
+
         return (
-            self.base_path
-            / "runs"
-            / rl_run_id
-            / kind
-            / shard1
-            / shard2
-            / f"{snapshot_id}.tar.gz"
+            self.base_path / "runs" / rl_run_id / kind / shard1 / shard2 / f"{snapshot_id}.tar.gz"
         )
-    
+
     def get_index_path(self, rl_run_id: str) -> Path:
         """Get the index file path for a run."""
         return self.base_path / "runs" / rl_run_id / "index" / "meta.jsonl"
-    
+
     def write_snapshot_atomic(
         self,
         path: Path,
@@ -50,87 +44,87 @@ class VolumeStorage:
         """Atomically write a snapshot archive to disk."""
         # Ensure parent directory exists
         path.parent.mkdir(parents=True, exist_ok=True)
-        
+
         # Write to temp file first
         tmp_path = path.with_suffix(".tmp")
         with open(tmp_path, "wb") as f:
             f.write(archive_bytes)
             f.flush()
             os.fsync(f.fileno())
-        
+
         # Atomic rename
         os.replace(tmp_path, path)
-    
+
     def create_archive(
         self,
-        state_dict: Dict[str, Any],
-        meta: Dict[str, Any],
+        state_dict: dict[str, Any],
+        meta: dict[str, Any],
     ) -> bytes:
         """Create a tar.gz archive with state and metadata."""
         with tempfile.TemporaryDirectory() as tmpdir:
             tmppath = Path(tmpdir)
-            
+
             # Write state.json
             state_path = tmppath / "state.json"
             with open(state_path, "w") as f:
                 json.dump(state_dict, f, sort_keys=True, indent=2)
-            
+
             # Write meta.json
             meta_path = tmppath / "meta.json"
             with open(meta_path, "w") as f:
                 json.dump(meta, f, sort_keys=True, indent=2)
-            
+
             # Create tar archive
             tar_path = tmppath / "archive.tar"
             with tarfile.open(tar_path, "w") as tar:
                 tar.add(state_path, arcname="state.json")
                 tar.add(meta_path, arcname="meta.json")
-            
+
             # Compress with gzip
             with open(tar_path, "rb") as f:
                 tar_bytes = f.read()
-            
+
             compressed = gzip.compress(tar_bytes, compresslevel=6)
-            
+
             return compressed
-    
-    def extract_archive(self, archive_bytes: bytes) -> tuple[Dict[str, Any], Dict[str, Any]]:
+
+    def extract_archive(self, archive_bytes: bytes) -> tuple[dict[str, Any], dict[str, Any]]:
         """Extract state and metadata from a tar.gz archive."""
         # Decompress
         tar_bytes = gzip.decompress(archive_bytes)
-        
+
         with tempfile.TemporaryDirectory() as tmpdir:
             tmppath = Path(tmpdir)
-            
+
             # Write tar bytes to temp file
             tar_path = tmppath / "archive.tar"
             with open(tar_path, "wb") as f:
                 f.write(tar_bytes)
-            
+
             # Extract tar
             with tarfile.open(tar_path, "r") as tar:
                 tar.extractall(tmppath)
-            
+
             # Read state and meta
-            with open(tmppath / "state.json", "r") as f:
+            with open(tmppath / "state.json") as f:
                 state = json.load(f)
-            
-            with open(tmppath / "meta.json", "r") as f:
+
+            with open(tmppath / "meta.json") as f:
                 meta = json.load(f)
-            
+
             return state, meta
-    
+
     def compute_snapshot_id(self, archive_bytes: bytes) -> str:
         """Compute content-addressed snapshot ID."""
         return hashlib.sha256(archive_bytes).hexdigest()
-    
+
     def save_snapshot(
         self,
         rl_run_id: str,
         kind: str,
-        state_dict: Dict[str, Any],
-        config: Optional[Dict[str, Any]] = None,
-        parent_snapshot_id: Optional[str] = None,
+        state_dict: dict[str, Any],
+        config: dict[str, Any] | None = None,
+        parent_snapshot_id: str | None = None,
     ) -> tuple[str, str, int]:
         """Save a snapshot and return (snapshot_id, path, size)."""
         # Build metadata
@@ -140,78 +134,78 @@ class VolumeStorage:
             "schema_version": "1.0",
             "created_at": datetime.utcnow().isoformat(),
         }
-        
+
         if parent_snapshot_id:
             meta["parent_snapshot_id"] = parent_snapshot_id
-        
+
         if config:
             config_str = json.dumps(config, sort_keys=True)
             meta["config_hash"] = hashlib.sha256(config_str.encode()).hexdigest()
-        
+
         # Create archive
         archive_bytes = self.create_archive(state_dict, meta)
-        
+
         # Compute snapshot ID
         snapshot_id = self.compute_snapshot_id(archive_bytes)
         meta["snapshot_id"] = snapshot_id
-        
+
         # Recreate archive with snapshot_id in metadata
         archive_bytes = self.create_archive(state_dict, meta)
-        
+
         # Get path and write
         path = self.get_snapshot_path(rl_run_id, kind, snapshot_id)
         self.write_snapshot_atomic(path, archive_bytes)
-        
+
         # Append to index
         self.append_to_index(rl_run_id, meta)
-        
+
         return snapshot_id, str(path), len(archive_bytes)
-    
+
     def load_snapshot(
         self,
         rl_run_id: str,
         kind: str,
         snapshot_id: str,
-    ) -> tuple[Dict[str, Any], Dict[str, Any]]:
+    ) -> tuple[dict[str, Any], dict[str, Any]]:
         """Load a snapshot and return (state_dict, meta)."""
         path = self.get_snapshot_path(rl_run_id, kind, snapshot_id)
-        
+
         if not path.exists():
             raise FileNotFoundError(f"Snapshot not found: {path}")
-        
+
         with open(path, "rb") as f:
             archive_bytes = f.read()
-        
+
         state, meta = self.extract_archive(archive_bytes)
         return state, meta
-    
+
     def append_to_index(
         self,
         rl_run_id: str,
-        meta: Dict[str, Any],
+        meta: dict[str, Any],
     ) -> None:
         """Append metadata to the run's index file."""
         index_path = self.get_index_path(rl_run_id)
         index_path.parent.mkdir(parents=True, exist_ok=True)
-        
+
         with open(index_path, "a") as f:
             f.write(json.dumps(meta) + "\n")
-    
-    def read_index(self, rl_run_id: str) -> list[Dict[str, Any]]:
+
+    def read_index(self, rl_run_id: str) -> list[dict[str, Any]]:
         """Read all entries from a run's index file."""
         index_path = self.get_index_path(rl_run_id)
-        
+
         if not index_path.exists():
             return []
-        
+
         entries = []
-        with open(index_path, "r") as f:
+        with open(index_path) as f:
             for line in f:
                 if line.strip():
                     entries.append(json.loads(line))
-        
+
         return entries
 
 
 # Global storage instance
-storage = VolumeStorage()
+storage = VolumeStorage()

examples/warming_up_to_rl/task_app/synth_envs_hosted/test_agents.py

@@ -16,6 +16,7 @@ This script will:
 
 import asyncio
 import os
+
 import httpx
 
 BASE_URL = os.environ.get("SYNTH_ENVS_HOSTED_URL", "http://localhost:8000")

examples/warming_up_to_rl/task_app/synth_envs_hosted/test_service.py

@@ -8,6 +8,7 @@ Run this after starting the service with:
 
 import asyncio
 import json
+
 import httpx
 
 
@@ -82,15 +83,11 @@ async def test_service():
             print(f"   Error: {response.status_code} - {response.text}")
         else:
             step_data = response.json()
-            print(
-                f"   Step result - done: {step_data['done']}, reward: {step_data.get('reward')}"
-            )
+            print(f"   Step result - done: {step_data['done']}, reward: {step_data.get('reward')}")
 
         # Test 6: Environment snapshot
         print("\n6. Creating environment snapshot...")
-        response = await client.post(
-            f"{base_url}/env/snapshot", json={"env_id": env_id}
-        )
+        response = await client.post(f"{base_url}/env/snapshot", json={"env_id": env_id})
         if response.status_code != 200:
             print(f"   Error: {response.status_code} - {response.text}")
         else:
@@ -100,9 +97,7 @@ async def test_service():
 
         # Test 7: Policy snapshot
         print("\n7. Creating policy snapshot...")
-        response = await client.post(
-            f"{base_url}/policy/snapshot", json={"policy_id": policy_id}
-        )
+        response = await client.post(f"{base_url}/policy/snapshot", json={"policy_id": policy_id})
         if response.status_code != 200:
             print(f"   Error: {response.status_code} - {response.text}")
         else:
@@ -121,9 +116,7 @@ async def test_service():
 
         # Test 9: Terminate environment
         print("\n9. Terminating environment...")
-        response = await client.post(
-            f"{base_url}/env/terminate", json={"env_id": env_id}
-        )
+        response = await client.post(f"{base_url}/env/terminate", json={"env_id": env_id})
         if response.status_code != 200:
             print(f"   Error: {response.status_code} - {response.text}")
         else:
@@ -131,9 +124,7 @@ async def test_service():
 
         # Test 10: Terminate policy
         print("\n10. Terminating policy...")
-        response = await client.post(
-            f"{base_url}/policy/terminate", json={"policy_id": policy_id}
-        )
+        response = await client.post(f"{base_url}/policy/terminate", json={"policy_id": policy_id})
         if response.status_code != 200:
             print(f"   Error: {response.status_code} - {response.text}")
         else:

examples/warming_up_to_rl/task_app/synth_envs_hosted/utils.py

@@ -1,7 +1,8 @@
 """Utility functions for the task service."""
 
+from typing import Any
+
 import numpy as np
-from typing import Any, Dict, List, Union
 
 
 def convert_numpy_to_python(obj: Any) -> Any:
@@ -22,13 +23,13 @@ def convert_numpy_to_python(obj: Any) -> Any:
         return obj.tolist()
     elif isinstance(obj, dict):
         return {key: convert_numpy_to_python(value) for key, value in obj.items()}
-    elif isinstance(obj, (list, tuple)):
+    elif isinstance(obj, list | tuple):
         return [convert_numpy_to_python(item) for item in obj]
     else:
         return obj
 
 
-def sanitize_observation(observation: Dict[str, Any]) -> Dict[str, Any]:
+def sanitize_observation(observation: dict[str, Any]) -> dict[str, Any]:
     """
     Sanitize observation data for JSON serialization.
 

synth_ai/__init__.py

@@ -5,6 +5,7 @@ Synth AI - Software for aiding the best and multiplying the will.
 # Environment exports - moved from synth-env
 from synth_ai.environments import *  # noqa
 import synth_ai.environments as environments  # expose module name for __all__
+
 try:
     from synth_ai.lm.core.main import LM  # Moved from zyk to lm for better organization
 except Exception:  # allow minimal imports (e.g., tracing) without LM stack