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

synth_ai/environments/examples/bandit/engine.py

@@ -191,7 +191,9 @@ class BanditEngine(StatefulEngine, IReproducibleEngine):
             step_count=self.step_count,
             max_steps=self.max_steps,
             last_arm=self.last_arm,
-            last_reward=float(reward) if reward is not None else (self.last_reward if self.step_count else None),
+            last_reward=float(reward)
+            if reward is not None
+            else (self.last_reward if self.step_count else None),
             cumulative_reward=float(self.total_reward),
             reward_history=self.reward_history.copy(),
             arm_pull_counts=self.arm_pull_counts.copy(),
@@ -238,7 +240,9 @@ class BanditEngine(StatefulEngine, IReproducibleEngine):
         engine.arm_probabilities = data.get("arm_probabilities", engine.arm_probabilities)
         engine.arm_means = data.get("arm_means", engine.arm_means)
         engine.arm_stds = data.get("arm_stds", engine.arm_stds)
-        engine.true_expected_rewards = list(data.get("true_expected_rewards", engine.true_expected_rewards))
+        engine.true_expected_rewards = list(
+            data.get("true_expected_rewards", engine.true_expected_rewards)
+        )
         engine.arm_count = len(engine.true_expected_rewards)
 
         engine.step_count = int(data.get("step_count", 0))
@@ -247,7 +251,9 @@ class BanditEngine(StatefulEngine, IReproducibleEngine):
         engine.last_arm = data.get("last_arm")
         engine.reward_history = list(data.get("reward_history", []))
         engine.arm_history = list(data.get("arm_history", []))
-        engine.arm_pull_counts = list(data.get("arm_pull_counts", [0 for _ in range(engine.arm_count)]))
+        engine.arm_pull_counts = list(
+            data.get("arm_pull_counts", [0 for _ in range(engine.arm_count)])
+        )
         engine.terminated = bool(data.get("terminated", False))
         engine.status = data.get("status", "in_progress")
 
@@ -287,7 +293,9 @@ class SynthBanditCheckpointObservationCallable(GetObservationCallable):
             "arm_count": pub.arm_count,
             "total_reward": priv.total_reward,
             "steps_taken": pub.step_count,
-            "best_expected_reward": max(priv.true_expected_rewards) if priv.true_expected_rewards else None,
+            "best_expected_reward": max(priv.true_expected_rewards)
+            if priv.true_expected_rewards
+            else None,
             "terminated": pub.terminated,
             "status": pub.status,
         }

synth_ai/environments/examples/bandit/taskset.py

@@ -156,10 +156,10 @@ async def create_bandit_taskset(
         )
 
         expected = _expected_rewards(metadata)
-        arm_count = len(expected) if expected else (
-            len(metadata.arm_probabilities or [])
-            or len(metadata.arm_means or [])
-            or 0
+        arm_count = (
+            len(expected)
+            if expected
+            else (len(metadata.arm_probabilities or []) or len(metadata.arm_means or []) or 0)
         )
         if arm_count == 0:
             arm_count = 1

synth_ai/environments/reproducibility/tree.py

@@ -256,7 +256,9 @@ class TrajectoryTreeStore:
     def reconstruct_actions(self, snap_id: str) -> tuple[Any, ...]:
         """Return the sequence of *actions* from the root → `snap_id`."""
         actions = []
-        for child, parent in zip(self.path_to_root(snap_id)[:-1], self.path_to_root(snap_id)[1:], strict=False):
+        for child, parent in zip(
+            self.path_to_root(snap_id)[:-1], self.path_to_root(snap_id)[1:], strict=False
+        ):
             actions.append(self.graph.edges[parent, child]["action"])
         return tuple(reversed(actions))
 

synth_ai/environments/service/core_routes.py

@@ -951,7 +951,9 @@ async def register_environment_api(request: RegisterEnvironmentRequest) -> dict[
         ) from e
     except Exception as e:
         logger.error(f"Failed to register environment {request.name}: {e}")
-        raise HTTPException(status_code=500, detail=f"Failed to register environment: {str(e)}") from e
+        raise HTTPException(
+            status_code=500, detail=f"Failed to register environment: {str(e)}"
+        ) from e
 
 
 @api_router.delete("/registry/environments/{env_name}")
@@ -984,7 +986,9 @@ async def unregister_environment_api(env_name: str) -> dict[str, Any]:
 
     except Exception as e:
         logger.error(f"Failed to unregister environment {env_name}: {e}")
-        raise HTTPException(status_code=500, detail=f"Failed to unregister environment: {str(e)}") from e
+        raise HTTPException(
+            status_code=500, detail=f"Failed to unregister environment: {str(e)}"
+        ) from e
 
 
 @api_router.get("/registry/environments")

synth_ai/evals/base.py

@@ -1,5 +1,3 @@
-
-
 class Judgement:
     def __init__(
         self, criteria: str, score: float, reasoning: str = "", evidence: list[str] = None

synth_ai/experimental/synth_oss.py

@@ -14,7 +14,7 @@ SYNTH_BACKEND_URL = ""
 # Learning V2 Modal Service URLs
 LEARNING_V2_URLS = {
     "dev": "https://synth-laboratories-dev--learning-v2-service-fastapi-app.modal.run",
-    "prod": "https://synth-laboratories-prod--learning-v2-service-fastapi-app.modal.run", 
+    "prod": "https://synth-laboratories-prod--learning-v2-service-fastapi-app.modal.run",
     "main": "https://synth-laboratories--learning-v2-service-fastapi-app.modal.run"
 }
 
@@ -30,7 +30,7 @@ HEALTH_APIS = {
         "response": {"status": "healthy"}
     },
     "detailed_health": {
-        "method": "GET", 
+        "method": "GET",
         "endpoint": "/learning/health",
         "description": "Detailed health check including GPU function availability",
         "response": {"status": "healthy", "components": {...}}
@@ -49,7 +49,7 @@ FILE_MANAGEMENT_APIS = {
         "request": "multipart/form-data with 'file' and 'purpose'='fine-tune'",
         "response": {
             "id": "file-abc123",
-            "object": "file", 
+            "object": "file",
             "bytes": 1234,
             "created_at": 1638360000,
             "filename": "data.jsonl",
@@ -84,7 +84,7 @@ FILE_MANAGEMENT_APIS = {
 }
 
 # ============================================================================
-# TRAINING/FINE-TUNING APIS  
+# TRAINING/FINE-TUNING APIS
 # ============================================================================
 
 TRAINING_APIS = {
@@ -94,7 +94,7 @@ TRAINING_APIS = {
         "description": "Create a fine-tuning job",
         "request": {
             "model": "Qwen/Qwen3-0.5B",
-            "training_file": "file-abc123", 
+            "training_file": "file-abc123",
             "training_type": "sft",  # or "dpo"
             "hyperparameters": {...},
             "suffix": "optional"
@@ -110,7 +110,7 @@ TRAINING_APIS = {
     },
     "list_training_jobs": {
         "method": "GET",
-        "endpoint": "/fine_tuning/jobs", 
+        "endpoint": "/fine_tuning/jobs",
         "description": "List all training jobs",
         "response": {"object": "list", "data": ["job_objects"]}
     },
@@ -132,7 +132,7 @@ TRAINING_APIS = {
         "response": {"object": "fine_tuning.job", "id": "...", "status": "cancelled"}
     },
     "get_training_events": {
-        "method": "GET", 
+        "method": "GET",
         "endpoint": "/fine_tuning/jobs/{job_id}/events",
         "description": "Get training logs/events",
         "response": {
@@ -154,7 +154,7 @@ TRAINING_APIS = {
 INFERENCE_APIS = {
     "chat_completions": {
         "method": "POST",
-        "endpoint": "/chat/completions", 
+        "endpoint": "/chat/completions",
         "description": "OpenAI-compatible chat completions for base and fine-tuned models",
         "request": {
             "model": "Qwen/Qwen3-0.5B",  # or "ft:Qwen/Qwen3-0.5B:suffix"
@@ -190,7 +190,7 @@ INFERENCE_APIS = {
     }
 }
 
-# ============================================================================  
+# ============================================================================
 # MODEL MANAGEMENT APIS
 # ============================================================================
 
@@ -203,7 +203,7 @@ MODEL_APIS = {
             "object": "list",
             "data": [{
                 "id": "Qwen/Qwen3-0.5B",
-                "object": "model", 
+                "object": "model",
                 "created": 1638360000,
                 "owned_by": "learning_v2"
             }]
@@ -246,7 +246,7 @@ SUPPORTED_MODELS = {
     "gpu_types": ["A10G", "L40S", "A100", "H100"],
     "features": [
         "Tool calling",
-        "Streaming responses", 
+        "Streaming responses",
         "Fine-tuning",
         "Multi-GPU training",
         "JSONL data format",
@@ -338,7 +338,6 @@ working.
 
 '''
 
-
 """
 LEARNING_v2 server-side changes required to honor `X-GPU-Preference`
 ====================================================================

synth_ai/handshake.py

@@ -72,7 +72,9 @@ def start_handshake_session(origin: str | None = None) -> Tuple[str, str, int, i
     )
 
 
-def poll_handshake_token(device_code: str, origin: str | None = None, *, timeout_s: int | None = None) -> Dict[str, Any]:
+def poll_handshake_token(
+    device_code: str, origin: str | None = None, *, timeout_s: int | None = None
+) -> Dict[str, Any]:
     base = (origin or _origin()).rstrip("/")
     api_origin, _ = _split_origin(base)
     url = urljoin(api_origin.rstrip("/") + "/", "api/sdk/handshake/token")

synth_ai/http_client.py

@@ -48,26 +48,46 @@ class AsyncHttpClient:
             path = path[4:]  # Remove leading /api
         return f"{self._base_url}/{path.lstrip('/')}"
 
-    async def get(self, path: str, *, params: Optional[Dict[str, Any]] = None, headers: Optional[Dict[str, str]] = None) -> Any:
+    async def get(
+        self,
+        path: str,
+        *,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> Any:
         url = self._abs(path)
         assert self._session is not None, "AsyncHttpClient must be used as an async context manager"
         async with self._session.get(url, params=params, headers=headers) as resp:
             return await self._handle_response(resp, url)
 
-    async def post_json(self, path: str, *, json: Dict[str, Any], headers: Optional[Dict[str, str]] = None) -> Any:
+    async def post_json(
+        self, path: str, *, json: Dict[str, Any], headers: Optional[Dict[str, str]] = None
+    ) -> Any:
         url = self._abs(path)
         assert self._session is not None, "AsyncHttpClient must be used as an async context manager"
         async with self._session.post(url, json=json, headers=headers) as resp:
             return await self._handle_response(resp, url)
 
-    async def post_multipart(self, path: str, *, data: Dict[str, Any], files: Dict[str, tuple[str, bytes, str | None]], headers: Optional[Dict[str, str]] = None) -> Any:
+    async def post_multipart(
+        self,
+        path: str,
+        *,
+        data: Dict[str, Any],
+        files: Dict[str, tuple[str, bytes, str | None]],
+        headers: Optional[Dict[str, str]] = None,
+    ) -> Any:
         url = self._abs(path)
         assert self._session is not None, "AsyncHttpClient must be used as an async context manager"
         form = aiohttp.FormData()
         for k, v in data.items():
             form.add_field(k, str(v))
         for field, (filename, content, content_type) in files.items():
-            form.add_field(field, content, filename=filename, content_type=content_type or "application/octet-stream")
+            form.add_field(
+                field,
+                content,
+                filename=filename,
+                content_type=content_type or "application/octet-stream",
+            )
         async with self._session.post(url, data=form, headers=headers) as resp:
             return await self._handle_response(resp, url)
 
@@ -95,10 +115,14 @@ class AsyncHttpClient:
             detail = await resp.json()
         except Exception:
             detail = None
-        raise HTTPError(status=resp.status, url=url, message="request_failed", body_snippet=body_snippet, detail=detail)
+        raise HTTPError(
+            status=resp.status,
+            url=url,
+            message="request_failed",
+            body_snippet=body_snippet,
+            detail=detail,
+        )
 
 
 async def sleep(seconds: float) -> None:
     await asyncio.sleep(seconds)
-
-

synth_ai/inference/__init__.py

@@ -3,5 +3,3 @@ from .client import InferenceClient
 __all__ = [
     "InferenceClient",
 ]
-
-

synth_ai/inference/client.py

@@ -11,10 +11,14 @@ class InferenceClient:
         self._api_key = api_key
         self._timeout = timeout
 
-    async def create_chat_completion(self, *, model: str, messages: list[dict], **kwargs: Any) -> Dict[str, Any]:
+    async def create_chat_completion(
+        self, *, model: str, messages: list[dict], **kwargs: Any
+    ) -> Dict[str, Any]:
         body: Dict[str, Any] = {"model": model, "messages": messages}
         body.update(kwargs)
+        # Backend now expects an explicit thinking_budget; provide a sensible default if omitted
+        if "thinking_budget" not in body:
+            body["thinking_budget"] = 256
         async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
-            return await http.post_json("/v1/chat/completions", json=body)
-
-
+            # Public learning-v2 inference path mounted under /api/v1
+            return await http.post_json("/api/v1/chat/completions", json=body)

synth_ai/jobs/client.py

@@ -9,13 +9,25 @@ class FilesApi:
     def __init__(self, http: AsyncHttpClient) -> None:
         self._http = http
 
-    async def upload(self, *, filename: str, content: bytes, purpose: str, content_type: Optional[str] = None, idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+    async def upload(
+        self,
+        *,
+        filename: str,
+        content: bytes,
+        purpose: str,
+        content_type: Optional[str] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> Dict[str, Any]:
         data = {"purpose": purpose}
         files = {"file": (filename, content, content_type)}
         headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
-        return await self._http.post_multipart("/api/files", data=data, files=files, headers=headers)
+        return await self._http.post_multipart(
+            "/api/files", data=data, files=files, headers=headers
+        )
 
-    async def list(self, *, purpose: Optional[str] = None, after: Optional[str] = None, limit: int = 20) -> Dict[str, Any]:
+    async def list(
+        self, *, purpose: Optional[str] = None, after: Optional[str] = None, limit: int = 20
+    ) -> Dict[str, Any]:
         params: Dict[str, Any] = {}
         if purpose is not None:
             params["purpose"] = purpose
@@ -30,7 +42,9 @@ class FilesApi:
     async def delete(self, file_id: str) -> Any:
         return await self._http.delete(f"/api/files/{file_id}")
 
-    async def list_jobs(self, file_id: str, *, after: Optional[str] = None, limit: int = 20) -> Dict[str, Any]:
+    async def list_jobs(
+        self, file_id: str, *, after: Optional[str] = None, limit: int = 20
+    ) -> Dict[str, Any]:
         params: Dict[str, Any] = {"limit": limit}
         if after is not None:
             params["after"] = after
@@ -102,11 +116,15 @@ class SftJobsApi:
     async def cancel(self, job_id: str) -> Dict[str, Any]:
         return await self._http.post_json(f"/api/sft/jobs/{job_id}/cancel", json={})
 
-    async def list_events(self, job_id: str, *, since_seq: int = 0, limit: int = 200) -> Dict[str, Any]:
+    async def list_events(
+        self, job_id: str, *, since_seq: int = 0, limit: int = 200
+    ) -> Dict[str, Any]:
         params = {"since_seq": since_seq, "limit": limit}
         return await self._http.get(f"/api/sft/jobs/{job_id}/events", params=params)
 
-    async def checkpoints(self, job_id: str, *, after: Optional[str] = None, limit: int = 10) -> Dict[str, Any]:
+    async def checkpoints(
+        self, job_id: str, *, after: Optional[str] = None, limit: int = 10
+    ) -> Dict[str, Any]:
         params: Dict[str, Any] = {"limit": limit}
         if after is not None:
             params["after"] = after
@@ -174,11 +192,15 @@ class RlJobsApi:
     async def cancel(self, job_id: str) -> Dict[str, Any]:
         return await self._http.post_json(f"/api/rl/jobs/{job_id}/cancel", json={})
 
-    async def list_events(self, job_id: str, *, since_seq: int = 0, limit: int = 200) -> Dict[str, Any]:
+    async def list_events(
+        self, job_id: str, *, since_seq: int = 0, limit: int = 200
+    ) -> Dict[str, Any]:
         params = {"since_seq": since_seq, "limit": limit}
         return await self._http.get(f"/api/rl/jobs/{job_id}/events", params=params)
 
-    async def metrics(self, job_id: str, *, after_step: int = -1, limit: int = 200) -> Dict[str, Any]:
+    async def metrics(
+        self, job_id: str, *, after_step: int = -1, limit: int = 200
+    ) -> Dict[str, Any]:
         params = {"after_step": after_step, "limit": limit}
         return await self._http.get(f"/api/rl/jobs/{job_id}/metrics", params=params)
 
@@ -213,7 +235,9 @@ class ModelsApi:
     async def delete(self, model_id: str) -> Any:
         return await self._http.delete(f"/api/models/{model_id}")
 
-    async def list_jobs(self, model_id: str, *, after: Optional[str] = None, limit: int = 20) -> Dict[str, Any]:
+    async def list_jobs(
+        self, model_id: str, *, after: Optional[str] = None, limit: int = 20
+    ) -> Dict[str, Any]:
         params: Dict[str, Any] = {"limit": limit}
         if after is not None:
             params["after"] = after
@@ -228,7 +252,13 @@ class JobsClient:
             await c.files.list()
     """
 
-    def __init__(self, base_url: str, api_key: str, timeout: float = 30.0, http: Optional[AsyncHttpClient] = None) -> None:
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        timeout: float = 30.0,
+        http: Optional[AsyncHttpClient] = None,
+    ) -> None:
         self._base_url = base_url
         self._api_key = api_key
         self._timeout = timeout

synth_ai/learning/client.py

@@ -20,7 +20,12 @@ class LearningClient:
             files = {"file": (p.name, content, _infer_content_type(p.name))}
             js = await http.post_multipart("/api/learning/files", data=data, files=files)
         if not isinstance(js, dict) or "id" not in js:
-            raise HTTPError(status=500, url="/api/learning/files", message="invalid_upload_response", body_snippet=str(js)[:200])
+            raise HTTPError(
+                status=500,
+                url="/api/learning/files",
+                message="invalid_upload_response",
+                body_snippet=str(js)[:200],
+            )
         return str(js["id"])
 
     async def create_job(
@@ -50,7 +55,9 @@ class LearningClient:
         async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
             return await http.get(f"/api/learning/jobs/{job_id}")
 
-    async def get_events(self, job_id: str, *, since_seq: int = 0, limit: int = 200) -> List[Dict[str, Any]]:
+    async def get_events(
+        self, job_id: str, *, since_seq: int = 0, limit: int = 200
+    ) -> List[Dict[str, Any]]:
         params = {"since_seq": since_seq, "limit": limit}
         async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
             js = await http.get(f"/api/learning/jobs/{job_id}/events", params=params)
@@ -58,7 +65,15 @@ class LearningClient:
             return js["events"]
         return []
 
-    async def get_metrics(self, job_id: str, *, name: str | None = None, after_step: int | None = None, limit: int = 500, run_id: str | None = None) -> List[Dict[str, Any]]:
+    async def get_metrics(
+        self,
+        job_id: str,
+        *,
+        name: str | None = None,
+        after_step: int | None = None,
+        limit: int = 500,
+        run_id: str | None = None,
+    ) -> List[Dict[str, Any]]:
         params: Dict[str, Any] = {"limit": limit}
         if name is not None:
             params["name"] = name
@@ -115,7 +130,9 @@ class LearningClient:
                 raise TimeoutError(f"Polling timed out after {elapsed} seconds for job {job_id}")
 
     # --- Optional diagnostics ---
-    async def pricing_preflight(self, *, job_type: str, gpu_type: str, estimated_seconds: float, container_count: int) -> Dict[str, Any]:
+    async def pricing_preflight(
+        self, *, job_type: str, gpu_type: str, estimated_seconds: float, container_count: int
+    ) -> Dict[str, Any]:
         body = {
             "job_type": job_type,
             "gpu_type": gpu_type,
@@ -125,14 +142,24 @@ class LearningClient:
         async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
             js = await http.post_json("/api/v1/pricing/preflight", json=body)
         if not isinstance(js, dict):
-            raise HTTPError(status=500, url="/api/v1/pricing/preflight", message="invalid_preflight_response", body_snippet=str(js)[:200])
+            raise HTTPError(
+                status=500,
+                url="/api/v1/pricing/preflight",
+                message="invalid_preflight_response",
+                body_snippet=str(js)[:200],
+            )
         return js
 
     async def balance_autumn_normalized(self) -> Dict[str, Any]:
         async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
             js = await http.get("/api/v1/balance/autumn-normalized")
         if not isinstance(js, dict):
-            raise HTTPError(status=500, url="/api/v1/balance/autumn-normalized", message="invalid_balance_response", body_snippet=str(js)[:200])
+            raise HTTPError(
+                status=500,
+                url="/api/v1/balance/autumn-normalized",
+                message="invalid_balance_response",
+                body_snippet=str(js)[:200],
+            )
         return js
 
 
@@ -145,5 +172,3 @@ def _infer_content_type(filename: str) -> str:
     if name.endswith(".txt"):
         return "text/plain"
     return "application/octet-stream"
-
-

synth_ai/learning/config.py

@@ -39,5 +39,3 @@ class RLJobConfig:
         if self.group_size < 2:
             raise ValueError("group_size must be >= 2")
         return {"batch_size": int(self.batch_size), "group_size": int(self.group_size)}
-
-

synth_ai/learning/constants.py

@@ -25,5 +25,3 @@ TERMINAL_EVENT_FAILURE = {
     "rl.job.failed",
     "workflow.failed",
 }
-
-

synth_ai/learning/ft_client.py

@@ -20,7 +20,12 @@ class FtClient:
             files = {"file": (p.name, content, _infer_content_type(p.name))}
             js = await http.post_multipart("/api/learning/files", data=data, files=files)
         if not isinstance(js, dict) or "id" not in js:
-            raise HTTPError(status=500, url="/api/learning/files", message="invalid_upload_response", body_snippet=str(js)[:200])
+            raise HTTPError(
+                status=500,
+                url="/api/learning/files",
+                message="invalid_upload_response",
+                body_snippet=str(js)[:200],
+            )
         return str(js["id"])
 
     async def create_sft_job(
@@ -55,5 +60,3 @@ def _infer_content_type(filename: str) -> str:
     if name.endswith(".txt"):
         return "text/plain"
     return "application/octet-stream"
-
-

synth_ai/learning/health.py

@@ -24,7 +24,15 @@ async def task_app_health(task_app_url: str) -> Dict[str, Any]:
     return await _th(task_app_url)
 
 
-async def pricing_preflight(base_url: str, api_key: str, *, job_type: str, gpu_type: str, estimated_seconds: float, container_count: int) -> Dict[str, Any]:
+async def pricing_preflight(
+    base_url: str,
+    api_key: str,
+    *,
+    job_type: str,
+    gpu_type: str,
+    estimated_seconds: float,
+    container_count: int,
+) -> Dict[str, Any]:
     body = {
         "job_type": job_type,
         "gpu_type": gpu_type,
@@ -40,4 +48,3 @@ async def balance_autumn_normalized(base_url: str, api_key: str) -> Dict[str, An
     async with AsyncHttpClient(base_url, api_key, timeout=30.0) as http:
         js = await http.get(f"{_api_base(base_url)}/v1/balance/autumn-normalized")
     return js if isinstance(js, dict) else {"raw": js}
-

synth_ai/learning/jobs.py

@@ -40,7 +40,15 @@ class JobsApiResolver:
 
 
 class JobHandle:
-    def __init__(self, base_url: str, api_key: str, job_id: str, *, strict: bool = True, timeout: float = 600.0) -> None:
+    def __init__(
+        self,
+        base_url: str,
+        api_key: str,
+        job_id: str,
+        *,
+        strict: bool = True,
+        timeout: float = 600.0,
+    ) -> None:
         self.base_url = base_url.rstrip("/")
         self.api_key = api_key
         self.job_id = job_id
@@ -134,7 +142,11 @@ class JobHandle:
                             if not detected_fine_tuned_model:
                                 try:
                                     data_obj = e.get("data") or {}
-                                    ftm = data_obj.get("fine_tuned_model") if isinstance(data_obj, dict) else None
+                                    ftm = (
+                                        data_obj.get("fine_tuned_model")
+                                        if isinstance(data_obj, dict)
+                                        else None
+                                    )
                                     if isinstance(ftm, str) and ftm:
                                         detected_fine_tuned_model = ftm
                                 except Exception:
@@ -200,6 +212,6 @@ class JobHandle:
                     )
                 await sleep(interval_seconds)
                 if max_seconds is not None and (time.time() - start_t) >= max_seconds:
-                    raise TimeoutError(f"Polling timed out after {max_seconds}s for job {self.job_id}")
-
-
+                    raise TimeoutError(
+                        f"Polling timed out after {max_seconds}s for job {self.job_id}"
+                    )

synth_ai/learning/prompts/hello_world_in_context_injection_ex.py

@@ -171,9 +171,7 @@ async def main() -> None:
         with LMOverridesContext(
             [{"match": {"contains": "atm"}, "injection_rules": INJECTION_RULES}]
         ):
-            _ = await client.chat.completions.create(
-                model=model, messages=messages, temperature=0
-            )
+            _ = await client.chat.completions.create(model=model, messages=messages, temperature=0)
         # Not all models echo input; instead, verify that our injected expectation matches
         expected_user = messages[1]["content"].replace("atm", "ATM")
         if messages[1]["content"] == expected_user:

synth_ai/learning/prompts/random_search.py

@@ -148,7 +148,10 @@ def random_search_compile(
     max_rounds: int = 2,
     num_candidate_programs: int = 16,
     stop_at_score: float | None = None,
-    evaluate_fn: Callable[[_ProgramLike, Sequence[tuple[Any, Any]], Callable[[Any, Any], float]], EvalResult] | None = None,
+    evaluate_fn: Callable[
+        [_ProgramLike, Sequence[tuple[Any, Any]], Callable[[Any, Any], float]], EvalResult
+    ]
+    | None = None,
     on_candidate_evaluated: Callable[[int, float, EvalResult, dict[str, Any]], None] | None = None,
 ) -> tuple[_ProgramLike, list[dict[str, Any]]]:
     best_program: _ProgramLike | None = None

synth_ai/learning/prompts/run_random_search_banking77.py

@@ -145,7 +145,10 @@ def main():
                     t_end = time.monotonic()
                     return i, y, "", t_start, t_end, {}
 
-            tasks = [asyncio.create_task(worker(i, x, y)) for i, (x, y) in enumerate(zip(xs, ys, strict=False))]
+            tasks = [
+                asyncio.create_task(worker(i, x, y))
+                for i, (x, y) in enumerate(zip(xs, ys, strict=False))
+            ]
             correct_sum = 0.0
             processed = 0
             import statistics
@@ -185,6 +188,7 @@ def main():
                         pending, timeout=timeout, return_when=asyncio.FIRST_COMPLETED
                     )
                     import contextlib
+
                     for task in done:
                         try:
                             i, y_true, pred, t_start, t_end, usage = task.result()
@@ -251,6 +255,7 @@ def main():
         pbar.set_postfix({"score": f"{score:.2f}"})
         # store per-instance details (for apples-to-apples)
         import contextlib
+
         with contextlib.suppress(Exception):
             candidate_eval_details[idx] = {
                 "score": score,