tokenspend 0.1.1__tar.gz

tokenspend-0.1.1/.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+*.py[cod]
+dist/
+*.egg-info/

tokenspend-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TokenSpend
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tokenspend-0.1.1/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.5
+Name: tokenspend
+Version: 0.1.1
+Summary: Official Python client for the TokenSpend API
+Project-URL: Documentation, https://tokenspend.dev/docs/router
+Project-URL: Homepage, https://tokenspend.dev
+Project-URL: Repository, https://github.com/haseebc2000/token-spend
+Author: TokenSpend
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,api,llm,tokenspend
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# TokenSpend Python
+
+Official Python client for the TokenSpend API. It has no runtime dependencies.
+
+```bash
+pip install tokenspend
+export TOKENSPEND_API_KEY=tsr_...
+```
+
+```python
+from tokenspend import TokenSpend
+
+client = TokenSpend()
+response = client.chat.completions.create(
+    model="xai/grok-4.5",
+    messages=[{"role": "user", "content": "Hello"}],
+)
+print(response.choices[0].message.content)
+```
+
+Set `stream=True` to iterate over server-sent chunks. `client.messages.create(...)`
+uses the Anthropic-compatible Messages API. See https://tokenspend.dev/docs/router.
+
+Every registry model uses the same method:
+
+```python
+for model in (
+    "xai/grok-4.5",
+    "meta/muse-spark-1.2",
+    "thinking-machines/inkling",
+    "moonshot/kimi-k3",
+):
+    response = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": "Hello"}],
+    )
+```
+
+The SDK never accepts a serving-host selector.

tokenspend-0.1.1/README.md

@@ -0,0 +1,39 @@
+# TokenSpend Python
+
+Official Python client for the TokenSpend API. It has no runtime dependencies.
+
+```bash
+pip install tokenspend
+export TOKENSPEND_API_KEY=tsr_...
+```
+
+```python
+from tokenspend import TokenSpend
+
+client = TokenSpend()
+response = client.chat.completions.create(
+    model="xai/grok-4.5",
+    messages=[{"role": "user", "content": "Hello"}],
+)
+print(response.choices[0].message.content)
+```
+
+Set `stream=True` to iterate over server-sent chunks. `client.messages.create(...)`
+uses the Anthropic-compatible Messages API. See https://tokenspend.dev/docs/router.
+
+Every registry model uses the same method:
+
+```python
+for model in (
+    "xai/grok-4.5",
+    "meta/muse-spark-1.2",
+    "thinking-machines/inkling",
+    "moonshot/kimi-k3",
+):
+    response = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": "Hello"}],
+    )
+```
+
+The SDK never accepts a serving-host selector.

tokenspend-0.1.1/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["hatchling>=1.26"]
+build-backend = "hatchling.build"
+
+[project]
+name = "tokenspend"
+version = "0.1.1"
+description = "Official Python client for the TokenSpend API"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [{ name = "TokenSpend" }]
+keywords = ["ai", "llm", "tokenspend", "api"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+]
+
+[project.urls]
+Documentation = "https://tokenspend.dev/docs/router"
+Homepage = "https://tokenspend.dev"
+Repository = "https://github.com/haseebc2000/token-spend"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/tokenspend"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src/tokenspend", "README.md", "LICENSE", "pyproject.toml"]

tokenspend-0.1.1/src/tokenspend/__init__.py

@@ -0,0 +1,6 @@
+"""Official Python client for TokenSpend."""
+
+from ._client import APIResponse, Stream, TokenSpend, TokenSpendError
+
+__all__ = ["APIResponse", "Stream", "TokenSpend", "TokenSpendError"]
+__version__ = "0.1.1"

tokenspend-0.1.1/src/tokenspend/_client.py

@@ -0,0 +1,152 @@
+"""Dependency-free TokenSpend API client."""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import Iterator, Mapping
+from typing import Any, BinaryIO
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+
+DEFAULT_BASE_URL = "https://api.tokenspend.dev/v1"
+
+
+class TokenSpendError(RuntimeError):
+    """An API or transport error returned by TokenSpend."""
+
+    def __init__(self, message: str, *, status_code: int | None = None, body: Any = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.body = body
+
+
+class APIResponse(dict[str, Any]):
+    """Dictionary response with convenient attribute access."""
+
+    def __getattr__(self, name: str) -> Any:
+        try:
+            return self[name]
+        except KeyError as exc:
+            raise AttributeError(name) from exc
+
+
+def _coerce(value: Any) -> Any:
+    if isinstance(value, dict):
+        return APIResponse({key: _coerce(item) for key, item in value.items()})
+    if isinstance(value, list):
+        return [_coerce(item) for item in value]
+    return value
+
+
+def _decode_json(raw: bytes) -> Any:
+    if not raw:
+        return APIResponse()
+    try:
+        return _coerce(json.loads(raw.decode("utf-8")))
+    except (UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise TokenSpendError("TokenSpend returned an invalid JSON response.") from exc
+
+
+class Stream(Iterator[APIResponse]):
+    """Iterator over server-sent JSON chunks."""
+
+    def __init__(self, response: BinaryIO):
+        self._response = response
+        self._iterator = iter(response)
+
+    def __iter__(self) -> Stream:
+        return self
+
+    def __next__(self) -> APIResponse:
+        for raw_line in self._iterator:
+            line = raw_line.decode("utf-8").strip()
+            if not line.startswith("data:"):
+                continue
+            data = line[5:].strip()
+            if data == "[DONE]":
+                self.close()
+                raise StopIteration
+            if data:
+                return _coerce(json.loads(data))
+        self.close()
+        raise StopIteration
+
+    def close(self) -> None:
+        close = getattr(self._response, "close", None)
+        if close:
+            close()
+
+    def __enter__(self) -> Stream:
+        return self
+
+    def __exit__(self, *_: Any) -> None:
+        self.close()
+
+
+class _Resource:
+    def __init__(self, client: TokenSpend, path: str):
+        self._client = client
+        self._path = path
+
+    def create(self, **params: Any) -> APIResponse | Stream:
+        return self._client._post(self._path, params, stream=bool(params.get("stream")))
+
+
+class _Chat:
+    def __init__(self, client: TokenSpend):
+        self.completions = _Resource(client, "/chat/completions")
+
+
+class TokenSpend:
+    """Client for TokenSpend's OpenAI and Anthropic-compatible endpoints."""
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 120,
+        default_headers: Mapping[str, str] | None = None,
+    ):
+        resolved_key = api_key or os.environ.get("TOKENSPEND_API_KEY") or os.environ.get("TOKENSPEND_RAIL_KEY")
+        if not resolved_key:
+            raise TokenSpendError("Set TOKENSPEND_API_KEY or pass api_key to TokenSpend().")
+        self.api_key = resolved_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.default_headers = dict(default_headers or {})
+        self.chat = _Chat(self)
+        self.messages = _Resource(self, "/messages")
+
+    def _post(self, path: str, payload: Mapping[str, Any], *, stream: bool) -> APIResponse | Stream:
+        headers = {
+            "accept": "text/event-stream" if stream else "application/json",
+            "authorization": f"Bearer {self.api_key}",
+            "content-type": "application/json",
+            "user-agent": "tokenspend-python/0.1.1",
+            **self.default_headers,
+        }
+        request = Request(
+            f"{self.base_url}{path}",
+            data=json.dumps(payload, separators=(",", ":")).encode("utf-8"),
+            headers=headers,
+            method="POST",
+        )
+        try:
+            response = urlopen(request, timeout=self.timeout)
+            if stream:
+                return Stream(response)
+            with response:
+                return _decode_json(response.read())
+        except HTTPError as exc:
+            raw = exc.read()
+            try:
+                body = _decode_json(raw)
+            except TokenSpendError:
+                body = raw.decode("utf-8", errors="replace")
+            message = body.get("error", {}).get("message") if isinstance(body, dict) else None
+            raise TokenSpendError(message or f"TokenSpend request failed with status {exc.code}.", status_code=exc.code, body=body) from exc
+        except URLError as exc:
+            raise TokenSpendError(f"Could not reach TokenSpend: {exc.reason}") from exc