synth-ai 0.2.14__py3-none-any.whl → 0.4.4__py3-none-any.whl

synth_ai/handshake.py

@@ -1,109 +0,0 @@
-from __future__ import annotations
-
-import contextlib
-import os
-import time
-import webbrowser
-from typing import Any
-from urllib.parse import urljoin, urlsplit, urlunsplit
-
-import requests
-
-
-class HandshakeError(Exception):
-    pass
-
-
-_TRUTHY = {"1", "true", "yes", "on"}
-
-
-def _origin() -> str:
-    """Resolve the dashboard origin for the browser handshake.
-
-    Priority order:
-      1. Explicit ``SYNTH_CANONICAL_ORIGIN`` override.
-      2. Development flag ``SYNTH_CANONICAL_DEV`` (case-insensitive truthy) → localhost.
-      3. Production dashboard at ``https://www.usesynth.ai/dashboard``.
-    """
-
-    override = (os.getenv("SYNTH_CANONICAL_ORIGIN") or "").strip()
-    if override:
-        return override.rstrip("/")
-
-    dev_flag = (os.getenv("SYNTH_CANONICAL_DEV") or "").strip().lower()
-    if dev_flag in _TRUTHY:
-        print("USING DEV ORIGIN")
-        return "http://localhost:3000"
-
-    return "https://www.usesynth.ai/dashboard"
-
-
-def _split_origin(origin: str) -> tuple[str, str]:
-    parsed = urlsplit(origin)
-    bare = urlunsplit((parsed.scheme, parsed.netloc, "", "", ""))
-    path = parsed.path.rstrip("/")
-    return bare, path
-
-
-def _ensure_verification_uri(data: dict[str, Any], base_with_path: str) -> None:
-    uri = data.get("verification_uri")
-    if not isinstance(uri, str) or not uri:
-        return
-    if uri.startswith("http://") or uri.startswith("https://"):
-        return
-    data["verification_uri"] = urljoin(base_with_path.rstrip("/") + "/", uri.lstrip("/"))
-
-
-def start_handshake_session(origin: str | None = None) -> tuple[str, str, int, int]:
-    base = (origin or _origin()).rstrip("/")
-    api_origin, _ = _split_origin(base)
-    url = urljoin(api_origin.rstrip("/") + "/", "api/sdk/handshake/init")
-    r = requests.post(url, timeout=10)
-    if r.status_code != 200:
-        raise HandshakeError(f"init failed: {r.status_code} {r.text}")
-    try:
-        data = r.json()
-    except ValueError as exc:  # pragma: no cover - network dependent
-        raise HandshakeError(f"init returned malformed JSON: {exc}") from exc
-    _ensure_verification_uri(data, base)
-    return (
-        str(data.get("device_code")),
-        str(data.get("verification_uri")),
-        int(data.get("expires_in", 600)),
-        int(data.get("interval", 3)),
-    )
-
-
-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")
-    deadline = time.time() + (timeout_s or 600)
-    while True:
-        if time.time() > deadline:
-            raise HandshakeError("handshake timed out")
-        try:
-            r = requests.post(url, json={"device_code": device_code}, timeout=10)
-        except Exception:
-            time.sleep(2)
-            continue
-        if r.status_code == 200:
-            try:
-                data = r.json()
-            except ValueError as exc:  # pragma: no cover - network dependent
-                raise HandshakeError(f"token returned malformed JSON: {exc}") from exc
-            _ensure_verification_uri(data, base)
-            return data
-        elif r.status_code in (404, 410):
-            raise HandshakeError(f"handshake failed: {r.status_code}")
-        # 428 authorization_pending or others → wait and retry
-        time.sleep(2)
-
-
-def run_handshake(origin: str | None = None) -> dict[str, Any]:
-    device_code, verification_uri, expires_in, interval = start_handshake_session(origin)
-    with contextlib.suppress(Exception):
-        webbrowser.open(verification_uri)
-    return poll_handshake_token(device_code, origin, timeout_s=expires_in)

synth_ai/http.py

@@ -1,26 +0,0 @@
-"""
-Compatibility shim to avoid shadowing Python's stdlib `http` module.
-This re-exports the actual client implementation from http_client.py and
-supports both package and script execution contexts.
-"""
-
-try:
-    from synth_ai.http_client import *  # type: ignore F401,F403
-except Exception:
-    try:
-        from .http_client import *  # type: ignore F401,F403
-    except Exception:
-        import importlib.util as _ilu
-        import sys as _sys
-        from pathlib import Path as _Path
-
-        _here = _Path(__file__).resolve()
-        _client_path = _here.parent / "http_client.py"
-        _spec = _ilu.spec_from_file_location("http_client", str(_client_path))
-        if not _spec or not _spec.loader:
-            raise ImportError("Could not load http_client module") from None
-        _mod = _ilu.module_from_spec(_spec)
-        _spec.loader.exec_module(_mod)
-        _sys.modules["synth_ai.http_client"] = _mod
-        for _name in ("HTTPError", "AsyncHttpClient", "sleep"):
-            globals()[_name] = getattr(_mod, _name)

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,295 +0,0 @@
-from __future__ import annotations
-
-import importlib
-from collections.abc import Callable
-from typing import Any, cast
-
-try:
-    _supported_module = cast(
-        Any, importlib.import_module("synth_ai.api.models.supported")
-    )
-    normalize_model_identifier = cast(
-        Callable[[str], str], _supported_module.normalize_model_identifier
-    )
-except Exception as exc:  # pragma: no cover - critical dependency
-    raise RuntimeError("Unable to load supported model utilities") from exc
-
-try:
-    _http_module = cast(Any, importlib.import_module("synth_ai.http"))
-    AsyncHttpClient = _http_module.AsyncHttpClient
-except Exception as exc:  # pragma: no cover - critical dependency
-    raise RuntimeError("Unable to load HTTP client") from exc
-
-try:
-    _sft_config_module = cast(
-        Any, importlib.import_module("synth_ai.learning.sft.config")
-    )
-    prepare_sft_job_payload = cast(
-        Callable[..., dict[str, Any]], _sft_config_module.prepare_sft_job_payload
-    )
-except Exception as exc:  # pragma: no cover - critical dependency
-    raise RuntimeError("Unable to load SFT configuration helpers") from exc
-
-
-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)