synth-ai 0.2.4.dev7__py3-none-any.whl → 0.2.4.dev9__py3-none-any.whl

synth_ai/environments/examples/sokoban/units/astar_common.py

@@ -0,0 +1,95 @@
+"""
+astar_common.py – one A* routine usable by both engine-level and
+environment-level unit tests.
+"""
+
+import heapq
+import itertools
+import json
+from typing import Any, Awaitable, Callable, List, Tuple
+
+import numpy as np
+
+
+# ---------- generic utilities ------------------------------------ #
+def _boxes_left(env_pkg) -> int:
+    """#targets – #boxes-on-targets (uses raw grids, never the counter)."""
+    return int(np.sum(env_pkg.room_fixed == 2) - np.sum(env_pkg.room_state == 3))
+
+
+def solved(obj: Any) -> bool:
+    """Expects obj to have a .package_sokoban_env attribute."""
+    return _boxes_left(obj.package_sokoban_env) == 0
+
+
+def heuristic(obj: Any) -> int:
+    """Expects obj to have a .package_sokoban_env attribute."""
+    return _boxes_left(obj.package_sokoban_env)
+
+
+# ---------- single reusable A* ----------------------------------- #
+async def astar(
+    root_obj: Any,
+    step_fn: Callable[[Any, int], Awaitable[None]],
+    deserialize_fn: Callable[[Any], Awaitable[Any]],
+    max_nodes: int = 1000,
+) -> List[int]:
+    """
+    Generic A* over Sokoban snapshots.
+
+    • `root_obj` - current engine *or* environment
+    • `step_fn(obj, action)` - async: apply one move to *obj*
+    • `deserialize_fn(snapshot)` - async: new obj from snapshot
+    """
+    start_snap = await root_obj._serialize_engine()
+
+    frontier: List[Tuple[int, int, Any, List[int]]] = []
+    counter = itertools.count()
+    frontier.append((heuristic(root_obj), next(counter), start_snap, []))
+    seen: set[str] = set()
+
+    nodes = 0
+    while frontier and nodes < max_nodes:
+        f, _, snap, path = heapq.heappop(frontier)
+        cur = await deserialize_fn(snap)
+        key = json.dumps(snap.engine_snapshot, sort_keys=True)
+        if key in seen:
+            continue
+        seen.add(key)
+        if solved(cur):
+            return path
+
+        nodes += 1
+        for action in range(cur.package_sokoban_env.action_space.n):
+            child = await deserialize_fn(snap)  # fresh copy
+            try:
+                await step_fn(child, action)
+            except Exception:  # illegal/off-board
+                continue
+
+            child_snap = await child._serialize_engine()
+            g = len(path) + 1
+            heapq.heappush(
+                frontier,
+                (g + heuristic(child), next(counter), child_snap, path + [action]),
+            )
+    return []
+
+
+# convenience lambdas for the two concrete APIs
+async def _engine_step(e, a):  # `SokobanEngine`
+    await e._step_engine(a)
+
+
+async def _env_step(env, a):  # `SokobanEnvironment` (expects Move wrapper)
+    from synth_ai.environments.examples.sokoban.units.test_sokoban_environment import Move
+
+    await env.step([[Move(a)]])
+
+
+ENGINE_ASTAR = lambda eng, **kw: astar(eng, _engine_step, eng.__class__._deserialize_engine, **kw)
+ENV_ASTAR = lambda env, **kw: astar(
+    env.engine, _env_step, env.engine.__class__._deserialize_engine, **kw
+)
+
+# ----------------------------------------------------------------- #

synth_ai/environments/service/app.py

@@ -47,6 +47,14 @@ except Exception as _e:
     # Keep service robust even if example env import fails
     logging.getLogger(__name__).warning(f"Wordle env not registered: {_e}")
 
+# Register Bandit example environment
+try:
+    import synth_ai.environments.examples.bandit.environment as bandit_mod
+
+    register_environment("Bandit", bandit_mod.BanditEnvironment)
+except Exception as _e:
+    logging.getLogger(__name__).warning(f"Bandit env not registered: {_e}")
+
 app = FastAPI(title="Environment Service")
 
 

synth_ai/http.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+import aiohttp
+
+
+@dataclass
+class HTTPError(Exception):
+    status: int
+    url: str
+    message: str
+    body_snippet: str | None = None
+    detail: Any | None = None
+
+    def __str__(self) -> str:  # pragma: no cover - trivial
+        base = f"HTTP {self.status} for {self.url}: {self.message}"
+        if self.body_snippet:
+            base += f" | body[0:200]={self.body_snippet[:200]}"
+        return base
+
+
+class AsyncHttpClient:
+    def __init__(self, base_url: str, api_key: str, timeout: float = 30.0) -> None:
+        self._base_url = base_url.rstrip("/")
+        self._api_key = api_key
+        self._timeout = aiohttp.ClientTimeout(total=timeout)
+        self._session: Optional[aiohttp.ClientSession] = None
+
+    async def __aenter__(self) -> "AsyncHttpClient":
+        if self._session is None:
+            headers = {"authorization": f"Bearer {self._api_key}"}
+            self._session = aiohttp.ClientSession(headers=headers, timeout=self._timeout)
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:  # noqa: ANN001
+        if self._session is not None:
+            await self._session.close()
+            self._session = None
+
+    def _abs(self, path: str) -> str:
+        if path.startswith("http://") or path.startswith("https://"):
+            return path
+        # If base_url already ends with /api and path starts with /api, remove duplicate
+        if self._base_url.endswith("/api") and path.startswith("/api"):
+            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:
+        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:
+        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:
+        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")
+        async with self._session.post(url, data=form, headers=headers) as resp:
+            return await self._handle_response(resp, url)
+
+    async def delete(self, path: str, *, 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.delete(url, headers=headers) as resp:
+            return await self._handle_response(resp, url)
+
+    async def _handle_response(self, resp: aiohttp.ClientResponse, url: str) -> Any:
+        text = await resp.text()
+        body_snippet = text[:200] if text else None
+        if 200 <= resp.status < 300:
+            ctype = resp.headers.get("content-type", "")
+            if "application/json" in ctype:
+                try:
+                    return await resp.json()
+                except Exception:
+                    # Fallback to text
+                    return text
+            return text
+        # error
+        detail: Any | None = None
+        try:
+            detail = await resp.json()
+        except Exception:
+            detail = None
+        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

@@ -0,0 +1,7 @@
+from .client import InferenceClient
+
+__all__ = [
+    "InferenceClient",
+]
+
+

synth_ai/inference/client.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from ..http import AsyncHttpClient
+
+
+class InferenceClient:
+    def __init__(self, base_url: str, api_key: str, *, timeout: float = 30.0) -> None:
+        self._base_url = base_url.rstrip("/")
+        self._api_key = api_key
+        self._timeout = timeout
+
+    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)
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
+            return await http.post_json("/v1/chat/completions", json=body)
+
+

synth_ai/install_sqld.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+# Install sqld binary for Synth AI
+
+set -e
+
+SQLD_VERSION="v0.26.2"
+OS=$(uname -s | tr '[:upper:]' '[:lower:]')
+ARCH=$(uname -m)
+
+# Map architecture names
+case "$ARCH" in
+    x86_64) ARCH="x86_64" ;;
+    aarch64|arm64) ARCH="aarch64" ;;
+    *) echo "Unsupported architecture: $ARCH"; exit 1 ;;
+esac
+
+# Construct download URL
+URL="https://github.com/tursodatabase/libsql/releases/download/libsql-server-${SQLD_VERSION}/sqld-${OS}-${ARCH}.tar.xz"
+
+echo "📥 Downloading sqld ${SQLD_VERSION} for ${OS}-${ARCH}..."
+
+# Download and extract
+TMP_DIR=$(mktemp -d)
+cd "$TMP_DIR"
+curl -L -o sqld.tar.xz "$URL"
+tar -xf sqld.tar.xz
+
+# Install to user's local bin
+mkdir -p ~/.local/bin
+mv sqld ~/.local/bin/
+chmod +x ~/.local/bin/sqld
+
+# Clean up
+cd -
+rm -rf "$TMP_DIR"
+
+echo "✅ sqld installed to ~/.local/bin/sqld"
+echo ""
+echo "🔧 Add ~/.local/bin to your PATH if needed:"
+echo "   export PATH=\"\$HOME/.local/bin:\$PATH\""

synth_ai/jobs/client.py

@@ -0,0 +1,246 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from synth_ai.http import AsyncHttpClient
+
+
+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]:
+        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)
+
+    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
+        if after is not None:
+            params["after"] = after
+        params["limit"] = limit
+        return await self._http.get("/api/files", params=params)
+
+    async def retrieve(self, file_id: str) -> Dict[str, Any]:
+        return await self._http.get(f"/api/files/{file_id}")
+
+    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]:
+        params: Dict[str, Any] = {"limit": limit}
+        if after is not None:
+            params["after"] = after
+        return await self._http.get(f"/api/files/{file_id}/jobs", params=params)
+
+
+class SftJobsApi:
+    def __init__(self, http: AsyncHttpClient) -> None:
+        self._http = http
+
+    async def create(
+        self,
+        *,
+        training_file: str,
+        model: str,
+        validation_file: Optional[str] = None,
+        hyperparameters: Optional[Dict[str, Any]] = None,
+        suffix: Optional[str] = None,
+        integrations: Optional[Dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {
+            "training_file": training_file,
+            "model": model,
+        }
+        if validation_file is not None:
+            payload["validation_file"] = validation_file
+        if hyperparameters is not None:
+            payload["hyperparameters"] = hyperparameters
+        if suffix is not None:
+            payload["suffix"] = suffix
+        if integrations is not None:
+            payload["integrations"] = integrations
+        if metadata is not None:
+            payload["metadata"] = metadata
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return await self._http.post_json("/api/sft/jobs", json=payload, headers=headers)
+
+    async def list(
+        self,
+        *,
+        status: Optional[str] = None,
+        model: Optional[str] = None,
+        file_id: Optional[str] = None,
+        created_after: Optional[int] = None,
+        created_before: Optional[int] = None,
+        after: Optional[str] = None,
+        limit: int = 20,
+    ) -> Dict[str, Any]:
+        params: Dict[str, Any] = {"limit": limit}
+        if status is not None:
+            params["status"] = status
+        if model is not None:
+            params["model"] = model
+        if file_id is not None:
+            params["file_id"] = file_id
+        if created_after is not None:
+            params["created_after"] = created_after
+        if created_before is not None:
+            params["created_before"] = created_before
+        if after is not None:
+            params["after"] = after
+        return await self._http.get("/api/sft/jobs", params=params)
+
+    async def retrieve(self, job_id: str) -> Dict[str, Any]:
+        return await self._http.get(f"/api/sft/jobs/{job_id}")
+
+    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]:
+        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]:
+        params: Dict[str, Any] = {"limit": limit}
+        if after is not None:
+            params["after"] = after
+        return await self._http.get(f"/api/sft/jobs/{job_id}/checkpoints", params=params)
+
+
+class RlJobsApi:
+    def __init__(self, http: AsyncHttpClient) -> None:
+        self._http = http
+
+    async def create(
+        self,
+        *,
+        model: str,
+        endpoint_base_url: str,
+        trainer_id: str,
+        trainer: Optional[Dict[str, Any]] = None,
+        job_config_id: Optional[str] = None,
+        config: Optional[Dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {
+            "model": model,
+            "endpoint_base_url": endpoint_base_url,
+            "trainer_id": trainer_id,
+        }
+        if trainer is not None:
+            payload["trainer"] = trainer
+        if job_config_id is not None:
+            payload["job_config_id"] = job_config_id
+        if config is not None:
+            payload["config"] = config
+        if metadata is not None:
+            payload["metadata"] = metadata
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return await self._http.post_json("/api/rl/jobs", json=payload, headers=headers)
+
+    async def list(
+        self,
+        *,
+        status: Optional[str] = None,
+        model: Optional[str] = None,
+        created_after: Optional[int] = None,
+        created_before: Optional[int] = None,
+        after: Optional[str] = None,
+        limit: int = 20,
+    ) -> Dict[str, Any]:
+        params: Dict[str, Any] = {"limit": limit}
+        if status is not None:
+            params["status"] = status
+        if model is not None:
+            params["model"] = model
+        if created_after is not None:
+            params["created_after"] = created_after
+        if created_before is not None:
+            params["created_before"] = created_before
+        if after is not None:
+            params["after"] = after
+        return await self._http.get("/api/rl/jobs", params=params)
+
+    async def retrieve(self, job_id: str) -> Dict[str, Any]:
+        return await self._http.get(f"/api/rl/jobs/{job_id}")
+
+    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]:
+        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]:
+        params = {"after_step": after_step, "limit": limit}
+        return await self._http.get(f"/api/rl/jobs/{job_id}/metrics", params=params)
+
+
+class ModelsApi:
+    def __init__(self, http: AsyncHttpClient) -> None:
+        self._http = http
+
+    async def list(
+        self,
+        *,
+        source: Optional[str] = None,
+        base_model: Optional[str] = None,
+        status: Optional[str] = None,
+        after: Optional[str] = None,
+        limit: int = 20,
+    ) -> Dict[str, Any]:
+        params: Dict[str, Any] = {"limit": limit}
+        if source is not None:
+            params["source"] = source
+        if base_model is not None:
+            params["base_model"] = base_model
+        if status is not None:
+            params["status"] = status
+        if after is not None:
+            params["after"] = after
+        return await self._http.get("/api/models", params=params)
+
+    async def retrieve(self, model_id: str) -> Dict[str, Any]:
+        return await self._http.get(f"/api/models/{model_id}")
+
+    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]:
+        params: Dict[str, Any] = {"limit": limit}
+        if after is not None:
+            params["after"] = after
+        return await self._http.get(f"/api/models/{model_id}/jobs", params=params)
+
+
+class JobsClient:
+    """High-level client aggregating job APIs.
+
+    Usage:
+        async with JobsClient(base_url, api_key) as c:
+            await c.files.list()
+    """
+
+    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
+        self._http = http or AsyncHttpClient(base_url, api_key, timeout=timeout)
+        self.files = FilesApi(self._http)
+        self.sft = SftJobsApi(self._http)
+        self.rl = RlJobsApi(self._http)
+        self.models = ModelsApi(self._http)
+
+    async def __aenter__(self) -> "JobsClient":
+        await self._http.__aenter__()
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:  # noqa: ANN001
+        await self._http.__aexit__(exc_type, exc, tb)

synth_ai/learning/__init__.py

@@ -0,0 +1,24 @@
+from .client import LearningClient
+from .rl_client import RlClient
+from .ft_client import FtClient
+from .validators import validate_training_jsonl, validate_trainer_cfg_rl
+from synth_ai.task import validate_task_app_url, task_app_health
+from .health import backend_health, pricing_preflight, balance_autumn_normalized
+from .sse import stream_events as stream_job_events
+from .jobs import JobHandle, JobsApiResolver
+
+__all__ = [
+    "LearningClient",
+    "RlClient",
+    "FtClient",
+    "validate_training_jsonl",
+    "validate_trainer_cfg_rl",
+    "validate_task_app_url",
+    "backend_health",
+    "task_app_health",
+    "pricing_preflight",
+    "balance_autumn_normalized",
+    "stream_job_events",
+    "JobHandle",
+    "JobsApiResolver",
+]