saia-python 0.4.1__py3-none-any.whl

saia_python/openai_compat.py

@@ -0,0 +1,70 @@
+"""OpenAI SDK compatibility layer for the SAIA platform.
+
+Provides a factory function that creates an ``openai.OpenAI`` (or
+``openai.AsyncOpenAI``) client pre-configured with SAIA credentials
+and base URL. This enables direct use of the OpenAI Python SDK and
+tools built on it (RAGAS, LangChain, instructor, etc.) against the
+SAIA API.
+"""
+
+from __future__ import annotations
+
+
+def create_openai_client(
+    *,
+    api_key: str | None = None,
+    base_url: str | None = None,
+    key_file: str | None = None,
+    async_client: bool = False,
+):
+    """Create an OpenAI client configured for the SAIA platform.
+
+    Reuses the same credential and base URL resolution as
+    :class:`~saia_python.SAIAClient`: environment variables, ``.env``,
+    ``.saia_api``, and ``config.toml`` are checked automatically when
+    parameters are omitted.
+
+    Args:
+        api_key: Explicit API key. If omitted, resolved via
+            :func:`~saia_python.load_api_key`.
+        base_url: Explicit base URL. If omitted, resolved via
+            :func:`~saia_python.resolve_base_url`.
+        key_file: Path to a ``.saia_api`` or ``.env`` file. Ignored
+            when ``api_key`` is provided.
+        async_client: If ``True``, return an ``openai.AsyncOpenAI``
+            instance instead of ``openai.OpenAI``.
+
+    Returns:
+        An ``openai.OpenAI`` or ``openai.AsyncOpenAI`` instance.
+
+    Example::
+
+        from saia_python import create_openai_client
+
+        client = create_openai_client()
+        response = client.chat.completions.create(
+            model="llama-3.3-70b-instruct",
+            messages=[{"role": "user", "content": "Hello!"}],
+        )
+
+        # Embeddings
+        embedding = client.embeddings.create(
+            model="e5-mistral-7b-instruct",
+            input="Text to embed",
+        )
+    """
+    try:
+        import openai
+    except ImportError as exc:
+        raise ImportError(
+            "The OpenAI compatibility layer requires the optional 'openai' "
+            "dependency. Install it with:\n"
+            "    pip install saia-python[openai]"
+        ) from exc
+
+    from .auth import resolve_credentials
+
+    resolved_key, resolved_url = resolve_credentials(api_key, base_url, key_file)
+
+    cls = openai.AsyncOpenAI if async_client else openai.OpenAI
+    return cls(api_key=resolved_key, base_url=resolved_url)

saia_python/rate_limits.py

@@ -0,0 +1,84 @@
+"""Rate limit header parsing for SAIA API responses."""
+
+from dataclasses import asdict, dataclass
+
+
+@dataclass
+class RateLimitInfo:
+    """Parsed rate-limit information from SAIA API response headers."""
+
+    limit_minute: int | None = None
+    limit_hour: int | None = None
+    limit_day: int | None = None
+    limit_month: int | None = None
+    remaining_minute: int | None = None
+    remaining_hour: int | None = None
+    remaining_day: int | None = None
+    remaining_month: int | None = None
+    reset_seconds: int | None = None
+
+    def to_dict(self) -> dict:
+        """Return a plain, JSON-serializable dict of all rate-limit fields."""
+        return asdict(self)
+
+    def __str__(self):
+        rows = []
+        for window in ("minute", "hour", "day", "month"):
+            limit = getattr(self, f"limit_{window}")
+            remaining = getattr(self, f"remaining_{window}")
+            if limit is not None:
+                rem_str = str(remaining) if remaining is not None else "?"
+                used = str(limit - remaining) if remaining is not None else "?"
+                rows.append((window, rem_str, limit, used))
+
+        if not rows:
+            return "SAIA Rate Limits: (no data)"
+
+        w_rem = max(len(str(r[1])) for r in rows)
+        w_lim = max(len(str(r[2])) for r in rows)
+        w_used = max(len(str(r[3])) for r in rows)
+
+        lines = ["SAIA Rate Limits:"]
+        for window, remaining, limit, used in rows:
+            lines.append(
+                f"  {window:<6}  "
+                f"{remaining:>{w_rem}} / {limit:>{w_lim}}  "
+                f"remaining  "
+                f"({used:>{w_used}} used)"
+            )
+        if self.reset_seconds is not None:
+            lines.append(f"  Resets in {self.reset_seconds}s")
+        return "\n".join(lines)
+
+
+_HEADER_MAP = {
+    "x-ratelimit-limit-minute": "limit_minute",
+    "x-ratelimit-limit-hour": "limit_hour",
+    "x-ratelimit-limit-day": "limit_day",
+    "x-ratelimit-limit-month": "limit_month",
+    "x-ratelimit-remaining-minute": "remaining_minute",
+    "x-ratelimit-remaining-hour": "remaining_hour",
+    "x-ratelimit-remaining-day": "remaining_day",
+    "x-ratelimit-remaining-month": "remaining_month",
+    "ratelimit-reset": "reset_seconds",
+}
+
+
+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``).
+
+    Returns:
+        RateLimitInfo with populated fields for each header found.
+    """
+    kwargs = {}
+    for header_name, field_name in _HEADER_MAP.items():
+        value = headers.get(header_name)
+        if value is not None:
+            try:
+                kwargs[field_name] = int(value)
+            except (ValueError, TypeError):
+                pass
+    return RateLimitInfo(**kwargs)

saia_python/responses.py

@@ -0,0 +1,70 @@
+"""Helpers for extracting fields from OpenAI-style API responses.
+
+The SAIA Chat AI and ARCANA RAG endpoints both return the canonical
+OpenAI ``ChatCompletion`` envelope::
+
+    {
+        "choices": [
+            {"message": {"role": "assistant", "content": "<text>"}, ...}
+        ],
+        ...
+    }
+
+Every caller eventually writes the same lookup chain. The helpers in
+this module make that lookup safe and uniform — empty ``choices`` lists
+and missing ``content`` fields return ``""`` (with a logged warning) so
+downstream string-handling code doesn't have to special-case them.
+"""
+
+from __future__ import annotations
+
+import logging
+
+log = logging.getLogger(__name__)
+
+
+def text_of(response: dict) -> str:
+    """Extract the assistant message content from a chat / RAG response.
+
+    Reaches into ``response["choices"][0]["message"]["content"]`` with
+    full nil-safety: an empty ``choices`` list, a missing ``message``
+    key, or a ``None`` ``content`` field all collapse to ``""`` rather
+    than raising. Both empty-response cases log a warning at this
+    module's logger so silent regressions surface in logs.
+
+    Works for the response shape returned by:
+
+    - :meth:`saia_python.ChatService.completions`
+    - :meth:`saia_python.ArcanaService.chat`
+    - ``client.openai.chat.completions.create(...).model_dump()``
+
+    Args:
+        response: An OpenAI-style ChatCompletion response dict.
+
+    Returns:
+        The first choice's assistant content string, or ``""`` if the
+        response carries no usable content.
+
+    Example::
+
+        resp = client.arcana.chat(
+            model="...", messages=[...], arcana_id="...",
+        )
+        answer = saia_python.text_of(resp)
+    """
+    choices = response.get("choices") or []
+    if not choices:
+        log.warning(
+            "text_of: response has no choices; keys=%s",
+            list(response.keys()),
+        )
+        return ""
+    message = choices[0].get("message") or {}
+    content = message.get("content")
+    if not content:
+        log.warning(
+            "text_of: first choice has empty content; finish_reason=%r",
+            choices[0].get("finish_reason"),
+        )
+        return ""
+    return str(content)

saia_python/voice.py

@@ -0,0 +1,175 @@
+"""Voice AI service — transcription and translation."""
+
+from __future__ import annotations
+
+import concurrent.futures
+import threading
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from ._http import new_session_like
+from .exceptions import raise_for_status
+
+if TYPE_CHECKING:
+    import requests
+
+
+class VoiceService:
+    """Access the ``/audio/transcriptions`` and ``/audio/translations`` endpoints.
+
+    Args:
+        session: A :class:`requests.Session` with auth headers configured.
+        base_url: The SAIA API base URL.
+    """
+
+    def __init__(self, session: requests.Session, base_url: str):
+        self._session = session
+        self._base_url = base_url
+
+    def transcribe(
+        self,
+        file_path: str | Path,
+        *,
+        model: str = "whisper-large-v2",
+        response_format: str = "text",
+        language: str | None = None,
+        wait: bool = True,
+    ) -> str | concurrent.futures.Future[str]:
+        """Transcribe an audio file to text.
+
+        Args:
+            file_path: Path to the audio file (WAV, MP3, MP4, FLAC).
+            model: Whisper model to use.
+            response_format: Output format — ``"text"``, ``"vtt"``, or ``"srt"``.
+            language: Optional language hint (e.g. ``"de"``, ``"en"``).
+            wait: If ``True`` (default), block until the transcription is
+                ready and return it as a string. If ``False``, submit the
+                request on a background thread and return a
+                :class:`concurrent.futures.Future` immediately so the call
+                does not block. Resolve it with ``.result()`` (which
+                re-raises any error), poll with ``.done()``, or attach
+                ``.add_done_callback(...)``.
+
+        Returns:
+            The transcription string when ``wait=True``; otherwise a
+            ``Future`` that resolves to that string.
+
+        Example::
+
+            # Blocking
+            text = client.voice.transcribe("meeting.mp3")
+
+            # Non-blocking — kick it off, do other work, collect later
+            fut = client.voice.transcribe("meeting.mp3", wait=False)
+            ...                       # other work runs while it transcribes
+            text = fut.result()       # blocks only now, re-raises on error
+        """
+        return self._audio_request(
+            "/audio/transcriptions",
+            file_path,
+            model=model,
+            response_format=response_format,
+            language=language,
+            wait=wait,
+        )
+
+    def translate(
+        self,
+        file_path: str | Path,
+        *,
+        model: str = "whisper-large-v2",
+        response_format: str = "text",
+        wait: bool = True,
+    ) -> str | concurrent.futures.Future[str]:
+        """Translate an audio file to English text.
+
+        Args:
+            file_path: Path to the audio file (WAV, MP3, MP4, FLAC).
+            model: Whisper model to use.
+            response_format: Output format — ``"text"``, ``"vtt"``, or ``"srt"``.
+            wait: If ``True`` (default), block until the result is ready and
+                return it as a string. If ``False``, submit on a background
+                thread and return a :class:`concurrent.futures.Future` that
+                resolves to the translation (see :meth:`transcribe`).
+
+        Returns:
+            The English translation string when ``wait=True``; otherwise a
+            ``Future`` that resolves to that string.
+        """
+        return self._audio_request(
+            "/audio/translations",
+            file_path,
+            model=model,
+            response_format=response_format,
+            wait=wait,
+        )
+
+    def _new_session(self) -> requests.Session:
+        """Create a fresh Session mirroring the client's auth headers.
+
+        Backgrounded requests (``wait=False``) use their own Session so they
+        never share the client's Session — and its connection pool — across
+        threads (``requests.Session`` is not guaranteed thread-safe). Thin
+        wrapper around :func:`saia_python._http.new_session_like` so the
+        "fresh authed background Session" idiom has a single implementation.
+        """
+        return new_session_like(self._session)
+
+    def _audio_request(
+        self,
+        endpoint: str,
+        file_path: str | Path,
+        *,
+        model: str,
+        response_format: str,
+        language: str | None = None,
+        wait: bool = True,
+    ) -> str | concurrent.futures.Future[str]:
+        file_path = Path(file_path)
+
+        def _send(session: requests.Session) -> str:
+            data = {"model": model, "response_format": response_format}
+            if language:
+                data["language"] = language
+
+            with open(file_path, "rb") as f:
+                resp = session.post(
+                    f"{self._base_url}{endpoint}",
+                    data=data,
+                    files={"file": (file_path.name, f)},
+                )
+            raise_for_status(resp)
+
+            content_type = resp.headers.get("content-type", "")
+            if "json" in content_type:
+                body = resp.json()
+                if isinstance(body, dict):
+                    return body.get("text", resp.text)
+                return str(body)
+            return resp.text
+
+        if wait:
+            return _send(self._session)
+
+        # Non-blocking: run on a worker thread with its OWN Session and hand
+        # back a Future. The caller resolves it with .result() (which
+        # re-raises any error), polls with .done(), or attaches a callback —
+        # so the result is never lost the way a bare fire-and-forget loses it.
+        future: concurrent.futures.Future[str] = concurrent.futures.Future()
+
+        def _worker() -> None:
+            if not future.set_running_or_notify_cancel():
+                return
+            session = self._new_session()
+            try:
+                future.set_result(_send(session))
+            except BaseException as exc:  # surfaced to the caller via .result()
+                future.set_exception(exc)
+            finally:
+                session.close()
+
+        threading.Thread(target=_worker, daemon=True).start()
+        return future
+
+    def __repr__(self):
+        return f"VoiceService(base_url={self._base_url!r})"

saia_python-0.4.1.dist-info/METADATA

@@ -0,0 +1,190 @@
+Metadata-Version: 2.4
+Name: saia-python
+Version: 0.4.1
+Summary: Python wrapper for the GWDG SAIA platform REST API
+Author: Friedrich Schwarz
+License-Expression: AGPL-3.0-only
+Project-URL: Homepage, https://github.com/fschwar4/saia_python
+Project-URL: Documentation, https://fschwar4.github.io/saia_python/
+Project-URL: Repository, https://github.com/fschwar4/saia_python
+Project-URL: Changelog, https://github.com/fschwar4/saia_python/blob/main/docs/CHANGELOG.md
+Project-URL: Issues, https://github.com/fschwar4/saia_python/issues
+Keywords: GWDG,SAIA,ARCANA,RAG,LLM,OpenAI,academic-cloud,whisper,AI
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+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: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Requires-Dist: tqdm>=4.60
+Requires-Dist: tomlkit>=0.12
+Provides-Extra: openai
+Requires-Dist: openai>=1.0; extra == "openai"
+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"
+Provides-Extra: docs
+Requires-Dist: sphinx>=7.0; extra == "docs"
+Requires-Dist: pydata-sphinx-theme>=0.15; extra == "docs"
+Requires-Dist: sphinx-design; extra == "docs"
+Requires-Dist: sphinx-copybutton; extra == "docs"
+Requires-Dist: myst-parser; extra == "docs"
+Provides-Extra: lint
+Requires-Dist: ruff>=0.6; extra == "lint"
+Requires-Dist: mypy>=1.10; extra == "lint"
+Requires-Dist: types-requests; extra == "lint"
+Provides-Extra: dev
+Requires-Dist: saia-python[docs,lint,test]; extra == "dev"
+Requires-Dist: jupyter; extra == "dev"
+Dynamic: license-file
+
+# saia-python
+
+[![PyPI](https://img.shields.io/pypi/v/saia-python.svg)](https://pypi.org/project/saia-python/)
+[![Python versions](https://img.shields.io/pypi/pyversions/saia-python.svg)](https://pypi.org/project/saia-python/)
+[![License: AGPL-3.0-only](https://img.shields.io/badge/license-AGPL--3.0--only-blue.svg)](https://github.com/fschwar4/saia_python/blob/main/LICENSE)
+[![Tests](https://github.com/fschwar4/saia_python/actions/workflows/tests.yml/badge.svg)](https://github.com/fschwar4/saia_python/actions/workflows/tests.yml)
+[![Docs](https://img.shields.io/badge/docs-online-blue.svg)](https://fschwar4.github.io/saia_python/)
+<!-- After enabling Zenodo (Settings → Integrations → GitHub) and cutting a release,
+     paste the DOI badge Zenodo provides, e.g.:
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.XXXXXXX.svg)](https://doi.org/10.5281/zenodo.XXXXXXX) -->
+
+A Python wrapper for the [GWDG SAIA (Scalable AI Accelerator) platform](https://docs.hpc.gwdg.de/services/ai-services/saia/index.html) REST API.
+
+SAIA provides self-hosted, OpenAI-compatible AI services at GWDG, including chat completions, voice transcription/translation, document conversion, and RAG (ARCANA). This library wraps the REST API so you can use it from Python — both as an object-oriented client and as standalone functions.
+
+## Installation
+
+```bash
+pip install saia-python
+```
+
+Or from source:
+
+```bash
+git clone https://github.com/fschwar4/saia_python.git
+cd saia_python
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from saia_python import SAIAClient
+
+# API key auto-discovered from SAIA_API_KEY env var, .saia_api, or .env file
+client = SAIAClient()
+
+# List available models
+print(client.models.list_ids())
+
+# Chat completion
+response = client.chat.completions(
+    model="meta-llama-3.1-8b-instruct",
+    messages=[{"role": "user", "content": "Hello!"}],
+)
+print(response["choices"][0]["message"]["content"])
+
+# Check your rate limits
+print(client.get_rate_limits())
+```
+
+All services are also available as standalone functions:
+
+```python
+from saia_python import list_model_ids, chat_completion
+
+list_model_ids()
+chat_completion(model="meta-llama-3.1-8b-instruct", messages=[...])
+```
+
+## Supported Services
+
+| Service | Description | GWDG Docs |
+|---------|-------------|-----------|
+| **Chat AI** | Chat completions with streaming and tool calling | [Chat AI](https://docs.hpc.gwdg.de/services/ai-services/chat-ai/index.html) |
+| **Voice AI** | Audio transcription and translation (Whisper) | [Voice AI](https://docs.hpc.gwdg.de/services/ai-services/voice-ai/index.html) |
+| **ARCANA** | RAG — knowledge base management and retrieval-augmented chat | [ARCANA](https://docs.hpc.gwdg.de/services/ai-services/arcana/index.html) |
+| **Documents** | PDF/document conversion via Docling | [SAIA API](https://docs.hpc.gwdg.de/services/ai-services/saia/index.html) |
+| **Models** | List available models, probe tool-calling support | [SAIA API](https://docs.hpc.gwdg.de/services/ai-services/saia/index.html) |
+| **Rate Limits** | Inspect current quota and usage | [SAIA API](https://docs.hpc.gwdg.de/services/ai-services/saia/index.html) |
+
+## Repository Structure
+
+```
+saia-python/
+├── saia_python/                  # Main package
+│   ├── __init__.py               # Public API, version, functional wrappers
+│   ├── client.py                 # SAIAClient — composes all services
+│   ├── chat.py                   # ChatService — completions + streaming
+│   ├── voice.py                  # VoiceService — transcribe + translate
+│   ├── arcana.py                 # ArcanaService — RAG / knowledge bases
+│   ├── models.py                 # ModelsService — list available models
+│   ├── documents.py              # DocumentService — Docling conversion
+│   ├── openai_compat.py          # OpenAI SDK compatibility layer
+│   ├── auth.py                   # Credential and config discovery
+│   ├── rate_limits.py            # RateLimitInfo dataclass + parser
+│   ├── exceptions.py             # SAIAError hierarchy + raise_for_status
+│   ├── _streaming.py             # Shared SSE iterator
+│   └── py.typed                  # PEP 561 typing marker
+├── docs/                         # Sphinx documentation (PyData theme)
+│   ├── conf.py
+│   ├── index.rst
+│   ├── quickstart.rst
+│   ├── explanations.rst
+│   ├── architecture.rst
+│   ├── implementation.rst
+│   ├── configuration.rst
+│   ├── api/                      # API reference (one page per module)
+│   ├── development.rst
+│   ├── dev_notes.rst
+│   ├── testing.rst
+│   ├── roadmap.rst
+│   └── CHANGELOG.md
+├── tests/                        # Unit tests
+├── examples/
+│   ├── saia_python_demo.ipynb         # Interactive demo
+│   ├── openai_compatible_proxy.ipynb  # OpenAI-compatible proxy example
+│   ├── config.toml.example            # Template for structured config
+│   └── .env.example                   # Template for secrets (.env)
+├── .github/workflows/            # CI/CD (tests, docs, PyPI publish)
+├── pyproject.toml                # Package metadata + dependencies
+├── CITATION.cff                  # Citation metadata (CFF 1.2.0)
+├── .gitignore
+└── README.md
+```
+
+## Documentation
+
+Online documentation: <https://fschwar4.github.io/saia_python/>
+
+Build the docs locally:
+
+```bash
+pip install -e ".[docs]"
+sphinx-build -b html -w warnings_sphinx_build.txt docs docs/_build/html
+python3 -m http.server 8000 --directory docs/_build/html
+```
+
+## Citation
+
+If you use `saia-python` in your work, please cite it. Citation metadata lives in
+[`CITATION.cff`](https://github.com/fschwar4/saia_python/blob/main/CITATION.cff); GitHub's "Cite this repository" button renders it
+as APA or BibTeX. A Zenodo DOI will be added here once the first release is
+archived.
+
+## License
+
+[AGPL-3.0-only](https://github.com/fschwar4/saia_python/blob/main/LICENSE)

saia_python-0.4.1.dist-info/RECORD

@@ -0,0 +1,22 @@
+saia_python/__init__.py,sha256=GY3m01r5-kIwKGVQXwGbGAUWXLytDxsYt7c7yY5okyk,6377
+saia_python/_http.py,sha256=6CNcpFP1u5ANzeDMb_QtYSwWe-fHG1no1nCNLSwzLz0,2793
+saia_python/_streaming.py,sha256=e0LhJ-0yzrqC1Lzi_Rn0Xy8mBNGl6u2mAT1rMQGHqHc,2880
+saia_python/_util.py,sha256=1QrgVxAEK6CwJTNK36qLv9GKTs3ySqg4FJKjx_ZEolM,867
+saia_python/arcana.py,sha256=zYXVkTNggLCo_EtTiNm5W1Y8HIupl4CsrBK39EMHzuE,39732
+saia_python/arcana_references.py,sha256=wVhbsQdqjtKaiEJu0Lpp26Nbqne7rXgHNE6qKH6cSfA,6818
+saia_python/auth.py,sha256=iKKT7hI3oPtz_rq-wLj-S-_XT7RIGIFgeNrY5nCNNB4,16432
+saia_python/chat.py,sha256=KsImp7mXCXAmzFtHRoxm8MMmn5X6zl-0_5xl5JYaOeo,2395
+saia_python/client.py,sha256=yqjN1kv-nBQ81YaMNEtU07AbGQl6s-7aVQN-MwSO4wQ,8432
+saia_python/documents.py,sha256=GG3DnfT6a4p5mPjxddqVr5yOAkceAH59j4UIkvTHrIs,4790
+saia_python/exceptions.py,sha256=_eY-JSfubWvYkKV7GVbFrdHip7MfwdHwL6In-MbP9X8,2074
+saia_python/models.py,sha256=XrMJ_ROs9k2SGAMg_goNpRh4CCpd0KrZP_7qOkNQtIs,4925
+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/responses.py,sha256=alemqTlwpeVS3u7W_DG0HG-KCW19ficjpP5Cs6GvqR8,2206
+saia_python/voice.py,sha256=hI365P1CLW3R2fwZrK2IHnr5bL4nXU570wfQ9Xd4fRQ,6313
+saia_python-0.4.1.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+saia_python-0.4.1.dist-info/METADATA,sha256=t7dasMAaMqJxWTLraOBzjjxt4jo_R6tfSfEpYgSvIlU,8338
+saia_python-0.4.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+saia_python-0.4.1.dist-info/top_level.txt,sha256=xQzdM-ir7Don4KJtPWWUkyLX9Ry2rai2OrnaWc7GMKw,12
+saia_python-0.4.1.dist-info/RECORD,,

saia_python-0.4.1.dist-info/WHEEL

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