dyadic 1.0.0__tar.gz

dyadic-1.0.0/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: dyadic
+Version: 1.0.0
+Summary: The official Python SDK for the Dyadic API (Iris, OpenAI-compatible).
+Author: Dyadic
+License: MIT
+Project-URL: Homepage, https://dyadic.app/developers/
+Project-URL: Documentation, https://dyadic.app/developers/
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx<1,>=0.25
+
+# dyadic
+
+The official Python SDK for the [Dyadic API](https://dyadic.app/developers/): use Iris
+from Python with streaming, function calling, images and typed errors. Requests use your Dyadic credits.
+
+```sh
+pip install dyadic
+```
+
+```python
+from dyadic import Dyadic
+
+client = Dyadic()  # reads DYADIC_API_KEY
+print(client.ask("Hello!", model="iris"))
+```
+
+See https://dyadic.app/developers/ for the full guide.

dyadic-1.0.0/README.md

@@ -0,0 +1,17 @@
+# dyadic
+
+The official Python SDK for the [Dyadic API](https://dyadic.app/developers/): use Iris
+from Python with streaming, function calling, images and typed errors. Requests use your Dyadic credits.
+
+```sh
+pip install dyadic
+```
+
+```python
+from dyadic import Dyadic
+
+client = Dyadic()  # reads DYADIC_API_KEY
+print(client.ask("Hello!", model="iris"))
+```
+
+See https://dyadic.app/developers/ for the full guide.

dyadic-1.0.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dyadic"
+version = "1.0.0"
+description = "The official Python SDK for the Dyadic API (Iris, OpenAI-compatible)."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Dyadic" }]
+dependencies = ["httpx>=0.25,<1"]
+classifiers = ["Programming Language :: Python :: 3", "License :: OSI Approved :: MIT License", "Typing :: Typed"]
+
+[project.urls]
+Homepage = "https://dyadic.app/developers/"
+Documentation = "https://dyadic.app/developers/"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+dyadic = ["py.typed"]

dyadic-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dyadic-1.0.0/src/dyadic/__init__.py

@@ -0,0 +1,18 @@
+"""The official Python SDK for the Dyadic API.
+
+    from dyadic import Dyadic
+    client = Dyadic()            # reads DYADIC_API_KEY
+    client.ask("Hello", model="iris")
+
+Sync (``Dyadic``) and async (``AsyncDyadic``) clients share one shape:
+``models``, ``chat.completions``, ``completions``, ``responses``, ``embeddings``,
+``audio`` (speech, transcriptions, translations), ``moderations``, ``images``,
+``files``, ``batches`` and ``ask``.
+Responses are ``APIObject`` values: dicts that also allow attribute access.
+"""
+from ._client import AsyncDyadic, Dyadic
+from ._errors import DyadicError
+from ._types import APIObject, AsyncStream, Binary, Image, Stream
+
+__version__ = "1.0.0"
+__all__ = ["Dyadic", "AsyncDyadic", "DyadicError", "APIObject", "Stream", "AsyncStream", "Image", "Binary", "__version__"]

dyadic-1.0.0/src/dyadic/_client.py

@@ -0,0 +1,434 @@
+from __future__ import annotations
+
+import mimetypes
+import os
+import random
+import time
+from typing import IO, Any, Dict, List, Optional, Tuple, Union
+
+import httpx
+
+from ._errors import DyadicError
+from ._types import APIObject, AsyncStream, Binary, Image, Stream
+
+DEFAULT_BASE_URL = "https://dyadic.app/api/openai/v1"
+RETRY_STATUSES = {408, 409, 429, 500, 502, 503, 504}
+Messages = List[Dict[str, Any]]
+FileInput = Union[str, "os.PathLike[str]", bytes, IO[bytes], Tuple[str, Any], Tuple[str, Any, str]]
+
+
+def _headers(api_key: str, app_name: Optional[str]) -> Dict[str, str]:
+    from . import __version__
+
+    headers = {"Authorization": f"Bearer {api_key}", "User-Agent": f"dyadic-python/{__version__}", "Accept": "application/json"}
+    if app_name:
+        headers["X-Title"] = app_name
+    return headers
+
+
+def _delay(attempt: int, response: Optional[httpx.Response]) -> float:
+    after = response.headers.get("retry-after") if response is not None else None
+    if after and after.replace(".", "", 1).isdigit():
+        return min(float(after), 30.0)
+    return min(0.5 * 2 ** attempt, 8.0) + random.random() * 0.25
+
+
+def _error(response: httpx.Response) -> DyadicError:
+    try:
+        data = response.json()
+    except ValueError:
+        data = {"error": {"message": response.text[:500] or f"HTTP {response.status_code}"}}
+    return DyadicError.from_response(response.status_code, data, response.headers.get("x-request-id", ""))
+
+
+def _out_of_quota(response: httpx.Response) -> bool:
+    """A usage limit or empty credit balance won't clear by retrying."""
+    try:
+        return (response.json().get("error") or {}).get("type") == "insufficient_quota"
+    except (ValueError, AttributeError):
+        return False
+
+
+def _clean(params: Dict[str, Any]) -> Dict[str, Any]:
+    return {k: v for k, v in params.items() if v is not None}
+
+
+def _file(value: FileInput, default_name: str = "file") -> Tuple[str, bytes, str]:
+    """(filename, bytes, content type) from a path, bytes, an open file or a
+    (filename, content[, content type]) tuple."""
+    if isinstance(value, tuple):
+        name, content = value[0], value[1]
+        kind = value[2] if len(value) > 2 else ""
+    elif isinstance(value, (str, os.PathLike)):
+        with open(value, "rb") as handle:
+            name, content, kind = os.path.basename(os.fspath(value)), handle.read(), ""
+    elif isinstance(value, (bytes, bytearray)):
+        name, content, kind = default_name, bytes(value), ""
+    else:
+        name, content, kind = os.path.basename(str(getattr(value, "name", "") or default_name)), value.read(), ""
+    if isinstance(content, str):
+        content = content.encode()
+    elif not isinstance(content, (bytes, bytearray)):
+        content = content.read()
+    return name, bytes(content), kind or mimetypes.guess_type(name)[0] or "application/octet-stream"
+
+
+def _form(params: Dict[str, Any]) -> Dict[str, Any]:
+    """Multipart text fields: lists repeat as name[] fields, numbers and
+    booleans become text."""
+    out: Dict[str, Any] = {}
+    for key, value in _clean(params).items():
+        if isinstance(value, (list, tuple)):
+            out[key if key.endswith("[]") else f"{key}[]"] = [str(v) for v in value]
+        elif isinstance(value, bool):
+            out[key] = "true" if value else "false"
+        else:
+            out[key] = str(value)
+    return out
+
+
+def _result(response: httpx.Response, raw: bool) -> Any:
+    kind = response.headers.get("content-type", "").split(";")[0].strip().lower()
+    if not raw and (kind == "application/json" or kind.endswith("+json")):
+        return APIObject.wrap(response.json())
+    if not raw and kind.startswith("text/"):
+        return response.text
+    return Binary(response.content, kind, response.headers.get("x-request-id", ""))
+
+
+class _Base:
+    def __init__(self, api_key: Optional[str], base_url: Optional[str], timeout: float, max_retries: int, app_name: Optional[str]) -> None:
+        self.api_key = api_key or os.environ.get("DYADIC_API_KEY") or ""
+        if not self.api_key:
+            raise DyadicError("No API key. Pass api_key= or set DYADIC_API_KEY. Create one at https://dyadic.app/workspace/?view=api.")
+        self.base_url = (base_url or os.environ.get("DYADIC_BASE_URL") or DEFAULT_BASE_URL).rstrip("/")
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.app_name = app_name
+
+    def _services(self) -> None:
+        # Shared by both clients: each method returns the client's request()
+        # result, a value for Dyadic and an awaitable for AsyncDyadic.
+        self.responses = _Responses(self)
+        self.embeddings = _Embeddings(self)
+        self.audio = _Audio(self)
+        self.moderations = _Moderations(self)
+        self.images = _Images(self)
+        self.files = _Files(self)
+        self.batches = _Batches(self)
+
+
+class Dyadic(_Base):
+    """The Dyadic API, synchronously.
+
+    ``Dyadic(api_key=None, base_url=None, timeout=600, max_retries=2,
+    app_name=None)``; the key defaults to ``DYADIC_API_KEY``. ``app_name`` is
+    shown as the app in your API activity log.
+    """
+
+    def __init__(self, api_key: Optional[str] = None, *, base_url: Optional[str] = None, timeout: float = 600.0,
+                 max_retries: int = 2, app_name: Optional[str] = None, http_client: Optional[httpx.Client] = None) -> None:
+        super().__init__(api_key, base_url, timeout, max_retries, app_name)
+        self._http = http_client or httpx.Client(timeout=httpx.Timeout(timeout, connect=10.0))
+        self.models = _Models(self)
+        self.chat = _Chat(self)
+        self.completions = _Completions(self)
+        self._services()
+
+    def request(self, method: str, path: str, body: Optional[dict] = None, *, stream: bool = False, files: Optional[dict] = None,
+                query: Optional[dict] = None, raw: bool = False, cast: Any = None) -> Any:
+        """Any API call: ``body`` is sent as JSON, or with ``files`` as
+        multipart form fields. Returns an APIObject (JSON), str (text) or
+        Binary (audio and file downloads), passed through ``cast`` if given."""
+        url = f"{self.base_url}{path}"
+        headers = _headers(self.api_key, self.app_name)
+        for attempt in range(self.max_retries + 1):
+            try:
+                if files is not None:
+                    request = self._http.build_request(method, url, data=_form(body or {}), files=files, params=_clean(query or {}), headers=headers)
+                else:
+                    request = self._http.build_request(method, url, json=body, params=_clean(query or {}), headers=headers)
+                response = self._http.send(request, stream=stream)
+            except httpx.TransportError as exc:
+                if attempt < self.max_retries:
+                    time.sleep(_delay(attempt, None))
+                    continue
+                raise DyadicError(f"Could not reach the Dyadic API: {exc}") from exc
+            if response.status_code < 400:
+                result = Stream(response) if stream else _result(response, raw)
+                return cast(result) if cast else result
+            if stream:
+                response.read()
+            if response.status_code in RETRY_STATUSES and attempt < self.max_retries and not _out_of_quota(response):
+                response.close()
+                time.sleep(_delay(attempt, response))
+                continue
+            raise _error(response)
+        raise DyadicError("The request could not be completed.")
+
+    def ask(self, prompt: str, *, model: str = "iris", system: Optional[str] = None, **params: Any) -> str:
+        """One question, one answer: the reply's text."""
+        messages: Messages = ([{"role": "system", "content": system}] if system else []) + [{"role": "user", "content": prompt}]
+        return self.chat.completions.create(model=model, messages=messages, **params).choices[0].message.content or ""
+
+    def openapi(self) -> APIObject:
+        """The API's OpenAPI description."""
+        return self.request("GET", "/openapi.json")
+
+    def close(self) -> None:
+        self._http.close()
+
+    def __enter__(self) -> "Dyadic":
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()
+
+
+class AsyncDyadic(_Base):
+    """The Dyadic API, asynchronously (same methods, awaited)."""
+
+    def __init__(self, api_key: Optional[str] = None, *, base_url: Optional[str] = None, timeout: float = 600.0,
+                 max_retries: int = 2, app_name: Optional[str] = None, http_client: Optional[httpx.AsyncClient] = None) -> None:
+        super().__init__(api_key, base_url, timeout, max_retries, app_name)
+        self._http = http_client or httpx.AsyncClient(timeout=httpx.Timeout(timeout, connect=10.0))
+        self.models = _AsyncModels(self)
+        self.chat = _AsyncChat(self)
+        self.completions = _AsyncCompletions(self)
+        self._services()
+
+    async def request(self, method: str, path: str, body: Optional[dict] = None, *, stream: bool = False, files: Optional[dict] = None,
+                      query: Optional[dict] = None, raw: bool = False, cast: Any = None) -> Any:
+        import asyncio
+
+        url = f"{self.base_url}{path}"
+        headers = _headers(self.api_key, self.app_name)
+        for attempt in range(self.max_retries + 1):
+            try:
+                if files is not None:
+                    request = self._http.build_request(method, url, data=_form(body or {}), files=files, params=_clean(query or {}), headers=headers)
+                else:
+                    request = self._http.build_request(method, url, json=body, params=_clean(query or {}), headers=headers)
+                response = await self._http.send(request, stream=stream)
+            except httpx.TransportError as exc:
+                if attempt < self.max_retries:
+                    await asyncio.sleep(_delay(attempt, None))
+                    continue
+                raise DyadicError(f"Could not reach the Dyadic API: {exc}") from exc
+            if response.status_code < 400:
+                result = AsyncStream(response) if stream else _result(response, raw)
+                return cast(result) if cast else result
+            if stream:
+                await response.aread()
+            if response.status_code in RETRY_STATUSES and attempt < self.max_retries and not _out_of_quota(response):
+                await response.aclose()
+                await asyncio.sleep(_delay(attempt, response))
+                continue
+            raise _error(response)
+        raise DyadicError("The request could not be completed.")
+
+    async def ask(self, prompt: str, *, model: str = "iris", system: Optional[str] = None, **params: Any) -> str:
+        messages: Messages = ([{"role": "system", "content": system}] if system else []) + [{"role": "user", "content": prompt}]
+        reply = await self.chat.completions.create(model=model, messages=messages, **params)
+        return reply.choices[0].message.content or ""
+
+    async def openapi(self) -> APIObject:
+        return await self.request("GET", "/openapi.json")
+
+    async def close(self) -> None:
+        await self._http.aclose()
+
+    async def __aenter__(self) -> "AsyncDyadic":
+        return self
+
+    async def __aexit__(self, *exc: Any) -> None:
+        await self.close()
+
+
+def _stream_body(params: Dict[str, Any], stream: bool) -> Dict[str, Any]:
+    body = _clean(params)
+    if stream:
+        body["stream"] = True
+        body.setdefault("stream_options", {"include_usage": True})
+    return body
+
+
+class _Models:
+    def __init__(self, client: Dyadic) -> None:
+        self._client = client
+
+    def list(self) -> List[APIObject]:
+        return self._client.request("GET", "/models").data
+
+    def retrieve(self, model: str) -> APIObject:
+        return self._client.request("GET", f"/models/{model}")
+
+
+class _ChatCompletions:
+    def __init__(self, client: Dyadic) -> None:
+        self._client = client
+
+    def create(self, *, model: str, messages: Messages, stream: bool = False, **params: Any) -> Union[APIObject, Stream]:
+        """POST /chat/completions. Any OpenAI field may be passed (tools,
+        response_format, top_p, seed...). With ``stream=True`` returns a Stream."""
+        body = _stream_body({"model": model, "messages": messages, **params}, stream)
+        return self._client.request("POST", "/chat/completions", body, stream=stream)
+
+
+class _Chat:
+    def __init__(self, client: Dyadic) -> None:
+        self.completions = _ChatCompletions(client)
+
+
+class _Completions:
+    def __init__(self, client: Dyadic) -> None:
+        self._client = client
+
+    def create(self, *, model: str, prompt: str, stream: bool = False, **params: Any) -> Union[APIObject, Stream]:
+        body = _stream_body({"model": model, "prompt": prompt, **params}, stream)
+        return self._client.request("POST", "/completions", body, stream=stream)
+
+
+class _AsyncModels:
+    def __init__(self, client: AsyncDyadic) -> None:
+        self._client = client
+
+    async def list(self) -> List[APIObject]:
+        return (await self._client.request("GET", "/models")).data
+
+    async def retrieve(self, model: str) -> APIObject:
+        return await self._client.request("GET", f"/models/{model}")
+
+
+class _AsyncChatCompletions:
+    def __init__(self, client: AsyncDyadic) -> None:
+        self._client = client
+
+    async def create(self, *, model: str, messages: Messages, stream: bool = False, **params: Any) -> Union[APIObject, AsyncStream]:
+        body = _stream_body({"model": model, "messages": messages, **params}, stream)
+        return await self._client.request("POST", "/chat/completions", body, stream=stream)
+
+
+class _AsyncChat:
+    def __init__(self, client: AsyncDyadic) -> None:
+        self.completions = _AsyncChatCompletions(client)
+
+
+class _AsyncCompletions:
+    def __init__(self, client: AsyncDyadic) -> None:
+        self._client = client
+
+    async def create(self, *, model: str, prompt: str, stream: bool = False, **params: Any) -> Union[APIObject, AsyncStream]:
+        body = _stream_body({"model": model, "prompt": prompt, **params}, stream)
+        return await self._client.request("POST", "/completions", body, stream=stream)
+
+
+class _Resource:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+
+class _Responses(_Resource):
+    def create(self, *, model: str, input: Any, stream: bool = False, **params: Any) -> Any:
+        """POST /responses. ``input`` is a string or a list of items; continue
+        a conversation with ``previous_response_id``. With ``stream=True``
+        returns a stream of Responses events (``stream.response`` at the end)."""
+        body = _clean({"model": model, "input": input, **params})
+        if stream:
+            body["stream"] = True
+        return self._client.request("POST", "/responses", body, stream=stream)
+
+    def retrieve(self, response_id: str) -> Any:
+        return self._client.request("GET", f"/responses/{response_id}")
+
+    def delete(self, response_id: str) -> Any:
+        return self._client.request("DELETE", f"/responses/{response_id}")
+
+    def input_items(self, response_id: str, **query: Any) -> Any:
+        return self._client.request("GET", f"/responses/{response_id}/input_items", query=query)
+
+    def cancel(self, response_id: str) -> Any:
+        return self._client.request("POST", f"/responses/{response_id}/cancel")
+
+
+class _Embeddings(_Resource):
+    def create(self, *, model: str, input: Union[str, List[str]], **params: Any) -> Any:
+        """POST /embeddings (text-embedding-3-small, text-embedding-3-large, text-embedding-ada-002)."""
+        return self._client.request("POST", "/embeddings", _clean({"model": model, "input": input, **params}))
+
+
+class _Speech(_Resource):
+    def create(self, *, model: str, voice: str, input: str, **params: Any) -> Any:
+        """POST /audio/speech: returns Binary audio (``.content``, ``.save(path)``)."""
+        return self._client.request("POST", "/audio/speech", _clean({"model": model, "voice": voice, "input": input, **params}), raw=True)
+
+
+class _Transcriptions(_Resource):
+    path = "/audio/transcriptions"
+
+    def create(self, *, file: FileInput, model: str, **params: Any) -> Any:
+        """Audio to text. Returns an APIObject for json formats, a str for
+        text, srt and vtt."""
+        return self._client.request("POST", self.path, {"model": model, **params}, files={"file": _file(file, "audio")})
+
+
+class _Translations(_Transcriptions):
+    path = "/audio/translations"
+
+
+class _Audio:
+    def __init__(self, client: Any) -> None:
+        self.speech = _Speech(client)
+        self.transcriptions = _Transcriptions(client)
+        self.translations = _Translations(client)
+
+
+class _Moderations(_Resource):
+    def create(self, *, input: Any, model: Optional[str] = None) -> Any:
+        return self._client.request("POST", "/moderations", _clean({"input": input, "model": model}))
+
+
+class _Images(_Resource):
+    def generate(self, prompt: str, **params: Any) -> Any:
+        return self._client.request("POST", "/images/generations", _clean({"prompt": prompt, **params}), cast=Image)
+
+    def edit(self, *, image: FileInput, prompt: str, **params: Any) -> Any:
+        """Change an image as the prompt describes."""
+        return self._client.request("POST", "/images/edits", {"prompt": prompt, **params}, files={"image": _file(image, "image.png")}, cast=Image)
+
+    def create_variation(self, *, image: FileInput, **params: Any) -> Any:
+        return self._client.request("POST", "/images/variations", params, files={"image": _file(image, "image.png")}, cast=Image)
+
+
+class _Files(_Resource):
+    def create(self, *, file: FileInput, purpose: str) -> Any:
+        """Upload a file (purpose batch for batch input, user_data to reference by file_id)."""
+        return self._client.request("POST", "/files", {"purpose": purpose}, files={"file": _file(file)})
+
+    def list(self, **query: Any) -> Any:
+        return self._client.request("GET", "/files", query=query)
+
+    def retrieve(self, file_id: str) -> Any:
+        return self._client.request("GET", f"/files/{file_id}")
+
+    def delete(self, file_id: str) -> Any:
+        return self._client.request("DELETE", f"/files/{file_id}")
+
+    def content(self, file_id: str) -> Any:
+        """The file's bytes as Binary (``.content``, ``.text``, ``.save(path)``)."""
+        return self._client.request("GET", f"/files/{file_id}/content", raw=True)
+
+
+class _Batches(_Resource):
+    def create(self, *, input_file_id: str, endpoint: str, completion_window: str = "24h", metadata: Optional[dict] = None) -> Any:
+        return self._client.request("POST", "/batches", _clean({"input_file_id": input_file_id, "endpoint": endpoint,
+                                                                "completion_window": completion_window, "metadata": metadata}))
+
+    def list(self, **query: Any) -> Any:
+        return self._client.request("GET", "/batches", query=query)
+
+    def retrieve(self, batch_id: str) -> Any:
+        return self._client.request("GET", f"/batches/{batch_id}")
+
+    def cancel(self, batch_id: str) -> Any:
+        return self._client.request("POST", f"/batches/{batch_id}/cancel")

dyadic-1.0.0/src/dyadic/_errors.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+
+class DyadicError(Exception):
+    """An error from the API (or the connection to it).
+
+    ``status`` is the HTTP status (0 for a connection failure); ``type``,
+    ``code`` and ``param`` come from the API's OpenAI-shaped error body.
+    """
+
+    def __init__(self, message: str, *, status: int = 0, type: str = "", code: Optional[str] = None,
+                 param: Optional[str] = None, request_id: str = "", body: Any = None) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status = status
+        self.type = type
+        self.code = code
+        self.param = param
+        self.request_id = request_id
+        self.body = body
+
+    def __repr__(self) -> str:
+        return f"DyadicError(status={self.status}, code={self.code!r}, message={self.message!r})"
+
+    @classmethod
+    def from_response(cls, status: int, data: Any, request_id: str = "") -> "DyadicError":
+        error = data.get("error") if isinstance(data, dict) else None
+        if isinstance(error, dict):
+            return cls(str(error.get("message") or f"HTTP {status}"), status=status, type=str(error.get("type") or ""),
+                       code=error.get("code"), param=error.get("param"), request_id=request_id, body=data)
+        return cls(f"HTTP {status}", status=status, request_id=request_id, body=data)

dyadic-1.0.0/src/dyadic/_types.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+import base64
+import json
+from typing import Any, AsyncIterator, Iterator, Optional
+
+from ._errors import DyadicError
+
+
+class APIObject(dict):
+    """A response object: a dict whose keys are also attributes."""
+
+    def __getattr__(self, name: str) -> Any:
+        try:
+            return self[name]
+        except KeyError:
+            if name.startswith("__"):
+                raise AttributeError(name) from None
+            return None
+
+    @classmethod
+    def wrap(cls, value: Any) -> Any:
+        if isinstance(value, dict):
+            return cls({k: cls.wrap(v) for k, v in value.items()})
+        if isinstance(value, list):
+            return [cls.wrap(v) for v in value]
+        return value
+
+    @property
+    def text(self) -> str:
+        """A chunk's or completion's text (content delta, message or legacy text)."""
+        if self.get("type") == "response.output_text.delta":
+            return self.get("delta") or ""
+        if self.get("object") == "response":
+            return self.get("output_text") or "".join(
+                part.get("text") or "" for item in self.get("output") or [] if item.get("type") == "message" for part in item.get("content") or [])
+        choices = self.get("choices") or []
+        if not choices:
+            return ""
+        choice = choices[0]
+        delta = choice.get("delta") or {}
+        message = choice.get("message") or {}
+        return delta.get("content") or message.get("content") or choice.get("text") or ""
+
+
+def _events(lines: Iterator[str]) -> Iterator[APIObject]:
+    for line in lines:
+        if not line.startswith("data:"):
+            continue
+        data = line[5:].strip()
+        if data == "[DONE]":
+            return
+        if not data:
+            continue
+        chunk = json.loads(data)
+        if isinstance(chunk, dict) and chunk.get("error"):
+            raise DyadicError.from_response(200, chunk)
+        if isinstance(chunk, dict) and chunk.get("type") == "response.failed":
+            raise DyadicError.from_response(200, {"error": (chunk.get("response") or {}).get("error") or {"message": "The response failed."}})
+        yield APIObject.wrap(chunk)
+
+
+class Stream:
+    """Iterate a streamed completion chunk by chunk. ``usage`` holds the final
+    usage (when the server sends it) and ``text`` the text so far."""
+
+    def __init__(self, response: Any) -> None:
+        self._response = response
+        self.usage: Optional[APIObject] = None
+        self.response: Optional[APIObject] = None
+        self.text = ""
+        self.request_id = response.headers.get("x-request-id", "")
+
+    def _take(self, chunk: APIObject) -> None:
+        if chunk.get("usage"):
+            self.usage = chunk["usage"]
+        if chunk.get("type") in ("response.completed", "response.incomplete") and chunk.get("response"):
+            self.response = chunk["response"]
+            self.usage = chunk["response"].get("usage")
+        self.text += chunk.text
+
+    def __iter__(self) -> Iterator[APIObject]:
+        try:
+            for chunk in _events(self._response.iter_lines()):
+                self._take(chunk)
+                yield chunk
+        finally:
+            self._response.close()
+
+    def until_done(self) -> str:
+        for _ in self:
+            pass
+        return self.text
+
+    def close(self) -> None:
+        self._response.close()
+
+    def __enter__(self) -> "Stream":
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()
+
+
+class AsyncStream:
+    """The async version of :class:`Stream` (``async for chunk in stream``)."""
+
+    def __init__(self, response: Any) -> None:
+        self._response = response
+        self.usage: Optional[APIObject] = None
+        self.response: Optional[APIObject] = None
+        self.text = ""
+        self.request_id = response.headers.get("x-request-id", "")
+
+    def _take(self, chunk: APIObject) -> None:
+        if chunk.get("usage"):
+            self.usage = chunk["usage"]
+        if chunk.get("type") in ("response.completed", "response.incomplete") and chunk.get("response"):
+            self.response = chunk["response"]
+            self.usage = chunk["response"].get("usage")
+        self.text += chunk.text
+
+    async def __aiter__(self) -> AsyncIterator[APIObject]:
+        try:
+            async for line in self._response.aiter_lines():
+                for chunk in _events(iter([line])):
+                    self._take(chunk)
+                    yield chunk
+                if line.strip() == "data: [DONE]":
+                    return
+        finally:
+            await self._response.aclose()
+
+    async def until_done(self) -> str:
+        async for _ in self:
+            pass
+        return self.text
+
+    async def close(self) -> None:
+        await self._response.aclose()
+
+    async def __aenter__(self) -> "AsyncStream":
+        return self
+
+    async def __aexit__(self, *exc: Any) -> None:
+        await self.close()
+
+
+class Image(APIObject):
+    """A generated image: ``bytes`` (when returned inline), ``url``, ``save()``."""
+
+    @property
+    def bytes(self) -> Optional[bytes]:
+        item = (self.get("data") or [{}])[0]
+        return base64.b64decode(item["b64_json"]) if item.get("b64_json") else None
+
+    @property
+    def url(self) -> Optional[str]:
+        return (self.get("data") or [{}])[0].get("url")
+
+    def save(self, path: str) -> str:
+        content = self.bytes
+        if content is None:
+            raise DyadicError("This image was returned as a URL; download it from image.url.")
+        with open(path, "wb") as handle:
+            handle.write(content)
+        return path
+
+
+class Binary:
+    """Bytes from the API (speech audio, file downloads): ``content``,
+    ``content_type``, ``text`` and ``save(path)``."""
+
+    def __init__(self, content: bytes, content_type: str = "", request_id: str = "") -> None:
+        self.content = content
+        self.content_type = content_type
+        self.request_id = request_id
+
+    @property
+    def text(self) -> str:
+        return self.content.decode("utf-8", errors="replace")
+
+    def save(self, path: str) -> str:
+        with open(path, "wb") as handle:
+            handle.write(self.content)
+        return path
+
+    def __len__(self) -> int:
+        return len(self.content)
+
+    def __repr__(self) -> str:
+        return f"Binary({self.content_type or 'application/octet-stream'}, {len(self.content)} bytes)"

dyadic-1.0.0/src/dyadic.egg-info/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: dyadic
+Version: 1.0.0
+Summary: The official Python SDK for the Dyadic API (Iris, OpenAI-compatible).
+Author: Dyadic
+License: MIT
+Project-URL: Homepage, https://dyadic.app/developers/
+Project-URL: Documentation, https://dyadic.app/developers/
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx<1,>=0.25
+
+# dyadic
+
+The official Python SDK for the [Dyadic API](https://dyadic.app/developers/): use Iris
+from Python with streaming, function calling, images and typed errors. Requests use your Dyadic credits.
+
+```sh
+pip install dyadic
+```
+
+```python
+from dyadic import Dyadic
+
+client = Dyadic()  # reads DYADIC_API_KEY
+print(client.ask("Hello!", model="iris"))
+```
+
+See https://dyadic.app/developers/ for the full guide.

dyadic-1.0.0/src/dyadic.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/dyadic/__init__.py
+src/dyadic/_client.py
+src/dyadic/_errors.py
+src/dyadic/_types.py
+src/dyadic/py.typed
+src/dyadic.egg-info/PKG-INFO
+src/dyadic.egg-info/SOURCES.txt
+src/dyadic.egg-info/dependency_links.txt
+src/dyadic.egg-info/requires.txt
+src/dyadic.egg-info/top_level.txt
+tests/test_client.py

dyadic-1.0.0/src/dyadic.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dyadic-1.0.0/src/dyadic.egg-info/requires.txt

@@ -0,0 +1 @@
+httpx<1,>=0.25

dyadic-1.0.0/src/dyadic.egg-info/top_level.txt

@@ -0,0 +1 @@
+dyadic

dyadic-1.0.0/tests/test_client.py

@@ -0,0 +1,159 @@
+"""The dyadic SDK against a mocked API: requests carry the key, app name and
+OpenAI fields; responses read as attributes; streams yield chunks, text and
+usage; tool-call chunks arrive; errors raise DyadicError with the API's
+code; retryable failures retry but a quota error does not; async mirrors sync;
+images decode and save."""
+import base64
+import json
+
+import httpx
+import pytest
+
+from dyadic import AsyncDyadic, Dyadic, DyadicError
+
+SSE = "".join(f"data: {json.dumps(c)}\n\n" for c in (
+    {"choices": [{"index": 0, "delta": {"role": "assistant", "content": ""}}]},
+    {"choices": [{"index": 0, "delta": {"content": "Hel"}}]},
+    {"choices": [{"index": 0, "delta": {"content": "lo"}}]},
+    {"choices": [{"index": 0, "delta": {"tool_calls": [{"index": 0, "id": "c1", "function": {"name": "f", "arguments": "{}"}}]}}]},
+    {"choices": [], "usage": {"prompt_tokens": 3, "completion_tokens": 2, "dyadic": {"credits": 1.5}}},
+)) + "data: [DONE]\n\n"
+
+
+def handler(seen):
+    def respond(request: httpx.Request) -> httpx.Response:
+        body = json.loads(request.content or b"{}")
+        seen.append((request, body))
+        if request.url.path.endswith("/models"):
+            return httpx.Response(200, json={"object": "list", "data": [{"id": "iris"}, {"id": "iris-think"}]})
+        if request.url.path.endswith("/images/generations"):
+            return httpx.Response(200, json={"created": 1, "data": [{"b64_json": base64.b64encode(b"png").decode()}]})
+        if body.get("model") == "broke":
+            return httpx.Response(429, json={"error": {"message": "Out of credits", "type": "insufficient_quota", "code": "insufficient_quota"}})
+        if body.get("model") == "flaky" and len(seen) < 2:
+            return httpx.Response(503, json={"error": {"message": "busy", "type": "server_error"}}, headers={"retry-after": "0"})
+        if body.get("stream"):
+            return httpx.Response(200, text=SSE, headers={"content-type": "text/event-stream", "x-request-id": "r1"})
+        return httpx.Response(200, json={"id": "x", "object": "chat.completion", "choices": [{"index": 0, "message": {"role": "assistant", "content": "Hi there"}, "finish_reason": "stop"}],
+                                        "usage": {"total_tokens": 5}, "dyadic": {"credits": 0.5}})
+    return respond
+
+
+def client(seen, **kwargs):
+    return Dyadic(api_key="dya-test", app_name="Tests", http_client=httpx.Client(transport=httpx.MockTransport(handler(seen))), **kwargs)
+
+
+def test_requests_responses_and_streams():
+    seen = []
+    api = client(seen)
+    assert api.ask("Hello", model="iris", system="Be brief.", top_p=0.5) == "Hi there"
+    request, body = seen[-1]
+    assert request.headers["authorization"] == "Bearer dya-test" and request.headers["x-title"] == "Tests"
+    assert str(request.url) == "https://dyadic.app/api/openai/v1/chat/completions"
+    assert body == {"model": "iris", "messages": [{"role": "system", "content": "Be brief."}, {"role": "user", "content": "Hello"}], "top_p": 0.5}
+    reply = api.chat.completions.create(model="iris", messages=[{"role": "user", "content": "x"}])
+    assert reply.choices[0].message.content == "Hi there" and reply.dyadic.credits == 0.5 and reply.missing is None
+    stream = api.chat.completions.create(model="iris", messages=[{"role": "user", "content": "x"}], stream=True)
+    chunks = list(stream)
+    assert seen[-1][1]["stream_options"] == {"include_usage": True} and stream.text == "Hello" and stream.usage.dyadic.credits == 1.5
+    assert chunks[3].choices[0].delta.tool_calls[0].function.name == "f" and stream.request_id == "r1"
+    assert [m.id for m in api.models.list()] == ["iris", "iris-think"]
+    assert api.images.generate("a cat").bytes == b"png"
+
+
+def test_errors_and_retries(tmp_path, monkeypatch):
+    monkeypatch.setattr("dyadic._client._delay", lambda *a: 0)
+    seen = []
+    api = client(seen)
+    with pytest.raises(DyadicError) as error:
+        api.ask("x", model="broke")
+    assert error.value.status == 429 and error.value.code == "insufficient_quota" and len(seen) == 1
+    seen.clear()
+    assert api.ask("x", model="flaky") == "Hi there" and len(seen) == 2
+    image = api.images.generate("a dog")
+    assert open(image.save(str(tmp_path / "dog.png")), "rb").read() == b"png"
+    monkeypatch.delenv("DYADIC_API_KEY", raising=False)
+    with pytest.raises(DyadicError):
+        Dyadic()
+
+
+@pytest.mark.asyncio
+async def test_async_client():
+    seen = []
+    async with AsyncDyadic(api_key="dya-test", http_client=httpx.AsyncClient(transport=httpx.MockTransport(handler(seen)))) as api:
+        assert await api.ask("Hello") == "Hi there"
+        stream = await api.chat.completions.create(model="iris", messages=[{"role": "user", "content": "x"}], stream=True)
+        assert [c.text async for c in stream][1:3] == ["Hel", "lo"] and stream.usage.prompt_tokens == 3
+        assert [m.id for m in await api.models.list()] == ["iris", "iris-think"]
+
+
+RESPONSE_SSE = "".join(f"event: {e['type']}\ndata: {json.dumps(e)}\n\n" for e in (
+    {"type": "response.created", "sequence_number": 0, "response": {"id": "resp_1", "status": "in_progress"}},
+    {"type": "response.output_text.delta", "sequence_number": 1, "delta": "Hel"},
+    {"type": "response.output_text.delta", "sequence_number": 2, "delta": "lo"},
+    {"type": "response.completed", "sequence_number": 3, "response": {"id": "resp_1", "status": "completed", "usage": {"total_tokens": 4}}},
+))
+
+
+def services(seen):
+    def respond(request: httpx.Request) -> httpx.Response:
+        path = request.url.path.removeprefix("/api/openai/v1")
+        kind = request.headers.get("content-type", "")
+        body = json.loads(request.content) if kind.startswith("application/json") else request.content
+        seen.append((request, body))
+        if path == "/responses" and body.get("stream"):
+            return httpx.Response(200, text=RESPONSE_SSE, headers={"content-type": "text/event-stream"})
+        if path == "/responses":
+            return httpx.Response(200, json={"id": "resp_1", "object": "response", "status": "completed", "output": [
+                {"type": "message", "content": [{"type": "output_text", "text": "Hi"}]}]})
+        if path == "/audio/speech":
+            return httpx.Response(200, content=b"ID3", headers={"content-type": "audio/mpeg"})
+        if path == "/audio/transcriptions":
+            return httpx.Response(200, text="Hello.", headers={"content-type": "text/plain"})
+        if path == "/files/file-1/content":
+            return httpx.Response(200, content=b'{"a": 1}\n', headers={"content-type": "application/jsonl"})
+        if path == "/images/edits":
+            return httpx.Response(200, json={"created": 1, "data": [{"b64_json": base64.b64encode(b"png").decode()}]})
+        return httpx.Response(200, json={"object": "echo", "path": path, "query": dict(request.url.params)})
+    return respond
+
+
+def test_service_resources(tmp_path):
+    seen = []
+    api = Dyadic(api_key="dya-test", http_client=httpx.Client(transport=httpx.MockTransport(services(seen))))
+    reply = api.responses.create(model="iris", input="Hi", previous_response_id="resp_0")
+    assert reply.text == "Hi" and seen[-1][1] == {"model": "iris", "input": "Hi", "previous_response_id": "resp_0"}
+    stream = api.responses.create(model="iris", input="Hi", stream=True)
+    assert [e.type for e in stream][-1] == "response.completed" and stream.text == "Hello" and stream.response.id == "resp_1"
+    assert stream.usage.total_tokens == 4
+    assert api.responses.delete("resp_1").path == "/responses/resp_1" and seen[-1][0].method == "DELETE"
+    assert api.responses.input_items("resp_1", limit=5).query == {"limit": "5"}
+    assert api.embeddings.create(model="text-embedding-3-small", input=["a"]).path == "/embeddings"
+    audio = api.audio.speech.create(model="tts-1", voice="alloy", input="Hello")
+    assert audio.content == b"ID3" and audio.content_type == "audio/mpeg" and open(audio.save(str(tmp_path / "a.mp3")), "rb").read() == b"ID3"
+    text = api.audio.transcriptions.create(file=("clip.wav", b"RIFF", "audio/wav"), model="whisper-1", response_format="text",
+                                           timestamp_granularities=["segment"])
+    request, raw = seen[-1]
+    assert text == "Hello." and request.headers["content-type"].startswith("multipart/form-data")
+    assert b'name="file"; filename="clip.wav"' in raw and b'name="timestamp_granularities[]"' in raw and b"whisper-1" in raw
+    path = tmp_path / "batch.jsonl"
+    path.write_text('{"custom_id": "1"}\n')
+    api.files.create(file=str(path), purpose="batch")
+    assert b'filename="batch.jsonl"' in seen[-1][1] and b"batch" in seen[-1][1]
+    assert api.files.content("file-1").text == '{"a": 1}\n'
+    assert api.batches.create(input_file_id="file-1", endpoint="/v1/chat/completions").path == "/batches"
+    assert seen[-1][1] == {"input_file_id": "file-1", "endpoint": "/v1/chat/completions", "completion_window": "24h"}
+    assert api.batches.cancel("batch_1").path == "/batches/batch_1/cancel"
+    assert api.moderations.create(input="x").path == "/moderations"
+    assert api.images.edit(image=b"png", prompt="Add a hat").bytes == b"png"
+
+
+@pytest.mark.asyncio
+async def test_async_service_resources():
+    seen = []
+    async with AsyncDyadic(api_key="dya-test", http_client=httpx.AsyncClient(transport=httpx.MockTransport(services(seen)))) as api:
+        assert (await api.responses.create(model="iris", input="Hi")).text == "Hi"
+        stream = await api.responses.create(model="iris", input="Hi", stream=True)
+        assert "".join([e.text async for e in stream]) == "Hello" and stream.response.status == "completed"
+        assert (await api.audio.speech.create(model="tts-1", voice="alloy", input="x")).content == b"ID3"
+        assert (await api.images.edit(image=b"png", prompt="x")).bytes == b"png"