synth-ai 0.2.9.dev11__py3-none-any.whl → 0.4.1__py3-none-any.whl

synth_ai/http_client.py

@@ -1,136 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import os
-from dataclasses import dataclass
-from typing import Any
-
-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: aiohttp.ClientSession | None = None
-
-    async def __aenter__(self) -> AsyncHttpClient:
-        if self._session is None:
-            headers = {"authorization": f"Bearer {self._api_key}"}
-            # Optional dev overrides for user/org context
-            user_id = os.getenv("SYNTH_USER_ID") or os.getenv("X_USER_ID") or os.getenv("USER_ID")
-            if user_id:
-                headers["X-User-ID"] = user_id
-            org_id = os.getenv("SYNTH_ORG_ID") or os.getenv("X_ORG_ID") or os.getenv("ORG_ID")
-            if org_id:
-                headers["X-Org-ID"] = org_id
-            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: dict[str, Any] | None = None,
-        headers: dict[str, str] | None = 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: dict[str, str] | None = 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: dict[str, str] | None = 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: dict[str, str] | None = 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

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

synth_ai/inference/client.py

@@ -1,34 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from synth_ai.api.models.supported import (
-    UnsupportedModelError,
-    normalize_model_identifier,
-)
-
-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]:
-        try:
-            normalized_model = normalize_model_identifier(model)
-        except UnsupportedModelError as exc:
-            raise ValueError(str(exc)) from exc
-
-        body: dict[str, Any] = {"model": normalized_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:
-            # Route through backend inference proxy to Modal
-            return await http.post_json("/api/inference/v1/chat/completions", json=body)

synth_ai/jobs/client.py

@@ -1,271 +0,0 @@
-from __future__ import annotations
-
-from typing import Any
-
-from synth_ai.api.models.supported import normalize_model_identifier
-from synth_ai.http import AsyncHttpClient
-from synth_ai.learning.sft.config import prepare_sft_job_payload
-
-
-class FilesApi:
-    def __init__(self, http: AsyncHttpClient) -> None:
-        self._http = http
-
-    async def upload(
-        self,
-        *,
-        filename: str,
-        content: bytes,
-        purpose: str,
-        content_type: str | None = None,
-        idempotency_key: str | None = 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: str | None = None, after: str | None = 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: str | None = 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: str | None = None,
-        hyperparameters: dict[str, Any] | None = None,
-        suffix: str | None = None,
-        integrations: dict[str, Any] | None = None,
-        metadata: dict[str, Any] | None = None,
-        idempotency_key: str | None = None,
-    ) -> dict[str, Any]:
-        payload = prepare_sft_job_payload(
-            model=model,
-            training_file=training_file,
-            hyperparameters=hyperparameters,
-            metadata=metadata,
-            training_type=None,
-            validation_file=validation_file,
-            suffix=suffix,
-            integrations=integrations,
-            training_file_field="training_file",
-            require_training_file=True,
-        )
-        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: str | None = None,
-        model: str | None = None,
-        file_id: str | None = None,
-        created_after: int | None = None,
-        created_before: int | None = None,
-        after: str | None = 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: str | None = 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: dict[str, Any] | None = None,
-        job_config_id: str | None = None,
-        config: dict[str, Any] | None = None,
-        metadata: dict[str, Any] | None = None,
-        idempotency_key: str | None = None,
-    ) -> dict[str, Any]:
-        payload: dict[str, Any] = {
-            "model": normalize_model_identifier(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: str | None = None,
-        model: str | None = None,
-        created_after: int | None = None,
-        created_before: int | None = None,
-        after: str | None = 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: str | None = None,
-        base_model: str | None = None,
-        status: str | None = None,
-        after: str | None = 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: str | None = 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."""
-
-    def __init__(
-        self,
-        base_url: str,
-        api_key: str,
-        timeout: float = 30.0,
-        http: AsyncHttpClient | None = 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

@@ -1,59 +0,0 @@
-from synth_ai.task import task_app_health, validate_task_app_url
-
-from .client import LearningClient
-from .health import backend_health, balance_autumn_normalized, pricing_preflight
-from .jobs import JobHandle, JobsApiResolver
-from .rl import (
-    MAX_ENVIRONMENT_API_KEY_BYTES,
-    RlClient,
-    RLJobConfig,
-    RolloutEnvSpec,
-    RolloutMetrics,
-    RolloutPolicySpec,
-    RolloutRecordConfig,
-    RolloutRequest,
-    RolloutResponse,
-    RolloutSafetyConfig,
-    RolloutStep,
-    RolloutTrajectory,
-    encrypt_for_backend,
-    mint_environment_api_key,
-    setup_environment_api_key,
-)
-from .sft import FtClient
-from .sft.config import SFTJobConfig, prepare_sft_job_payload
-from .sse import stream_events as stream_job_events
-from .validators import validate_trainer_cfg_rl, validate_training_jsonl
-
-__all__ = [
-    "LearningClient",
-    "RlClient",
-    "RLJobConfig",
-    "FtClient",
-    "SFTJobConfig",
-    "prepare_sft_job_payload",
-    "RolloutEnvSpec",
-    "RolloutPolicySpec",
-    "RolloutRecordConfig",
-    "RolloutSafetyConfig",
-    "RolloutRequest",
-    "RolloutStep",
-    "RolloutTrajectory",
-    "RolloutMetrics",
-    "RolloutResponse",
-    "mint_environment_api_key",
-    "encrypt_for_backend",
-    "setup_environment_api_key",
-    "MAX_ENVIRONMENT_API_KEY_BYTES",
-    # convenience re-export for typing
-    "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",
-]