saia-python 0.7.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

saia_python/__init__.py

@@ -18,6 +18,12 @@ import concurrent.futures
 from importlib.metadata import PackageNotFoundError, version
 
 from ._http import RetryPolicy
+from ._payloads import (
+    INFERENCE_SERVICE,
+    apply_arcana_fields,
+    arcana_chat_headers,
+    build_chat_body,
+)
 from ._streaming import SSEStream
 from .arcana_references import (
     ArcanaReference,
@@ -40,7 +46,7 @@ from .client import SAIAClient
 from .documents import ConversionImage, ConversionResult
 from .exceptions import APIError, AuthenticationError, RateLimitError, SAIAError
 from .openai_compat import create_openai_client
-from .rate_limits import RateLimitInfo, parse_rate_limits
+from .rate_limits import RateLimitInfo, format_rate_limit_error, parse_rate_limits
 from .responses import text_of
 from .tokenizer import (
     DEFAULT_TOKENIZER_DIR,
@@ -95,6 +101,12 @@ __all__ = [
     # Rate limits
     "RateLimitInfo",
     "parse_rate_limits",
+    "format_rate_limit_error",
+    # Request builders (pure — shared by sync, async, and external gateways)
+    "build_chat_body",
+    "apply_arcana_fields",
+    "arcana_chat_headers",
+    "INFERENCE_SERVICE",
     # Response helpers
     "text_of",
     "SSEStream",
@@ -142,6 +154,23 @@ __all__ = [
     "ConversionImage",
 ]
 
+# Async API (the ``[async]`` extra: ``pip install saia-python[async]``). Exposed
+# lazily so importing ``saia_python`` never pulls ``httpx`` for sync-only users;
+# ``from saia_python import AsyncSAIAClient`` still works when httpx is present.
+# Kept OUT of ``__all__`` so ``from saia_python import *`` stays httpx-free.
+_ASYNC_EXPORTS = frozenset(
+    {"AsyncSAIAClient", "AsyncChatService", "AsyncArcanaService", "AsyncModelsService"}
+)
+
+
+def __getattr__(name: str):
+    """Lazily resolve the async client from :mod:`saia_python.aio` on access."""
+    if name in _ASYNC_EXPORTS:
+        from . import aio
+
+        return getattr(aio, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
 
 def _make_client(api_key: str | None = None, base_url: str | None = None) -> SAIAClient:
     kwargs: dict = {}

saia_python/_async_http.py

@@ -0,0 +1,127 @@
+"""Async HTTP plumbing — the ``httpx.AsyncClient`` twin of :mod:`saia_python._http`.
+
+Mirrors :func:`~saia_python._http.execute` and
+:func:`~saia_python._http.post_chat_completion` over ``httpx.AsyncClient``,
+**reusing the pure retry brains** (:class:`~saia_python._http.RetryPolicy`,
+``_plan``, ``_jitter``) and :func:`~saia_python.rate_limits.parse_rate_limits`
+unchanged — so the sync and async paths can never drift on rate-limit handling.
+Only the socket-touching parts (``await client.request(...)`` /
+``await resp.aclose()`` / ``await asyncio.sleep(...)``) are re-implemented.
+
+This module never imports ``httpx`` at runtime — it only *calls methods* on a
+client object the caller supplies, so it stays import-safe without the
+``[async]`` extra and is trivially testable with a fake client. Construct the
+client via :class:`saia_python.aio.AsyncSAIAClient` (or pass your own
+``httpx.AsyncClient``).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING, Any
+
+from ._http import RetryPolicy, _jitter, _plan
+from .exceptions import raise_for_status
+from .rate_limits import parse_rate_limits
+
+if TYPE_CHECKING:
+    import httpx
+
+log = logging.getLogger(__name__)
+
+#: An awaitable ``sleep(seconds)`` — ``asyncio.sleep`` in production; tests pass
+#: a recorder so they never actually block.
+AsyncSleep = Callable[..., Awaitable[Any]]
+
+
+async def aexecute(
+    client: httpx.AsyncClient,
+    method: str,
+    url: str,
+    *,
+    policy: RetryPolicy,
+    idempotent: bool,
+    sleep: AsyncSleep = asyncio.sleep,
+    **kwargs: Any,
+) -> httpx.Response:
+    """Issue a request under a transport policy and return the response.
+
+    The async analogue of :func:`saia_python._http.execute`: dispatches
+    ``getattr(client, method)(url, **kwargs)`` (``method`` is the lowercase verb
+    — ``"post"`` / ``"get"`` — matching the sync seam) and, on HTTP 429 that the
+    ``policy`` permits, waits per :func:`~saia_python._http._plan` and retries.
+
+    Like the sync version it returns the **raw response** unchanged on success
+    *or* on give-up, so the caller's
+    :func:`~saia_python.exceptions.raise_for_status` still raises
+    :class:`~saia_python.RateLimitError` when retry is off, the budget is spent,
+    or the window must not be waited on. Only status + headers are inspected —
+    never the body — so a give-up never consumes the response. Streaming is a
+    separate seam (:class:`saia_python.aio.AsyncSSEStream`), because ``httpx``
+    exposes a streamed body only inside ``client.stream(...)``.
+    """
+    attempt = 0
+    while True:
+        resp = await getattr(client, method)(url, **kwargs)
+        if resp.status_code != 429 or not policy.applies(idempotent):
+            return resp
+        wait = _plan(parse_rate_limits(resp.headers), policy, attempt)
+        if wait is None:
+            return resp
+        await resp.aclose()
+        attempt += 1
+        wait += _jitter(policy)
+        log.info("SAIA rate limit (429) — waiting %.1fs before retry %d", wait, attempt)
+        await sleep(wait)
+
+
+async def apost_chat_completion(
+    client: httpx.AsyncClient,
+    url: str,
+    body: dict,
+    *,
+    headers: dict | None = None,
+    stream: bool = False,
+    policy: RetryPolicy | None = None,
+    sleep: AsyncSleep = asyncio.sleep,
+) -> dict | Any:
+    """POST a chat-completion request and normalise the response (async).
+
+    The async twin of :func:`saia_python._http.post_chat_completion`. For
+    ``stream=False`` it returns the response dict with an extra
+    ``"_rate_limits"`` key; for ``stream=True`` it returns a connected
+    :class:`~saia_python.aio.AsyncSSEStream` (imported lazily to avoid a cycle),
+    with the initial-429 retry already applied *before* the stream is exposed —
+    never mid-stream, exactly like the sync path.
+    """
+    policy = policy if policy is not None else RetryPolicy()
+    if stream:
+        from ._async_streaming import AsyncSSEStream
+
+        stream_body = {**body, "stream": True}
+        stream_headers = {**(headers or {}), "Accept": "text/event-stream"}
+        return await AsyncSSEStream.open(
+            client,
+            url,
+            json=stream_body,
+            headers=stream_headers,
+            policy=policy,
+            sleep=sleep,
+        )
+
+    resp = await aexecute(
+        client,
+        "post",
+        url,
+        policy=policy,
+        idempotent=True,
+        sleep=sleep,
+        json=body,
+        headers=headers,
+    )
+    raise_for_status(resp)
+    result = resp.json()
+    result["_rate_limits"] = parse_rate_limits(resp.headers).to_dict()
+    return result

saia_python/_async_streaming.py

@@ -0,0 +1,157 @@
+"""Async SSE streaming — the ``httpx.AsyncClient`` twin of :mod:`saia_python._streaming`.
+
+``httpx`` only exposes a streamed body inside an ``async with client.stream(...)``
+context, so unlike the sync :class:`~saia_python._streaming.SSEStream` (which
+wraps an already-open ``requests`` response) this class **owns** that context
+manager: :meth:`AsyncSSEStream.open` enters it — retrying an initial 429 *before*
+any body is exposed, exactly like the sync path — and :meth:`aclose` / the
+``async with`` protocol exits it.
+
+Like :mod:`saia_python._async_http`, this module never imports ``httpx`` at
+runtime; it only calls methods on the client / response the caller supplies,
+staying import-safe without the ``[async]`` extra and trivially fakeable in tests.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from collections.abc import AsyncIterator
+from typing import TYPE_CHECKING, Any
+
+from ._async_http import AsyncSleep
+from ._http import RetryPolicy, _jitter, _plan
+from .exceptions import raise_for_status
+from .rate_limits import parse_rate_limits
+
+if TYPE_CHECKING:
+    import httpx
+
+log = logging.getLogger(__name__)
+
+
+class AsyncSSEStream:
+    """Async iterable over the SSE chunks of an ``httpx`` streaming response.
+
+    The async twin of :class:`~saia_python._streaming.SSEStream`. Two
+    consumption modes — pick **one**, because a streamed body can only be read
+    once:
+
+    * ``async for chunk in stream`` — decoded ``dict`` chunks (the high-level
+      API). Surfaces a typed error (:class:`~saia_python.RateLimitError` with an
+      informative message on 429, etc.) *before* the first chunk if the upstream
+      status is an error.
+    * ``async for line in stream.aiter_lines()`` — the raw decoded ``str`` SSE
+      lines. Does **not** raise, so a gateway can frame upstream errors itself
+      (this is what the AVOR adapter uses to keep its verbatim ``[DONE]`` /
+      non-``data:`` line passthrough).
+
+    Either way, use it as an async context manager (``async with stream:``) or
+    call :meth:`aclose` so the upstream connection is released.
+
+    Attributes:
+        status_code: The final upstream status code (after any retry).
+        rate_limits: A JSON-serializable dict of the response's rate-limit
+            headers (available immediately — headers arrive before the body).
+    """
+
+    def __init__(self, cm: Any, response: httpx.Response):
+        self._cm: Any = cm
+        self._response = response
+        self.status_code: int = response.status_code
+        self.rate_limits: dict = parse_rate_limits(response.headers).to_dict()
+
+    @classmethod
+    async def open(
+        cls,
+        client: httpx.AsyncClient,
+        url: str,
+        *,
+        json: dict,
+        headers: dict | None = None,
+        policy: RetryPolicy | None = None,
+        sleep: AsyncSleep = asyncio.sleep,
+    ) -> AsyncSSEStream:
+        """Open the stream, retrying an initial 429 before exposing the body.
+
+        Mirrors :func:`saia_python._http.execute`'s retry loop, but over
+        ``client.stream(...)``: it enters the context, and on a retryable 429
+        exits it (releasing the socket) and re-issues after the planned wait.
+        Only status + headers are inspected, so the streamed body is never
+        consumed by the retry decision. Returns a connected stream whose
+        ``status_code`` reflects the final attempt (which may still be an error
+        the caller inspects).
+        """
+        policy = policy if policy is not None else RetryPolicy()
+        attempt = 0
+        while True:
+            cm = client.stream("POST", url, json=json, headers=headers)
+            response = await cm.__aenter__()
+            if response.status_code != 429 or not policy.applies(True):
+                return cls(cm, response)
+            wait = _plan(parse_rate_limits(response.headers), policy, attempt)
+            if wait is None:
+                return cls(cm, response)
+            await cm.__aexit__(None, None, None)
+            attempt += 1
+            wait += _jitter(policy)
+            log.info(
+                "SAIA rate limit (429) — waiting %.1fs before retry %d", wait, attempt
+            )
+            await sleep(wait)
+
+    async def aiter_lines(self) -> AsyncIterator[str]:
+        """Yield the raw decoded SSE lines (no dict parsing, no raise).
+
+        The low-level surface: the caller sees every line verbatim (``data:``
+        payloads, ``data: [DONE]``, blank event terminators) and decides how to
+        frame errors and what to forward. Releases the connection when the
+        consumer stops, whether it finished, broke early, or was cancelled.
+        """
+        try:
+            async for raw in self._response.aiter_lines():
+                yield raw if isinstance(raw, str) else raw.decode("utf-8")
+        finally:
+            await self.aclose()
+
+    async def __aiter__(self) -> AsyncIterator[dict]:
+        """Yield decoded ``dict`` chunks (high-level; raises on an error status).
+
+        Copies the sync :func:`~saia_python._streaming.iter_sse` decision logic
+        verbatim: skip non-``data:`` lines, stop on ``[DONE]``, ``json.loads``
+        each payload, silently skip an unparseable one.
+        """
+        if self.status_code >= 400:
+            await self._response.aread()
+            raise_for_status(self._response)
+        try:
+            async for raw in self._response.aiter_lines():
+                line = raw if isinstance(raw, str) else raw.decode("utf-8")
+                if not line or not line.startswith("data:"):
+                    continue
+                payload = line[len("data:") :].strip()
+                if payload == "[DONE]":
+                    return
+                try:
+                    yield json.loads(payload)
+                except json.JSONDecodeError:
+                    continue
+        finally:
+            await self.aclose()
+
+    async def aread(self) -> bytes:
+        """Read and return the full upstream body (used to frame an error)."""
+        return await self._response.aread()
+
+    async def aclose(self) -> None:
+        """Release the upstream connection. Idempotent."""
+        if self._cm is not None:
+            cm, self._cm = self._cm, None
+            await cm.__aexit__(None, None, None)
+
+    async def __aenter__(self) -> AsyncSSEStream:
+        return self
+
+    async def __aexit__(self, *exc: object) -> None:
+        await self.aclose()

saia_python/_payloads.py

@@ -0,0 +1,81 @@
+"""Pure request-body / header builders shared across transports.
+
+Transport-free — no ``Session``, no ``httpx.AsyncClient``, no I/O — so these
+helpers are reused **verbatim** by the sync services (:mod:`saia_python.chat`,
+:mod:`saia_python.arcana`), the async services (:mod:`saia_python.aio`), and
+external gateways that assemble the request themselves (the AVOR adapter builds
+its own body so it can inject a per-conversation system prompt, then reuses
+:func:`apply_arcana_fields` to keep the ARCANA injection identical to ours).
+
+Keeping the ARCANA injection in ONE place matters: GWDG only routes a request
+through the retrieval pipeline when **all three** of ``enable-tools`` + the
+``arcana.id`` body field *and* the ``inference-service`` header are present.
+Drop any one and the request still returns 200 — but with no retrieval. That
+invariant now lives in :func:`apply_arcana_fields` + :func:`arcana_chat_headers`
+instead of being retyped at every call site.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+#: The GWDG gateway value that opts a chat request into the ARCANA retrieval
+#: pipeline. Sent as the ``inference-service`` header (see
+#: :func:`arcana_chat_headers`); without it retrieval never fires.
+INFERENCE_SERVICE = "saia-openai-gateway"
+
+
+def build_chat_body(
+    model: str,
+    messages: list[dict],
+    *,
+    temperature: float | None = None,
+    top_p: float | None = None,
+    max_tokens: int | None = None,
+    **kwargs: Any,
+) -> dict:
+    """Assemble an OpenAI-shaped ``/chat/completions`` request body.
+
+    The sampling knobs are omitted from the body when ``None`` (so the server's
+    own defaults apply) rather than being sent as ``null``. Extra ``kwargs`` are
+    merged verbatim, letting callers pass ``stop``, ``stream``, ``seed``, etc.
+    """
+    body: dict = {"model": model, "messages": messages, **kwargs}
+    if temperature is not None:
+        body["temperature"] = temperature
+    if top_p is not None:
+        body["top_p"] = top_p
+    if max_tokens is not None:
+        body["max_tokens"] = max_tokens
+    return body
+
+
+def apply_arcana_fields(body: dict, arcana_id: str) -> dict:
+    """Return ``body`` with the ARCANA RAG **body** fields injected.
+
+    Adds ``enable-tools: true`` and ``arcana: {"id": arcana_id}``. Returns a
+    **new** dict (the input is left unmutated) with the ARCANA fields applied
+    last, so they cannot be silently clobbered by an earlier body key. This is
+    the body half of the three-part retrieval invariant; pair it with
+    :func:`arcana_chat_headers` (or set the ``inference-service`` header
+    yourself) for the header half.
+    """
+    return {**body, "enable-tools": True, "arcana": {"id": arcana_id}}
+
+
+def arcana_chat_headers(api_key: str, *, extra: dict | None = None) -> dict:
+    """Build the header set for an ARCANA chat call.
+
+    ``Bearer`` auth + ``Accept: application/json`` + the ``inference-service``
+    gateway header (the header half of the retrieval invariant). ``extra`` is
+    merged last, so a caller can add a correlation id (e.g. ``X-Request-ID``)
+    without losing the required headers.
+    """
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Accept": "application/json",
+        "inference-service": INFERENCE_SERVICE,
+    }
+    if extra:
+        headers.update(extra)
+    return headers

saia_python/aio.py

@@ -0,0 +1,464 @@
+"""Async client for the GWDG SAIA platform — the ``httpx`` twin of the sync API.
+
+Requires the ``[async]`` extra::
+
+    pip install saia-python[async]
+
+Usage mirrors :class:`~saia_python.SAIAClient`, with ``await`` on the network
+calls and ``async for`` over a stream::
+
+    from saia_python.aio import AsyncSAIAClient
+
+    async with AsyncSAIAClient() as client:
+        # non-streaming RAG chat
+        answer = await client.arcana.chat(
+            model="openai-gpt-oss-120b",
+            messages=[{"role": "user", "content": "..."}],
+            arcana_id="owner/kb",
+        )
+        # streaming plain chat
+        stream = await client.chat.completions(
+            model="...", messages=[...], stream=True,
+        )
+        async for chunk in stream:
+            ...
+
+**Scope.** The async layer covers the **data plane** — chat completions and
+ARCANA RAG chat (streaming + non-streaming), the rate-limit
+:class:`~saia_python.RetryPolicy` as a per-call ``retry`` keyword, rate-limit
+surfacing, and an informative 429 error when retry is off — plus the
+lightweight read-only control-plane calls (``models``, arcana
+``version``/``heartbeat``/``list``/``get``, ``health_check``). File
+management (upload / index / sync), voice transcription, and document
+conversion stay **sync-only** on :class:`~saia_python.SAIAClient`: batch/admin
+work with blocking file I/O and no concurrency benefit. See
+``docs/adr/0007-native-async-transport.md``.
+
+The retry semantics are identical to the sync path (same
+:class:`~saia_python.RetryPolicy`, ``_plan``, jitter — imported, not copied), so
+the two transports cannot drift.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from ._async_http import aexecute, apost_chat_completion
+from ._async_streaming import AsyncSSEStream
+from ._http import RetryPolicy, coerce_retry, resolve_retry
+from ._payloads import (
+    apply_arcana_fields,
+    arcana_chat_headers,
+    build_chat_body,
+)
+from .auth import resolve_credentials
+from .exceptions import raise_for_status
+from .rate_limits import RateLimitInfo, parse_rate_limits
+
+if TYPE_CHECKING:
+    import httpx
+
+_ARCANA_PATH = "/arcanas/api/v1"
+
+# Data-plane default: a long read so a legitimately slow RAG/chat answer (which
+# can run for minutes) is not truncated. The read-only control-plane calls pass
+# their own short per-request cap instead. Mirrors the sync split (the chat path
+# is exempt from the control-plane timeout). httpx wants a float/httpx.Timeout,
+# not the requests-style (connect, read) tuple, so these are plain floats.
+_DATA_PLANE_READ_TIMEOUT = 300.0
+_CONTROL_PLANE_TIMEOUT = 60.0
+
+__all__ = [
+    "AsyncSAIAClient",
+    "AsyncChatService",
+    "AsyncArcanaService",
+    "AsyncModelsService",
+    "AsyncSSEStream",
+    "aexecute",
+    "apost_chat_completion",
+]
+
+
+def _require_httpx() -> Any:
+    """Import ``httpx`` or raise a pointed error naming the ``[async]`` extra."""
+    try:
+        import httpx
+    except ImportError as exc:  # pragma: no cover - trivial import guard
+        raise ImportError(
+            "The async client requires the optional 'httpx' dependency. "
+            "Install it with:\n    pip install saia-python[async]"
+        ) from exc
+    return httpx
+
+
+class AsyncChatService:
+    """Async access to ``/chat/completions`` (the twin of :class:`~saia_python.chat.ChatService`)."""
+
+    def __init__(
+        self,
+        client: httpx.AsyncClient,
+        base_url: str,
+        *,
+        retry: RetryPolicy | bool | None = None,
+    ):
+        self._client = client
+        self._base_url = base_url
+        self._retry = coerce_retry(retry)
+
+    async def completions(
+        self,
+        model: str,
+        messages: list[dict],
+        *,
+        temperature: float | None = None,
+        top_p: float | None = None,
+        max_tokens: int | None = None,
+        stream: bool = False,
+        retry: RetryPolicy | bool | None = None,
+        **kwargs: Any,
+    ) -> dict | AsyncSSEStream:
+        """Send a chat completion request. See :meth:`ChatService.completions`.
+
+        With ``stream=False`` returns the response dict (plus a ``_rate_limits``
+        key); with ``stream=True`` returns an :class:`AsyncSSEStream` to iterate.
+        ``retry`` overrides the service policy for this call (``False`` fails
+        fast on a 429 with an informative :class:`~saia_python.RateLimitError`).
+        """
+        body = build_chat_body(
+            model,
+            messages,
+            temperature=temperature,
+            top_p=top_p,
+            max_tokens=max_tokens,
+            **kwargs,
+        )
+        return await apost_chat_completion(
+            self._client,
+            f"{self._base_url}/chat/completions",
+            body,
+            stream=stream,
+            policy=resolve_retry(self._retry, retry),
+        )
+
+    def __repr__(self) -> str:
+        return f"AsyncChatService(base_url={self._base_url!r})"
+
+
+class AsyncArcanaService:
+    """Async access to the ARCANA data plane + read-only control plane.
+
+    Covers RAG :meth:`chat` (the point of the async layer) plus the cheap
+    read-only management calls (:meth:`version`, :meth:`heartbeat`,
+    :meth:`user_info`, :meth:`list`, :meth:`get`). Uploads, indexing, and
+    directory sync stay on the sync :class:`~saia_python.arcana.ArcanaService`.
+    """
+
+    def __init__(
+        self,
+        client: httpx.AsyncClient,
+        base_url: str,
+        api_key: str,
+        *,
+        timeout: float | None = _CONTROL_PLANE_TIMEOUT,
+        retry: RetryPolicy | bool | None = None,
+    ):
+        self._client = client
+        self._base_url = base_url
+        self._arcana_base = f"{base_url}{_ARCANA_PATH}"
+        self._api_key = api_key
+        self._timeout = timeout
+        self._retry = coerce_retry(retry)
+
+    def _headers(self, **extra: str) -> dict:
+        # Control plane uses the raw key (no Bearer prefix), unlike chat().
+        return {"Authorization": self._api_key, "Accept": "application/json", **extra}
+
+    async def chat(
+        self,
+        model: str,
+        messages: list[dict],
+        arcana_id: str,
+        *,
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+        stream: bool = False,
+        retry: RetryPolicy | bool | None = None,
+        api_key: str | None = None,
+        extra_headers: dict | None = None,
+        **kwargs: Any,
+    ) -> dict | AsyncSSEStream:
+        """Chat with RAG context from an arcana (async twin of :meth:`ArcanaService.chat`).
+
+        The three-part ARCANA injection (``enable-tools`` + ``arcana.id`` body
+        fields and the ``inference-service`` header) comes from the shared
+        :func:`~saia_python._payloads.apply_arcana_fields` /
+        :func:`~saia_python._payloads.arcana_chat_headers`, so it matches the
+        sync :meth:`ArcanaService.chat`. One deliberate difference: the injection
+        is applied **last**, so the retrieval fields cannot be disabled by a
+        stray caller key (the sync path lets a ``**kwargs`` override win) — the
+        Rule #6-safe behaviour.
+
+        Args:
+            api_key: Override the instance key for this call — lets one pooled
+                async client serve many users (each request authenticated
+                separately), which a shared multi-user gateway needs.
+            extra_headers: Extra headers merged into the request (e.g. an
+                ``X-Request-ID`` for cross-referencing upstream logs).
+        """
+        body = apply_arcana_fields(
+            build_chat_body(
+                model,
+                messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                **kwargs,
+            ),
+            arcana_id,
+        )
+        headers = arcana_chat_headers(api_key or self._api_key, extra=extra_headers)
+        return await apost_chat_completion(
+            self._client,
+            f"{self._base_url}/chat/completions",
+            body,
+            headers=headers,
+            stream=stream,
+            policy=resolve_retry(self._retry, retry),
+        )
+
+    async def _get_json(
+        self, url: str, *, timeout: Any = None, retry: Any = None
+    ) -> Any:
+        resp = await aexecute(
+            self._client,
+            "get",
+            url,
+            policy=resolve_retry(self._retry, retry),
+            idempotent=True,
+            headers=self._headers(),
+            timeout=timeout if timeout is not None else self._timeout,
+        )
+        raise_for_status(resp)
+        return resp.json()
+
+    async def version(self) -> str:
+        """Return the ARCANA API version string."""
+        data = await self._get_json(f"{self._arcana_base}/version")
+        return data.get("version", "") if isinstance(data, dict) else str(data)
+
+    async def heartbeat(self) -> bool:
+        """Return ``True`` if the ARCANA backend answers 204 (fast, no retry)."""
+        try:
+            resp = await aexecute(
+                self._client,
+                "get",
+                f"{self._arcana_base}/heartbeat",
+                policy=coerce_retry(False),
+                idempotent=True,
+                headers=self._headers(),
+                timeout=10.0,
+            )
+        except Exception:
+            return False
+        return resp.status_code == 204
+
+    async def user_info(self) -> dict:
+        """Return the current user's profile + arcana statistics."""
+        return await self._get_json(f"{self._arcana_base}/user/me")
+
+    async def list(self) -> list[dict]:
+        """List the caller's arcanas."""
+        return await self._get_json(f"{self._arcana_base}/arcana/")
+
+    async def get(self, name: str) -> dict:
+        """Get one arcana by name (accepts ``owner/name`` or ``name``)."""
+        from urllib.parse import quote
+
+        from .arcana import extract_arcana_name
+
+        short = extract_arcana_name(name)
+        return await self._get_json(f"{self._arcana_base}/arcana/{quote(short)}")
+
+    def __repr__(self) -> str:
+        return f"AsyncArcanaService(base_url={self._base_url!r})"
+
+
+class AsyncModelsService:
+    """Async model listing (read-only twin of :class:`~saia_python.models.ModelsService`)."""
+
+    def __init__(
+        self,
+        client: httpx.AsyncClient,
+        base_url: str,
+        *,
+        timeout: float | None = _CONTROL_PLANE_TIMEOUT,
+    ):
+        self._client = client
+        self._base_url = base_url
+        self._timeout = timeout
+
+    async def list_raw(self) -> dict:
+        """Return the raw ``GET /models`` payload."""
+        # Cap the read at the control-plane timeout (not the client-wide
+        # data-plane read, which is long for chat) so a wedged /models probe
+        # fails fast instead of hanging — mirrors the sync ModelsService.
+        resp = await self._client.get(f"{self._base_url}/models", timeout=self._timeout)
+        raise_for_status(resp)
+        return resp.json()
+
+    async def list(self) -> list[dict]:
+        """Return the list of model dicts (unwrapping the ``{"data": [...]}``)."""
+        payload = await self.list_raw()
+        if isinstance(payload, dict) and isinstance(payload.get("data"), list):
+            return payload["data"]
+        return payload if isinstance(payload, list) else []
+
+    async def list_ids(self) -> list[str]:
+        """Return the model id strings, de-duplicated in first-seen order.
+
+        Coalesces the same id keys as the sync :meth:`ModelsService.list_ids`
+        (``id`` / ``modelId`` / ``model_id`` / ``model`` / ``name`` /
+        ``model_name``) so a non-OpenAI-shaped gateway payload still yields ids.
+        """
+        seen: dict[str, None] = {}
+        for model in await self.list():
+            if not isinstance(model, dict):
+                continue
+            mid = (
+                model.get("id")
+                or model.get("modelId")
+                or model.get("model_id")
+                or model.get("model")
+                or model.get("name")
+                or model.get("model_name")
+            )
+            if isinstance(mid, str) and mid:
+                seen.setdefault(mid, None)
+        return list(seen)
+
+    def __repr__(self) -> str:
+        return f"AsyncModelsService(base_url={self._base_url!r})"
+
+
+class AsyncSAIAClient:
+    """Async, connection-pooled client for the SAIA data plane.
+
+    Owns one ``httpx.AsyncClient`` (shared across services for connection
+    pooling). Use it as an async context manager so the pool is closed::
+
+        async with AsyncSAIAClient() as client:
+            await client.chat.completions(model="...", messages=[...])
+
+    Credential + base-URL resolution is identical to
+    :class:`~saia_python.SAIAClient` (delegated to the same
+    :func:`~saia_python.auth.resolve_credentials`).
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        key_file: str | None = None,
+        *,
+        timeout: Any = None,
+        retry: RetryPolicy | bool | None = None,
+    ):
+        httpx = _require_httpx()
+        self._api_key, self._base_url = resolve_credentials(api_key, base_url, key_file)
+        self._retry = coerce_retry(retry)
+        if timeout is None:
+            timeout = httpx.Timeout(
+                connect=10.0, read=_DATA_PLANE_READ_TIMEOUT, write=10.0, pool=10.0
+            )
+        self._client = httpx.AsyncClient(
+            timeout=timeout,
+            headers={
+                "Authorization": f"Bearer {self._api_key}",
+                "Accept": "application/json",
+            },
+        )
+        self._chat: AsyncChatService | None = None
+        self._arcana: AsyncArcanaService | None = None
+        self._models: AsyncModelsService | None = None
+
+    @property
+    def chat(self) -> AsyncChatService:
+        """Async chat completions service."""
+        if self._chat is None:
+            self._chat = AsyncChatService(
+                self._client, self._base_url, retry=self._retry
+            )
+        return self._chat
+
+    @property
+    def arcana(self) -> AsyncArcanaService:
+        """Async ARCANA/RAG service (data plane + read-only control plane)."""
+        if self._arcana is None:
+            self._arcana = AsyncArcanaService(
+                self._client, self._base_url, self._api_key, retry=self._retry
+            )
+        return self._arcana
+
+    @property
+    def models(self) -> AsyncModelsService:
+        """Async model listing service."""
+        if self._models is None:
+            self._models = AsyncModelsService(self._client, self._base_url)
+        return self._models
+
+    async def get_rate_limits(self) -> RateLimitInfo:
+        """Fetch current rate-limit status via a lightweight probe.
+
+        A ``GET /chat/completions`` returns 400 (missing body) but carries the
+        rate-limit headers; a 401/403 is surfaced as
+        :class:`~saia_python.AuthenticationError`.
+        """
+        resp = await self._client.get(f"{self._base_url}/chat/completions")
+        if resp.status_code in (401, 403):
+            raise_for_status(resp)
+        return parse_rate_limits(resp.headers)
+
+    async def arcana_version(self) -> str:
+        """Return the ARCANA API version string."""
+        return await self.arcana.version()
+
+    async def arcana_heartbeat(self) -> bool:
+        """Return ``True`` if the ARCANA backend is reachable (204)."""
+        return await self.arcana.heartbeat()
+
+    async def health_check(self, *, verbose: bool = False) -> bool | dict:
+        """Verify the client can reach + authenticate against the API.
+
+        Combines ``GET /models`` (auth + chat backend) with the ARCANA
+        heartbeat. Returns a bool, or a diagnostic dict with ``verbose=True``.
+        """
+        details: dict = {
+            "base_url": self._base_url,
+            "models_ok": False,
+            "model_count": 0,
+            "arcana_ok": False,
+            "error": None,
+        }
+        try:
+            model_ids = await self.models.list_ids()
+            details["models_ok"] = True
+            details["model_count"] = len(model_ids)
+        except Exception as exc:
+            details["error"] = f"models: {exc}"
+        details["arcana_ok"] = await self.arcana_heartbeat()
+        if not details["arcana_ok"] and details["error"] is None:
+            details["error"] = "arcana heartbeat returned non-204"
+        details["ok"] = details["models_ok"] and details["arcana_ok"]
+        return details if verbose else bool(details["ok"])
+
+    async def aclose(self) -> None:
+        """Close the underlying ``httpx.AsyncClient`` (release the pool)."""
+        await self._client.aclose()
+
+    async def __aenter__(self) -> AsyncSAIAClient:
+        return self
+
+    async def __aexit__(self, *exc: object) -> None:
+        await self.aclose()
+
+    def __repr__(self) -> str:
+        return f"AsyncSAIAClient(base_url={self._base_url!r})"

saia_python/arcana.py

@@ -415,6 +415,49 @@ class ArcanaService:
 
         return _json_or_none(resp)
 
+    def recreate(self, name: str, *, update_toml: bool = False) -> dict:
+        """Delete an arcana and recreate it **empty with the same ID**.
+
+        The minimal-call way to wipe an entire arcana: two requests
+        (:meth:`delete` + :meth:`create`) regardless of how many files it
+        holds, versus one :meth:`delete_file` per file (thousands of calls,
+        each its own read-timeout risk while the arcana is busy). The name —
+        including any UUID suffix — is preserved verbatim via
+        ``create(..., append_uuid=False)``, so a downstream pin on the full
+        ``owner/name-uuid`` ID stays valid.
+
+        Trade-offs versus emptying file-by-file (:meth:`delete_file` in a
+        loop, which keeps the container): there is a brief window between the
+        two calls where the arcana does **not exist**, and the recreated
+        arcana is brand-new — ``created_at``, sharing/permissions and any
+        other container settings reset to defaults. Only the name/ID carries
+        across.
+
+        Args:
+            name: The arcana name or full ``owner/name`` ID to recreate.
+            update_toml: Forwarded to :meth:`create`.
+
+        Returns:
+            The :meth:`create` result (``{"name", "id", "message"}``).
+
+        Raises:
+            APIError: If recreation fails *after* the delete already
+                succeeded — the arcana is then gone. The message says so
+                explicitly so the operator recreates it before any consumer
+                (adapter / manifest pin) points at the ID.
+        """
+        short = extract_arcana_name(name)
+        self.delete(name)
+        try:
+            return self.create(short, append_uuid=False, update_toml=update_toml)
+        except Exception as e:  # noqa: BLE001 — re-raise with a louder message
+            raise APIError(
+                f"arcana {short!r} was DELETED but could not be recreated: {e}. "
+                f"The arcana no longer exists — recreate it (e.g. "
+                f"create({short!r}, append_uuid=False)) before any consumer "
+                f"(adapter / manifest pin) points at its ID."
+            ) from e
+
     def list(self) -> list[dict]:
         """List all available arcanas.
 
@@ -742,6 +785,70 @@ class ArcanaService:
         raise_for_status(resp)
         return _json_or_none(resp)
 
+    def delete_files(
+        self,
+        name: str,
+        file_names: Iterable[str],
+        *,
+        verbose: bool = False,
+        on_result: Callable[[str, dict], None] | None = None,
+    ) -> list[dict]:
+        """Delete an explicit list of files from an arcana, by name.
+
+        The batch counterpart to :meth:`delete_file`: hand it the file names
+        (as returned by :meth:`list_files`) and it deletes each one,
+        capturing a per-file outcome instead of aborting on the first
+        failure. Unlike :meth:`delete_directory` no local directory is
+        consulted — the names come straight from the caller — so it can
+        target files that no longer exist on disk (e.g. a name list from a
+        CSV). Pairs with a thin CLI front-end that resolves *which* names to
+        delete; this method only does the deleting.
+
+        Args:
+            name: The arcana name or full ``owner/name`` ID.
+            file_names: The file names to delete (flat names, as listed by
+                :meth:`list_files`). Order is preserved; a repeated name is
+                attempted each time (a second delete just reports the
+                server's response / 404).
+            verbose: If ``True``, print per-file deletion status.
+            on_result: Optional callback invoked as ``on_result(file_name,
+                entry)`` after each file (``entry`` is that file's
+                ``{"file", "status", ["error"]}`` dict), for inline
+                per-file logging.
+
+        Returns:
+            A list of dicts with keys ``"file"`` (the name), ``"status"``
+            (``"deleted"`` or ``"failed"``), and ``"error"`` (only on
+            failure) — the same shape every batch op returns.
+        """
+        names = [str(n) for n in file_names]
+        # Arcana file names are flat (as listed by :meth:`list_files`). The
+        # batch executor below is Path-centric and targets ``Path(n).name``;
+        # a name containing ``/`` would silently collapse to its basename and
+        # delete the WRONG file. Refuse the whole batch up front — atomic, so
+        # nothing is deleted if any name is malformed (e.g. from a bad CSV).
+        bad = [n for n in names if "/" in n]
+        if bad:
+            raise ValueError(
+                f"ARCANA file names are flat (no '/'); refusing to delete "
+                f"{len(bad)} name(s) containing a path separator: {bad}"
+            )
+        # Reuse the shared batch executor (iteration, per-file error capture,
+        # progress bar, on_result, tally). With flat names ``Path(n).name ==
+        # n``, so the label/delete-target round-trips exactly.
+        return self._run_file_batch(
+            [Path(n) for n in names],
+            lambda fp: self.delete_file(name, fp.name),
+            default_status="deleted",
+            desc="Deleting",
+            verbose=verbose,
+            on_result=(
+                None
+                if on_result is None
+                else lambda fp, entry: on_result(fp.name, entry)
+            ),
+        )
+
     def download_file(self, name: str, file_name: str, output_path: str | Path) -> Path:
         """Download a file from an arcana to a local path.
 

saia_python/exceptions.py

@@ -1,18 +1,43 @@
-"""Custom exceptions and shared HTTP error handling for the SAIA Python wrapper."""
+"""Custom exceptions and shared HTTP error handling for the SAIA Python wrapper.
+
+:func:`raise_for_status` is transport-agnostic: it inspects only ``status_code``,
+``headers``, ``json()`` and ``text`` — the attributes ``requests.Response`` and
+``httpx.Response`` share — so the sync and async paths raise the *same* typed
+errors. Every error now carries ``status_code`` + ``response_body`` (so a gateway
+can reframe the upstream response faithfully), and a 429 carries both the parsed
+``rate_limits`` and an informative message (which window, when it resets, how to
+auto-retry).
+"""
 
 from __future__ import annotations
 
 import json as _json
-from typing import TYPE_CHECKING
-
-from .rate_limits import parse_rate_limits
+from typing import Any
 
-if TYPE_CHECKING:
-    import requests
+from .rate_limits import format_rate_limit_error, parse_rate_limits
 
 
 class SAIAError(Exception):
-    """Base exception for all SAIA API errors."""
+    """Base exception for all SAIA API errors.
+
+    Args:
+        message: Human-readable error message.
+        status_code: The upstream HTTP status, when the error came from a
+            response (``None`` for client-side errors).
+        response_body: The raw upstream body, preserved so a caller can surface
+            exactly what the server sent.
+    """
+
+    def __init__(
+        self,
+        message: object,
+        *,
+        status_code: int | None = None,
+        response_body: str | None = None,
+    ):
+        super().__init__(message)
+        self.status_code = status_code
+        self.response_body = response_body
 
 
 class AuthenticationError(SAIAError):
@@ -20,27 +45,43 @@ class AuthenticationError(SAIAError):
 
 
 class RateLimitError(SAIAError):
-    """Raised on 429 responses — rate limit exceeded."""
+    """Raised on 429 responses — rate limit exceeded.
 
-    def __init__(self, message, rate_limits=None):
-        super().__init__(message)
+    Carries :attr:`rate_limits` (the parsed :class:`~saia_python.RateLimitInfo`)
+    and, when raised by :func:`raise_for_status`, an informative message built
+    by :func:`~saia_python.rate_limits.format_rate_limit_error`.
+    """
+
+    def __init__(
+        self,
+        message: object,
+        rate_limits: object = None,
+        *,
+        status_code: int | None = None,
+        response_body: str | None = None,
+    ):
+        super().__init__(message, status_code=status_code, response_body=response_body)
         self.rate_limits = rate_limits
 
 
 class APIError(SAIAError):
     """Raised on unexpected HTTP errors."""
 
-    def __init__(self, message, status_code=None, response_body=None):
-        super().__init__(message)
-        self.status_code = status_code
-        self.response_body = response_body
+    def __init__(
+        self,
+        message: object,
+        status_code: int | None = None,
+        response_body: str | None = None,
+    ):
+        super().__init__(message, status_code=status_code, response_body=response_body)
 
 
-def _extract_detail(resp: requests.Response) -> str:
+def _extract_detail(resp: Any) -> str:
     """Try to extract a human-readable message from a JSON error body.
 
     The SAIA API typically returns ``{"detail": "..."}`` on errors.
-    Falls back to the raw response text.
+    Falls back to the raw response text. Works with any response exposing
+    ``json()`` / ``text`` (``requests`` or ``httpx``).
     """
     try:
         body = resp.json()
@@ -51,18 +92,33 @@ def _extract_detail(resp: requests.Response) -> str:
     return resp.text
 
 
-def raise_for_status(resp: requests.Response) -> None:
+def raise_for_status(resp: Any) -> None:
     """Raise a typed SAIA exception for HTTP error responses.
 
-    Called by all service modules — this is the single implementation.
+    The single implementation shared by every service, sync and async. Accepts
+    a ``requests.Response`` (which has ``.ok``) or an ``httpx.Response`` (which
+    does not — success is decided from ``status_code`` instead). For a streamed
+    response the body must already be read (``await resp.aread()``) first.
     """
-    if resp.ok:
+    ok = getattr(resp, "ok", None)
+    if ok is None:
+        ok = resp.status_code < 400
+    if ok:
         return
     detail = _extract_detail(resp)
+    body = resp.text
     if resp.status_code in (401, 403):
-        raise AuthenticationError(detail)
+        raise AuthenticationError(
+            detail, status_code=resp.status_code, response_body=body
+        )
     if resp.status_code == 429:
-        raise RateLimitError(detail, rate_limits=parse_rate_limits(resp.headers))
+        info = parse_rate_limits(resp.headers)
+        raise RateLimitError(
+            format_rate_limit_error(info, detail),
+            rate_limits=info,
+            status_code=resp.status_code,
+            response_body=body,
+        )
     # Any other non-2xx/3xx status. The early `return` above already handled
-    # the resp.ok case, so reaching here always means an error response.
-    raise APIError(detail, status_code=resp.status_code, response_body=resp.text)
+    # the success case, so reaching here always means an error response.
+    raise APIError(detail, status_code=resp.status_code, response_body=body)

saia_python/rate_limits.py

@@ -68,7 +68,8 @@ def parse_rate_limits(headers) -> RateLimitInfo:
     """Parse rate-limit info from HTTP response headers.
 
     Args:
-        headers: A dict-like object (e.g. ``requests.Response.headers``).
+        headers: A dict-like object (e.g. ``requests.Response.headers`` or
+            ``httpx.Response.headers``).
 
     Returns:
         RateLimitInfo with populated fields for each header found.
@@ -82,3 +83,37 @@ def parse_rate_limits(headers) -> RateLimitInfo:
             except (ValueError, TypeError):
                 pass
     return RateLimitInfo(**kwargs)
+
+
+def format_rate_limit_error(info: RateLimitInfo, detail: str | None = None) -> str:
+    """Build a human-readable message for a 429 (rate-limit) response.
+
+    Pure — parses nothing, does no I/O — so both the sync and async transports
+    raise the *same* informative :class:`~saia_python.RateLimitError` message
+    when retry is off or the budget is spent, instead of a bare server string.
+    Summarises the remaining per-window quota, the reset hint, and how to make
+    the call wait automatically.
+
+    Args:
+        info: The parsed rate-limit headers from the 429 response.
+        detail: The server's own error detail, appended when present.
+    """
+    parts = ["SAIA rate limit exceeded (HTTP 429)."]
+    windows = []
+    for window in ("minute", "hour", "day", "month"):
+        limit = getattr(info, f"limit_{window}")
+        remaining = getattr(info, f"remaining_{window}")
+        if limit is not None:
+            rem = remaining if remaining is not None else "?"
+            windows.append(f"{window} {rem}/{limit}")
+    if windows:
+        parts.append("Remaining — " + ", ".join(windows) + ".")
+    if info.reset_seconds is not None and info.reset_seconds > 0:
+        parts.append(f"The minute window resets in ~{info.reset_seconds}s.")
+    parts.append(
+        "Pass retry=True (or a RetryPolicy) to wait for the reset and retry "
+        "automatically; retry=False fails fast with this error."
+    )
+    if detail and detail.strip():
+        parts.append(f"Server detail: {detail.strip()}")
+    return " ".join(parts)

{saia_python-0.7.0.dist-info → saia_python-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: saia-python
-Version: 0.7.0
+Version: 0.9.0
 Summary: Python wrapper for the GWDG SAIA platform REST API
 Author: Friedrich Schwarz
 License-Expression: AGPL-3.0-only
@@ -22,6 +22,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Framework :: AsyncIO
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -31,6 +32,8 @@ Requires-Dist: tqdm>=4.60
 Requires-Dist: tomlkit>=0.12
 Provides-Extra: openai
 Requires-Dist: openai>=1.0; extra == "openai"
+Provides-Extra: async
+Requires-Dist: httpx>=0.27; extra == "async"
 Provides-Extra: tokenizer
 Requires-Dist: transformers>=4.40; extra == "tokenizer"
 Requires-Dist: huggingface-hub>=0.20; extra == "tokenizer"
@@ -39,7 +42,7 @@ Requires-Dist: sentencepiece>=0.1.99; extra == "tokenizer"
 Provides-Extra: test
 Requires-Dist: pytest>=7.0; extra == "test"
 Requires-Dist: pytest-cov>=4.0; extra == "test"
-Requires-Dist: saia-python[openai]; extra == "test"
+Requires-Dist: saia-python[async,openai]; extra == "test"
 Provides-Extra: docs
 Requires-Dist: sphinx>=7.0; extra == "docs"
 Requires-Dist: pydata-sphinx-theme>=0.15; extra == "docs"
@@ -113,6 +116,52 @@ list_model_ids()
 chat_completion(model="meta-llama-3.1-8b-instruct", messages=[...])
 ```
 
+### Async
+
+For concurrent workloads (e.g. an ASGI service), install the `[async]` extra and
+use `AsyncSAIAClient` — the `httpx.AsyncClient` twin of the data plane, carrying
+the **same** `RetryPolicy` and rate-limit handling as the sync client (not the
+`openai_async` shim, which bypasses them):
+
+```bash
+pip install saia-python[async]
+```
+
+```python
+import asyncio
+from saia_python.aio import AsyncSAIAClient
+
+
+async def main():
+    async with AsyncSAIAClient() as client:
+        # Non-streaming RAG chat
+        answer = await client.arcana.chat(
+            model="openai-gpt-oss-120b",
+            messages=[{"role": "user", "content": "Summarise the DLBCL first line."}],
+            arcana_id="owner/kb",
+        )
+        print(answer["choices"][0]["message"]["content"])
+
+        # Streaming plain chat — retry=False fails fast with an informative 429
+        stream = await client.chat.completions(
+            model="meta-llama-3.1-8b-instruct",
+            messages=[{"role": "user", "content": "Hello!"}],
+            stream=True,
+            retry=False,
+        )
+        async for chunk in stream:
+            ...
+
+
+asyncio.run(main())
+```
+
+Async covers the data plane (chat, ARCANA RAG chat, streaming) plus the
+read-only control-plane calls (`models`, arcana `version`/`heartbeat`/`list`/
+`get`, `health_check`). File upload/index/sync, voice, and document conversion
+remain synchronous on `SAIAClient` — see
+[ADR-0007](docs/adr/0007-native-async-transport.md).
+
 ## Supported Services
 
 | Service | Description | GWDG Docs |

{saia_python-0.7.0.dist-info → saia_python-0.9.0.dist-info}/RECORD

@@ -1,23 +1,27 @@
-saia_python/__init__.py,sha256=yJ2bHCJ5s3NJWGaXRUCrkhg5SZ_8A7CcGKa3s0bSuCQ,7565
+saia_python/__init__.py,sha256=h7QDujGai4lJ20etSMAxTeq5q5gtMIDAtOH2nqT2tuI,8640
+saia_python/_async_http.py,sha256=kx_1n6984UCuu6tUU_uhcWrLdQk_EZd-L9HLzah0Iis,4687
+saia_python/_async_streaming.py,sha256=hY0u8z_9gbKtBcd2gp1cnWzIWJDCTN1z68SgP186pxg,6448
 saia_python/_http.py,sha256=OW7-3TeTl9efBcdsqL2tmAqeTv_cnUs0j-rfeGCY3Cs,9720
+saia_python/_payloads.py,sha256=YK-oaaswx2_8Ao7Qx5duzowCWCEHVDCVsGQirDTMuFc,3349
 saia_python/_streaming.py,sha256=camkWgoeqBky3b-v4xTC8i4gmADpwpBqtpCVcPCGMvA,3107
 saia_python/_util.py,sha256=1QrgVxAEK6CwJTNK36qLv9GKTs3ySqg4FJKjx_ZEolM,867
-saia_python/arcana.py,sha256=G8_DtNgS6fWXyOHz4h950isuJHXT0lhN4KPBdDuiabc,49243
+saia_python/aio.py,sha256=yu7K1q_UiBmaW-rTfEkP57RVAlx8PwWq37qvtm6gaDs,16858
+saia_python/arcana.py,sha256=gmh4IuC-k5ia5KVQScXQvtD0FhrZj4v8E78C6TRUn5E,54435
 saia_python/arcana_references.py,sha256=wVhbsQdqjtKaiEJu0Lpp26Nbqne7rXgHNE6qKH6cSfA,6818
 saia_python/auth.py,sha256=iKKT7hI3oPtz_rq-wLj-S-_XT7RIGIFgeNrY5nCNNB4,16432
 saia_python/chat.py,sha256=VVqrPbR5UU7nsg7YNCUT5uv5IMRRmwkKvqz72O0W3ZQ,2673
 saia_python/client.py,sha256=P4c41LLfkeutUh4anfcbaEg_nNc3AN_KyHA0hf-YF0E,10520
 saia_python/documents.py,sha256=O8nnqxfXs7Yzq7fYhSm7w1dGTaxBAvoKcvtV9yToDJ8,8680
-saia_python/exceptions.py,sha256=_eY-JSfubWvYkKV7GVbFrdHip7MfwdHwL6In-MbP9X8,2074
+saia_python/exceptions.py,sha256=qb4wXkF2L7qq-qJS3dTTPigTC4F6P-09t0oyGpTpjmc,4252
 saia_python/models.py,sha256=ZGm94FTHY2pcKzU-A3g5g_gGLAYnx4Clq7wCB6NZmqc,5557
 saia_python/openai_compat.py,sha256=RkZp-uKLpOk-UlTMpQpF_E-1_LtiAbUC4IqLWBOjM5k,2349
 saia_python/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-saia_python/rate_limits.py,sha256=ITIF8CQkHpPVT1d_zEiFNXSt6uFQYagp9QE3C1i_m6Q,2841
+saia_python/rate_limits.py,sha256=5UTn9_sOG6dURXwMqs7j3VHHPHg4pGBEUI18ffSDLVo,4435
 saia_python/responses.py,sha256=alemqTlwpeVS3u7W_DG0HG-KCW19ficjpP5Cs6GvqR8,2206
 saia_python/tokenizer.py,sha256=e8GZFi0kfwgGS-9-GL8sNBjGh5MihX57FGiOz5ETbP8,59694
 saia_python/voice.py,sha256=CFZ2TQ8y-eCZ0H1z7P_JKWEORkjRYu1LZriUl4hzPws,7004
-saia_python-0.7.0.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-saia_python-0.7.0.dist-info/METADATA,sha256=ynRkIJAQ1LQbdBe2P-iWda5W6GFKz4Wy48826XG7yUQ,8791
-saia_python-0.7.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-saia_python-0.7.0.dist-info/top_level.txt,sha256=xQzdM-ir7Don4KJtPWWUkyLX9Ry2rai2OrnaWc7GMKw,12
-saia_python-0.7.0.dist-info/RECORD,,
+saia_python-0.9.0.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+saia_python-0.9.0.dist-info/METADATA,sha256=W9d3xWl_icWKPX9LXOjALdz2AGVfZluTUSZqsV-u3uU,10383
+saia_python-0.9.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+saia_python-0.9.0.dist-info/top_level.txt,sha256=xQzdM-ir7Don4KJtPWWUkyLX9Ry2rai2OrnaWc7GMKw,12
+saia_python-0.9.0.dist-info/RECORD,,

{saia_python-0.7.0.dist-info → saia_python-0.9.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (82.0.1)
+Generator: setuptools (83.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any