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

synth_ai/learning/rl_client.py

@@ -31,10 +31,17 @@ class RlClient:
         async with AsyncHttpClient(self._base_url, self._api_key, timeout=30.0) as http:
             js = await http.get(path)
         if not isinstance(js, dict):
-            raise HTTPError(status=500, url=path, message="invalid_service_response", body_snippet=str(js)[:200])
+            raise HTTPError(
+                status=500, url=path, message="invalid_service_response", body_snippet=str(js)[:200]
+            )
         start_url = js.get("training_start_url")
         if not isinstance(start_url, str) or not start_url:
-            raise HTTPError(status=500, url=path, message="missing_training_start_url", body_snippet=str(js)[:200])
+            raise HTTPError(
+                status=500,
+                url=path,
+                message="missing_training_start_url",
+                body_snippet=str(js)[:200],
+            )
         return start_url
 
     async def create_job(
@@ -63,7 +70,12 @@ class RlClient:
         async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
             js = await http.post_json(f"{_api_base(self._base_url)}/rl/jobs", json=body)
         if not isinstance(js, dict):
-            raise HTTPError(status=500, url="/api/rl/jobs", message="invalid_create_response", body_snippet=str(js)[:200])
+            raise HTTPError(
+                status=500,
+                url="/api/rl/jobs",
+                message="invalid_create_response",
+                body_snippet=str(js)[:200],
+            )
         return js
 
     async def start_job_if_supported(self, job_id: str) -> Optional[Dict[str, Any]]:
@@ -80,11 +92,15 @@ class RlClient:
         async with AsyncHttpClient(self._base_url, self._api_key, timeout=30.0) as http:
             return await http.get(f"{_api_base(self._base_url)}/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=30.0) as http:
             try:
-                js = await http.get(f"{_api_base(self._base_url)}/learning/jobs/{job_id}/events", params=params)
+                js = await http.get(
+                    f"{_api_base(self._base_url)}/learning/jobs/{job_id}/events", params=params
+                )
             except HTTPError as he:
                 try:
                     print(
@@ -99,10 +115,14 @@ class RlClient:
                 return evs
         return []
 
-    async def get_metrics(self, job_id: str, *, after_step: int = -1, limit: int = 200) -> List[Dict[str, Any]]:
+    async def get_metrics(
+        self, job_id: str, *, after_step: int = -1, limit: int = 200
+    ) -> List[Dict[str, Any]]:
         params = {"after_step": after_step, "limit": limit}
         async with AsyncHttpClient(self._base_url, self._api_key, timeout=30.0) as http:
-            js = await http.get(f"{_api_base(self._base_url)}/learning/jobs/{job_id}/metrics", params=params)
+            js = await http.get(
+                f"{_api_base(self._base_url)}/learning/jobs/{job_id}/metrics", params=params
+            )
         if isinstance(js, dict) and isinstance(js.get("points"), list):
             return js["points"]
         return []
@@ -161,7 +181,9 @@ class RlClient:
             if events_job_id and events_job_id not in stream_ids:
                 stream_ids.append(events_job_id)
             try:
-                print(f"[poll] streams={stream_ids} intervals={interval_seconds}s since_map={last_seq_by_stream} empty_polls={empty_polls}")
+                print(
+                    f"[poll] streams={stream_ids} intervals={interval_seconds}s since_map={last_seq_by_stream} empty_polls={empty_polls}"
+                )
             except Exception:
                 pass
             total_events_this_cycle = 0
@@ -173,13 +195,17 @@ class RlClient:
                     events = await self.get_events(ev_id, since_seq=since, limit=200)
                 except HTTPError as he:
                     try:
-                        print(f"[poll] get_events error status={he.status} url={he.url} since={since} body={(he.body_snippet or '')[:200]}")
+                        print(
+                            f"[poll] get_events error status={he.status} url={he.url} since={since} body={(he.body_snippet or '')[:200]}"
+                        )
                     except Exception:
                         pass
                     events = []
                 except Exception as e:
                     try:
-                        print(f"[poll] get_events unexpected error ev_id={ev_id} since={since} err={type(e).__name__}: {e}")
+                        print(
+                            f"[poll] get_events unexpected error ev_id={ev_id} since={since} err={type(e).__name__}: {e}"
+                        )
                     except Exception:
                         pass
                     events = []
@@ -238,7 +264,9 @@ class RlClient:
                     )
                 except Exception:
                     pass
-                raise AssertionError(f"No new events detected for {empty_polls_threshold} consecutive polls. Check event ingestion.")
+                raise AssertionError(
+                    f"No new events detected for {empty_polls_threshold} consecutive polls. Check event ingestion."
+                )
 
             if not saw_any_event and (time.time() - start_t) > int(startup_deadline_s):
                 try:
@@ -247,10 +275,10 @@ class RlClient:
                     )
                 except Exception:
                     pass
-                raise AssertionError(f"No events observed within startup window ({startup_deadline_s}s). Investigate event streaming.")
+                raise AssertionError(
+                    f"No events observed within startup window ({startup_deadline_s}s). Investigate event streaming."
+                )
 
             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 {job_id}")
-
-

synth_ai/learning/sse.py

@@ -54,5 +54,3 @@ async def stream_events(
                             return
         except Exception:
             continue
-
-

synth_ai/learning/validators.py

@@ -13,7 +13,7 @@ def validate_training_jsonl(path: str | Path, *, sample_lines: int = 50) -> None
     lines = p.read_text().splitlines()
     if not lines:
         raise ValueError("empty JSONL")
-    for i, line in enumerate(lines[: max(1, sample_lines) ], start=1):
+    for i, line in enumerate(lines[: max(1, sample_lines)], start=1):
         if not line.strip():
             continue
         try:
@@ -29,7 +29,11 @@ def validate_training_jsonl(path: str | Path, *, sample_lines: int = 50) -> None
         for m in msgs:
             if not isinstance(m, dict):
                 raise ValueError(f"line {i}: non-dict message")
-            if not isinstance(m.get("role"), str) or not isinstance(m.get("content"), str) or not m["content"].strip():
+            if (
+                not isinstance(m.get("role"), str)
+                or not isinstance(m.get("content"), str)
+                or not m["content"].strip()
+            ):
                 raise ValueError(f"line {i}: invalid role/content")
 
 

synth_ai/lm/caching/ephemeral.py

@@ -28,9 +28,7 @@ class EphemeralCache:
         os.makedirs(fast_cache_dir, exist_ok=True)
         self.fast_cache = Cache(fast_cache_dir, size_limit=DISKCACHE_SIZE_LIMIT)
 
-    def hit_cache(
-        self, key: str, response_model: BaseModel | None = None
-    ) -> BaseLMResponse | None:
+    def hit_cache(self, key: str, response_model: BaseModel | None = None) -> BaseLMResponse | None:
         """
         Check if a response exists in cache for the given key.
 

synth_ai/lm/core/exceptions.py

@@ -1,5 +1,3 @@
-
-
 class StructuredOutputCoercionFailureException(Exception):
     pass
 

synth_ai/lm/core/main.py

@@ -113,7 +113,19 @@ class LM:
         max_retries: Literal["None", "Few", "Many"] = "Few",
         structured_output_mode: Literal["stringified_json", "forced_json"] = "stringified_json",
         synth_logging: bool = True,
-        provider: Literal["openai", "anthropic", "groq", "gemini", "deepseek", "grok", "mistral", "openrouter", "together"] | str | None = None,
+        provider: Literal[
+            "openai",
+            "anthropic",
+            "groq",
+            "gemini",
+            "deepseek",
+            "grok",
+            "mistral",
+            "openrouter",
+            "together",
+        ]
+        | str
+        | None = None,
         enable_thinking: bool | None = None,
     ):
         # print("Structured output mode", structured_output_mode)

synth_ai/lm/core/synth_models.py

@@ -27,7 +27,6 @@ QWEN3_MODELS: List[str] = [
     "Qwen/Qwen3-8B",
     "Qwen/Qwen3-14B",
     "Qwen/Qwen3-32B",
-
     # Qwen3 specialized variants
     "Qwen/Qwen3-4B-2507",
     "Qwen/Qwen3-4B-Thinking-2507",

synth_ai/lm/core/vendor_clients.py

@@ -180,8 +180,10 @@ def get_client(
     elif any(regex.match(model_name) for regex in custom_endpoint_naming_regexes):
         # Custom endpoints are passed as the endpoint URL
         return CustomEndpointClient(endpoint_url=model_name)
-    elif (any(regex.match(model_name) for regex in synth_naming_regexes) or
-          model_name in SYNTH_SUPPORTED_MODELS):
+    elif (
+        any(regex.match(model_name) for regex in synth_naming_regexes)
+        or model_name in SYNTH_SUPPORTED_MODELS
+    ):
         # Synth models use OpenAI-compatible client with custom endpoint
         return OpenAIStructuredOutputClient(synth_logging=synth_logging)
     else:

synth_ai/lm/overrides.py

@@ -20,8 +20,8 @@ from synth_ai.lm.injection import (
 #   "params": { ... api params to override ... },
 #   "tools": { ... optional tools overrides ... },
 # }
-_override_specs_ctx: contextvars.ContextVar[list[dict[str, Any]] | None] = (
-    contextvars.ContextVar("override_specs", default=None)
+_override_specs_ctx: contextvars.ContextVar[list[dict[str, Any]] | None] = contextvars.ContextVar(
+    "override_specs", default=None
 )
 
 # ContextVars actually applied for the specific call once matched

synth_ai/lm/vendors/core/anthropic_api.py

@@ -100,13 +100,13 @@ class AnthropicAPI(VendorBase):
                 and model in CLAUDE_REASONING_MODELS
                 and reasoning_effort in ["high", "medium"]
             ):
-                    budget = SONNET_37_BUDGETS[reasoning_effort]
-                    api_params["thinking"] = {
-                        "type": "enabled",
-                        "budget_tokens": budget,
-                    }
-                    api_params["max_tokens"] = budget + 4096
-                    api_params["temperature"] = 1
+                budget = SONNET_37_BUDGETS[reasoning_effort]
+                api_params["thinking"] = {
+                    "type": "enabled",
+                    "budget_tokens": budget,
+                }
+                api_params["max_tokens"] = budget + 4096
+                api_params["temperature"] = 1
         except (ImportError, AttributeError, TypeError):
             pass
 

synth_ai/lm/vendors/core/openai_api.py

@@ -74,11 +74,13 @@ class OpenAIStructuredOutputClient(OpenAIStandard):
         elif synth_logging:
             # print("Using synth logging - OpenAIStructuredOutputClient")
             from synth_ai.lm.provider_support.openai import AsyncOpenAI, OpenAI
+
             sync_client = OpenAI()
             async_client = AsyncOpenAI()
         else:
             # print("Not using synth logging - OpenAIStructuredOutputClient")
             from openai import AsyncOpenAI, OpenAI
+
             sync_client = OpenAI()
             async_client = AsyncOpenAI()
 

synth_ai/lm/vendors/openai_standard.py

@@ -427,7 +427,9 @@ class OpenAIStandard(VendorBase, OpenAIResponsesAPIMixin):
                             "type": getattr(tc, "type", "function"),
                             "function": {
                                 "name": getattr(getattr(tc, "function", None), "name", None),
-                                "arguments": getattr(getattr(tc, "function", None), "arguments", None),
+                                "arguments": getattr(
+                                    getattr(tc, "function", None), "arguments", None
+                                ),
                             },
                         }
                     )

synth_ai/lm/vendors/openai_standard_responses.py

@@ -223,7 +223,9 @@ class OpenAIResponsesAPIMixin:
         if not synth_gpu_endpoint:
             raise ValueError("SYNTH_GPU_HARMONY_ENDPOINT environment variable not set")
 
-        async with aiohttp.ClientSession() as session, session.post(
+        async with (
+            aiohttp.ClientSession() as session,
+            session.post(
                 f"{synth_gpu_endpoint}/v1/completions",
                 json={
                     "model": model,
@@ -231,8 +233,9 @@ class OpenAIResponsesAPIMixin:
                     "max_tokens": lm_config.get("max_tokens", 4096),
                     "temperature": lm_config.get("temperature", 0.8),
                 },
-            ) as resp:
-                result = await resp.json()
+            ) as resp,
+        ):
+            result = await resp.json()
 
         # Parse response using Harmony
         response_tokens = result.get("choices", [{}])[0].get("text", "")

synth_ai/lm/vendors/supported/custom_endpoint.py

@@ -194,9 +194,7 @@ IMPORTANT: To use a tool, respond with JSON wrapped in ```json fences:
 
 For regular responses, just respond normally without JSON fences."""
 
-    def _extract_tool_calls(
-        self, content: str, tools: list[BaseTool]
-    ) -> tuple[list | None, str]:
+    def _extract_tool_calls(self, content: str, tools: list[BaseTool]) -> tuple[list | None, str]:
         """Extract and validate tool calls from response."""
         # Look for JSON fenced blocks
         json_pattern = r"```json\s*(\{.*?\})\s*```"

synth_ai/lm/vendors/synth_client.py

@@ -276,8 +276,20 @@ class AsyncSynthClient:
         This method provides the OpenAI client interface structure.
         """
         return await self._chat_completions_create(
-            model, messages, temperature, max_tokens, top_p, frequency_penalty,
-            presence_penalty, stop, stream, tools, tool_choice, response_format, seed, **kwargs
+            model,
+            messages,
+            temperature,
+            max_tokens,
+            top_p,
+            frequency_penalty,
+            presence_penalty,
+            stop,
+            stream,
+            tools,
+            tool_choice,
+            response_format,
+            seed,
+            **kwargs,
         )
 
     async def _chat_completions_create(
@@ -368,7 +380,8 @@ class AsyncSynthClient:
             if isinstance(bt, int) and isinstance(mt, int) and bt > mt:
                 logger.warning(
                     "thinking_budget (%s) exceeds max_tokens (%s) – forwarding as-is",
-                    str(bt), str(mt)
+                    str(bt),
+                    str(mt),
                 )
         except Exception:
             pass
@@ -387,6 +400,7 @@ class AsyncSynthClient:
 
                 # If streaming requested, return an async stream adapter
                 if stream:
+
                     async def _astream():
                         await self._ensure_client()
                         async with self._client.stream("POST", url, json=payload) as r:  # type: ignore
@@ -678,6 +692,7 @@ def create_sync_client(config: SynthConfig | None = None) -> SyncSynthClient:
 # Drop-in replacements for OpenAI clients
 # These allow Synth to be used as a complete replacement for OpenAI
 
+
 class AsyncOpenAI(AsyncSynthClient):
     """
     Drop-in replacement for openai.AsyncOpenAI.
@@ -710,16 +725,22 @@ class AsyncOpenAI(AsyncSynthClient):
         """
         # Handle OpenAI-style initialization
         from ..config import SynthConfig
+
         if api_key or base_url:
             config = SynthConfig(
-                base_url=base_url or os.getenv("OPENAI_API_BASE", "https://synth-backend-dev-docker.onrender.com/api"),
-                api_key=api_key or os.getenv("OPENAI_API_KEY", "")
+                base_url=base_url
+                or os.getenv(
+                    "OPENAI_API_BASE", "https://synth-backend-dev-docker.onrender.com/api"
+                ),
+                api_key=api_key or os.getenv("OPENAI_API_KEY", ""),
             )
         else:
             # Fallback to environment variables (OPENAI_* first, then SYNTH_*)
             env_base = os.getenv("OPENAI_API_BASE") or os.getenv("SYNTH_BASE_URL")
             env_key = os.getenv("OPENAI_API_KEY") or os.getenv("SYNTH_API_KEY")
-            config = SynthConfig(base_url=env_base, api_key=env_key) if env_base and env_key else None
+            config = (
+                SynthConfig(base_url=env_base, api_key=env_key) if env_base and env_key else None
+            )
 
         super().__init__(config, **kwargs)
 
@@ -742,15 +763,21 @@ class OpenAI(SyncSynthClient):
         """
         # Handle OpenAI-style initialization
         from ..config import SynthConfig
+
         if api_key or base_url:
             config = SynthConfig(
-                base_url=base_url or os.getenv("OPENAI_API_BASE", "https://synth-backend-dev-docker.onrender.com/api"),
-                api_key=api_key or os.getenv("OPENAI_API_KEY", "")
+                base_url=base_url
+                or os.getenv(
+                    "OPENAI_API_BASE", "https://synth-backend-dev-docker.onrender.com/api"
+                ),
+                api_key=api_key or os.getenv("OPENAI_API_KEY", ""),
             )
         else:
             env_base = os.getenv("OPENAI_API_BASE") or os.getenv("SYNTH_BASE_URL")
             env_key = os.getenv("OPENAI_API_KEY") or os.getenv("SYNTH_API_KEY")
-            config = SynthConfig(base_url=env_base, api_key=env_key) if env_base and env_key else None
+            config = (
+                SynthConfig(base_url=env_base, api_key=env_key) if env_base and env_key else None
+            )
 
         super().__init__(config, **kwargs)
 
@@ -760,7 +787,7 @@ __all__ = [
     "AsyncSynthClient",
     "SyncSynthClient",
     "AsyncOpenAI",  # Drop-in replacement for openai.AsyncOpenAI
-    "OpenAI",       # Drop-in replacement for openai.OpenAI
+    "OpenAI",  # Drop-in replacement for openai.OpenAI
     "create_async_client",
     "create_sync_client",
     "create_chat_completion_async",

synth_ai/rl/__init__.py

@@ -27,4 +27,3 @@ __all__ = [
     "mint_environment_api_key",
     "MAX_ENVIRONMENT_API_KEY_BYTES",
 ]
-

synth_ai/rl/contracts.py

@@ -28,5 +28,3 @@ __all__ = [
     "RolloutMetrics",
     "RolloutResponse",
 ]
-
-

synth_ai/rl/env_keys.py

@@ -101,7 +101,12 @@ def setup_environment_api_key(
 
     body = {"name": "ENVIRONMENT_API_KEY", "ciphertext_b64": ciphertext_b64}
     post_url = f"{backend}/api/v1/env-keys"
-    response2 = requests.post(post_url, headers={**headers, "Content-Type": "application/json"}, json=body, timeout=timeout)
+    response2 = requests.post(
+        post_url,
+        headers={**headers, "Content-Type": "application/json"},
+        json=body,
+        timeout=timeout,
+    )
     _raise_with_detail(response2)
 
     try:

synth_ai/task/__init__.py

@@ -54,6 +54,7 @@ from .server import (
     create_task_app,
     run_task_app,
 )
+
 __all__ = [
     "validate_task_app_url",
     "task_app_health",

synth_ai/task/apps/__init__.py

@@ -68,7 +68,7 @@ class TaskAppRegistry:
 
     def __iter__(self) -> Iterable[TaskAppEntry]:
         return iter(self.list())
-    
+
     def clear(self) -> None:
         """Clear all registered task apps."""
         self._entries.clear()
@@ -85,34 +85,34 @@ def register_task_app(*, entry: TaskAppEntry) -> None:
 def discover_task_apps_from_cwd() -> None:
     """Discover and register task apps from the current working directory and subdirectories."""
     cwd = Path.cwd()
-    
+
     # Look for task app files in common patterns
     patterns = [
         "**/task_app/*.py",
-        "**/task_apps/*.py", 
+        "**/task_apps/*.py",
         "**/*_task_app.py",
         "**/grpo_crafter.py",
         "**/math_single_step.py",
     ]
-    
+
     discovered_files = []
     for pattern in patterns:
         discovered_files.extend(cwd.glob(pattern))
-    
+
     # Add current directory to Python path temporarily
     original_path = sys.path.copy()
     try:
         sys.path.insert(0, str(cwd))
-        
+
         for file_path in discovered_files:
-            if file_path.name.startswith('__'):
+            if file_path.name.startswith("__"):
                 continue
-                
+
             # Convert file path to module name
             relative_path = file_path.relative_to(cwd)
             module_parts = list(relative_path.parts[:-1]) + [relative_path.stem]
-            module_name = '.'.join(module_parts)
-            
+            module_name = ".".join(module_parts)
+
             try:
                 # Import the module to trigger registration
                 importlib.import_module(module_name)
@@ -120,7 +120,7 @@ def discover_task_apps_from_cwd() -> None:
                 # Silently skip modules that can't be imported
                 # This allows for graceful handling of missing dependencies
                 continue
-                
+
     finally:
         sys.path[:] = original_path
 

synth_ai/task/auth.py

@@ -12,7 +12,9 @@ _DEV_API_KEY_ENVS = ("dev_environment_api_key", "DEV_ENVIRONMENT_API_KEY")
 _API_KEY_HEADER = "x-api-key"
 _API_KEYS_HEADER = "x-api-keys"
 _AUTH_HEADER = "authorization"
-_API_KEY_ALIASES_ENV = "ENVIRONMENT_API_KEY_ALIASES"  # comma-separated list of additional valid keys
+_API_KEY_ALIASES_ENV = (
+    "ENVIRONMENT_API_KEY_ALIASES"  # comma-separated list of additional valid keys
+)
 
 
 def _mask(value: str, *, prefix: int = 4) -> str:
@@ -120,7 +122,9 @@ def require_api_key_dependency(request: Any) -> None:
 
     allowed = allowed_environment_api_keys()
     if not allowed:
-        raise http_exception(503, "missing_environment_api_key", "ENVIRONMENT_API_KEY is not configured")
+        raise http_exception(
+            503, "missing_environment_api_key", "ENVIRONMENT_API_KEY is not configured"
+        )
     # Build candidate list for verbose diagnostics
     single = list(_header_values(request, _API_KEY_HEADER))
     multi = list(_header_values(request, _API_KEYS_HEADER))
@@ -132,22 +136,30 @@ def require_api_key_dependency(request: Any) -> None:
     candidates = _split_csv(single + multi + bearer)
     if not any(candidate in allowed for candidate in candidates):
         try:
-            print({
-                "task_auth_failed": True,
+            print(
+                {
+                    "task_auth_failed": True,
+                    "allowed_first15": [k[:15] for k in allowed],
+                    "allowed_count": len(allowed),
+                    "got_first15": [c[:15] for c in candidates],
+                    "got_lens": [len(c) for c in candidates],
+                    "have_x_api_key": bool(single),
+                    "have_x_api_keys": bool(multi),
+                    "have_authorization": bool(auths),
+                },
+                flush=True,
+            )
+        except Exception:
+            pass
+        # Use 400 to make failures unmistakable during preflight
+        raise http_exception(
+            400,
+            "unauthorised",
+            "API key missing or invalid",
+            extra={
                 "allowed_first15": [k[:15] for k in allowed],
                 "allowed_count": len(allowed),
                 "got_first15": [c[:15] for c in candidates],
                 "got_lens": [len(c) for c in candidates],
-                "have_x_api_key": bool(single),
-                "have_x_api_keys": bool(multi),
-                "have_authorization": bool(auths),
-            }, flush=True)
-        except Exception:
-            pass
-        # Use 400 to make failures unmistakable during preflight
-        raise http_exception(400, "unauthorised", "API key missing or invalid", extra={
-            "allowed_first15": [k[:15] for k in allowed],
-            "allowed_count": len(allowed),
-            "got_first15": [c[:15] for c in candidates],
-            "got_lens": [len(c) for c in candidates],
-        })
+            },
+        )

synth_ai/task/client.py

@@ -158,7 +158,9 @@ class _TaskAppEnvironmentClient:
         )
         return response.json()
 
-    async def terminate(self, env_name: str, payload: Dict[str, Any] | None = None) -> Dict[str, Any]:
+    async def terminate(
+        self, env_name: str, payload: Dict[str, Any] | None = None
+    ) -> Dict[str, Any]:
         response = await self._client._request(
             "POST", f"/env/{env_name}/terminate", json_payload=payload or {}
         )

synth_ai/task/contracts.py

@@ -46,6 +46,7 @@ class TaskAppContract:
 
 # --- Unified rollout schema used by Task App services and SDK utilities ---
 
+
 class RolloutEnvSpec(BaseModel):
     env_id: Optional[str] = None
     env_name: Optional[str] = None

synth_ai/task/datasets.py

@@ -37,7 +37,9 @@ class TaskDatasetRegistry:
         self._entries: Dict[str, Tuple[TaskDatasetSpec, RegistryLoader, bool]] = {}
         self._cache: Dict[Hashable, Any] = {}
 
-    def register(self, spec: TaskDatasetSpec, loader: RegistryLoader, *, cache: bool = True) -> None:
+    def register(
+        self, spec: TaskDatasetSpec, loader: RegistryLoader, *, cache: bool = True
+    ) -> None:
         """Register a dataset loader and its metadata."""
 
         self._entries[spec.id] = (spec, loader, cache)

synth_ai/task/errors.py

@@ -7,7 +7,9 @@ from typing import Any, Dict, Optional
 from .json import to_jsonable
 
 
-def error_payload(code: str, message: str, *, extra: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+def error_payload(
+    code: str, message: str, *, extra: Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
     payload: Dict[str, Any] = {"error": {"code": code, "message": message}}
     if extra:
         payload["error"].update(extra)
@@ -46,4 +48,3 @@ def json_error_response(
 
     payload = error_payload(code, message, extra=extra)
     return JSONResponse(status_code=status_code, content=to_jsonable(payload), headers=headers)
-

synth_ai/task/health.py

@@ -24,5 +24,3 @@ async def task_app_health(task_app_url: str) -> Dict[str, Any]:
         return {"ok": False, "status": None}
     except Exception as e:
         return {"ok": False, "error": f"{type(e).__name__}: {e}"}
-
-

synth_ai/task/json.py

@@ -74,4 +74,3 @@ def to_jsonable(value: Any) -> Any:
         return to_jsonable(vars(value))
 
     return repr(value)
-