pendra 0.1.0__tar.gz

pendra-0.1.0/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: pendra
+Version: 0.1.0
+Summary: Python SDK for Pendra — UK-based, privacy-first LLM inference
+Author-email: Pendra <hello@pendra.ai>
+License: MIT
+Project-URL: Homepage, https://pendra.ai
+Project-URL: Documentation, https://docs.pendra.ai
+Project-URL: Repository, https://github.com/Pendra-Cloud/pendra
+Keywords: llm,ai,inference,uk,openai-compatible
+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.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24; extra == "dev"
+Requires-Dist: respx>=0.22; extra == "dev"
+
+# pendra-python
+
+Official Python SDK for [Pendra](https://pendra.ai) — UK-based, privacy-first LLM inference.
+
+Your data is processed in the UK, never stored, never shared with US cloud providers.
+
+## Installation
+
+```bash
+pip install pendra
+```
+
+## Quick Start
+
+```python
+import pendra
+
+client = pendra.Pendra(
+    api_key="pdr_sk_...",          # or set PENDRA_API_KEY env var
+    base_url="http://localhost",    # your self-hosted instance
+)
+
+response = client.chat.completions.create(
+    model="llama3.2",
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "What is the capital of the UK?"},
+    ],
+)
+
+print(response.choices[0].message.content)
+# → London is the capital of the United Kingdom.
+```
+
+## Streaming
+
+```python
+with client.chat.completions.create(
+    model="llama3.2",
+    messages=[{"role": "user", "content": "Write me a short poem about London."}],
+    stream=True,
+) as stream:
+    for chunk in stream:
+        print(chunk.choices[0].delta.content or "", end="", flush=True)
+```
+
+## Async
+
+```python
+import asyncio
+import pendra
+
+async def main():
+    async with pendra.AsyncPendra(api_key="pdr_sk_...") as client:
+        # Non-streaming
+        response = await client.chat.completions.create(
+            model="llama3.2",
+            messages=[{"role": "user", "content": "Hello!"}],
+        )
+        print(response.choices[0].message.content)
+
+        # Streaming
+        stream = await client.chat.completions.create(
+            model="llama3.2",
+            messages=[{"role": "user", "content": "Count to 5"}],
+            stream=True,
+        )
+        async for chunk in stream:
+            print(chunk.choices[0].delta.content or "", end="", flush=True)
+
+asyncio.run(main())
+```
+
+## List Models
+
+```python
+models = client.models.list()
+for model in models:
+    print(model.id)
+```
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `PENDRA_API_KEY` | Your Pendra API key (`pdr_sk_...`) |
+
+## OpenAI Compatibility
+
+The Pendra SDK is fully compatible with the OpenAI Python SDK interface. To migrate:
+
+```python
+# Before
+from openai import OpenAI
+client = OpenAI(api_key="sk-...")
+
+# After
+from pendra import Pendra
+client = Pendra(api_key="pdr_sk_...", base_url="https://your-pendra-instance.com")
+```
+
+The `client.chat.completions.create()` interface is identical.
+
+## Self-Hosting
+
+Pendra is fully open source. Run your own instance:
+
+```bash
+git clone https://github.com/pendra-ai/pendra
+cd pendra
+cp .env.example .env
+docker compose up -d
+```
+
+## Licence
+
+MIT

pendra-0.1.0/README.md

@@ -0,0 +1,117 @@
+# pendra-python
+
+Official Python SDK for [Pendra](https://pendra.ai) — UK-based, privacy-first LLM inference.
+
+Your data is processed in the UK, never stored, never shared with US cloud providers.
+
+## Installation
+
+```bash
+pip install pendra
+```
+
+## Quick Start
+
+```python
+import pendra
+
+client = pendra.Pendra(
+    api_key="pdr_sk_...",          # or set PENDRA_API_KEY env var
+    base_url="http://localhost",    # your self-hosted instance
+)
+
+response = client.chat.completions.create(
+    model="llama3.2",
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant."},
+        {"role": "user", "content": "What is the capital of the UK?"},
+    ],
+)
+
+print(response.choices[0].message.content)
+# → London is the capital of the United Kingdom.
+```
+
+## Streaming
+
+```python
+with client.chat.completions.create(
+    model="llama3.2",
+    messages=[{"role": "user", "content": "Write me a short poem about London."}],
+    stream=True,
+) as stream:
+    for chunk in stream:
+        print(chunk.choices[0].delta.content or "", end="", flush=True)
+```
+
+## Async
+
+```python
+import asyncio
+import pendra
+
+async def main():
+    async with pendra.AsyncPendra(api_key="pdr_sk_...") as client:
+        # Non-streaming
+        response = await client.chat.completions.create(
+            model="llama3.2",
+            messages=[{"role": "user", "content": "Hello!"}],
+        )
+        print(response.choices[0].message.content)
+
+        # Streaming
+        stream = await client.chat.completions.create(
+            model="llama3.2",
+            messages=[{"role": "user", "content": "Count to 5"}],
+            stream=True,
+        )
+        async for chunk in stream:
+            print(chunk.choices[0].delta.content or "", end="", flush=True)
+
+asyncio.run(main())
+```
+
+## List Models
+
+```python
+models = client.models.list()
+for model in models:
+    print(model.id)
+```
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `PENDRA_API_KEY` | Your Pendra API key (`pdr_sk_...`) |
+
+## OpenAI Compatibility
+
+The Pendra SDK is fully compatible with the OpenAI Python SDK interface. To migrate:
+
+```python
+# Before
+from openai import OpenAI
+client = OpenAI(api_key="sk-...")
+
+# After
+from pendra import Pendra
+client = Pendra(api_key="pdr_sk_...", base_url="https://your-pendra-instance.com")
+```
+
+The `client.chat.completions.create()` interface is identical.
+
+## Self-Hosting
+
+Pendra is fully open source. Run your own instance:
+
+```bash
+git clone https://github.com/pendra-ai/pendra
+cd pendra
+cp .env.example .env
+docker compose up -d
+```
+
+## Licence
+
+MIT

pendra-0.1.0/pendra/__init__.py

@@ -0,0 +1,22 @@
+"""Pendra Python SDK — UK-based LLM inference, OpenAI-compatible."""
+
+from ._client import AsyncPendra, Pendra
+from ._exceptions import (
+    APIConnectionError,
+    APIError,
+    APIStatusError,
+    AuthenticationError,
+    RateLimitError,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Pendra",
+    "AsyncPendra",
+    "APIError",
+    "APIStatusError",
+    "APIConnectionError",
+    "AuthenticationError",
+    "RateLimitError",
+]

pendra-0.1.0/pendra/_client.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import os
+
+import httpx
+
+from .resources.chat import Chat
+from .resources.models import Models
+
+
+class Pendra:
+    """
+    Synchronous Pendra client.
+
+    Usage::
+
+        import pendra
+
+        client = pendra.Pendra(
+            api_key="pdr_sk_...",
+            base_url="http://localhost",  # or your Pendra instance
+        )
+
+        response = client.chat.completions.create(
+            model="llama3.2",
+            messages=[{"role": "user", "content": "Hello!"}],
+        )
+        print(response.choices[0].message.content)
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        base_url: str = "https://api.pendra.ai",
+        timeout: float = 120.0,
+    ):
+        self.api_key = api_key or os.environ.get("PENDRA_API_KEY")
+        if not self.api_key:
+            raise ValueError(
+                "No API key provided. Pass api_key= or set the "
+                "PENDRA_API_KEY environment variable."
+            )
+
+        self.base_url = base_url.rstrip("/")
+        self._http = httpx.Client(timeout=timeout)
+
+        self.chat = Chat(self)
+        self.models = Models(self)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self._http.close()
+
+    def close(self):
+        self._http.close()
+
+
+class AsyncPendra:
+    """
+    Async Pendra client for use with asyncio.
+
+    Usage::
+
+        import asyncio
+        import pendra
+
+        async def main():
+            async with pendra.AsyncPendra(api_key="pdr_sk_...") as client:
+                response = await client.chat.completions.create(
+                    model="llama3.2",
+                    messages=[{"role": "user", "content": "Hello!"}],
+                )
+                print(response.choices[0].message.content)
+
+        asyncio.run(main())
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        base_url: str = "https://api.pendra.ai",
+        timeout: float = 120.0,
+    ):
+        self.api_key = api_key or os.environ.get("PENDRA_API_KEY")
+        if not self.api_key:
+            raise ValueError(
+                "No API key provided. Pass api_key= or set the "
+                "PENDRA_API_KEY environment variable."
+            )
+
+        self.base_url = base_url.rstrip("/")
+        self._http = httpx.AsyncClient(timeout=timeout)
+
+        # Async resources share the sync interface via separate implementation
+        from .resources.async_chat import AsyncChat
+        from .resources.async_models import AsyncModels
+
+        self.chat = AsyncChat(self)
+        self.models = AsyncModels(self)
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *_):
+        await self._http.aclose()
+
+    async def close(self):
+        await self._http.aclose()

pendra-0.1.0/pendra/_exceptions.py

@@ -0,0 +1,32 @@
+class APIError(Exception):
+    """Base exception for all Pendra API errors."""
+
+    def __init__(self, message: str, status_code: int | None = None):
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+
+
+class APIConnectionError(APIError):
+    """Raised when the API cannot be reached."""
+
+    def __init__(self, message: str = "Failed to connect to the Pendra API"):
+        super().__init__(message)
+
+
+class APIStatusError(APIError):
+    """Raised when the API returns a non-2xx response."""
+
+
+class AuthenticationError(APIStatusError):
+    """Raised on 401 Unauthorized."""
+
+    def __init__(self):
+        super().__init__("Invalid API key — check your PENDRA_API_KEY", status_code=401)
+
+
+class RateLimitError(APIStatusError):
+    """Raised on 429 Too Many Requests."""
+
+    def __init__(self):
+        super().__init__("Rate limit exceeded", status_code=429)

pendra-0.1.0/pendra/_streaming.py

@@ -0,0 +1,38 @@
+import json
+from collections.abc import Iterator
+from typing import TYPE_CHECKING
+
+from .types.chat import ChatCompletionChunk
+
+if TYPE_CHECKING:
+    import httpx
+
+
+class Stream:
+    """Iterates over SSE chunks from a streaming chat completion."""
+
+    def __init__(self, ctx_manager, response: "httpx.Response"):
+        self._ctx = ctx_manager   # keeps the httpx stream context alive
+        self._response = response
+        self._iter = response.iter_lines()
+
+    def __iter__(self) -> Iterator[ChatCompletionChunk]:
+        for line in self._iter:
+            line = line.strip()
+            if not line or not line.startswith("data: "):
+                continue
+            data = line[6:]
+            if data == "[DONE]":
+                break
+            try:
+                chunk = ChatCompletionChunk.from_dict(json.loads(data))
+                yield chunk
+            except (json.JSONDecodeError, KeyError):
+                continue
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self._response.close()
+        self._ctx.__exit__(*args)

pendra-0.1.0/pendra/resources/__init__.py

@@ -0,0 +1,4 @@
+from .chat import Chat
+from .models import Models
+
+__all__ = ["Chat", "Models"]

pendra-0.1.0/pendra/resources/async_chat.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import json
+from collections.abc import AsyncIterator
+from typing import TYPE_CHECKING, Literal, Optional, Union, overload
+
+from .._exceptions import APIConnectionError, APIStatusError, AuthenticationError, RateLimitError
+from .._streaming import Stream
+from ..types.chat import ChatCompletion, ChatCompletionChunk
+
+if TYPE_CHECKING:
+    from .._client import AsyncPendra
+
+
+class AsyncCompletions:
+    def __init__(self, client: "AsyncPendra"):
+        self._client = client
+
+    async def create(
+        self,
+        *,
+        model: str,
+        messages: list[dict],
+        stream: bool = False,
+        temperature: Optional[float] = None,
+        max_tokens: Optional[int] = None,
+        top_p: Optional[float] = None,
+        stop: Optional[Union[str, list[str]]] = None,
+        **kwargs,
+    ) -> Union[ChatCompletion, AsyncIterator[ChatCompletionChunk]]:
+        payload: dict = {"model": model, "messages": messages, "stream": stream}
+        if temperature is not None:
+            payload["temperature"] = temperature
+        if max_tokens is not None:
+            payload["max_tokens"] = max_tokens
+        if top_p is not None:
+            payload["top_p"] = top_p
+        if stop is not None:
+            payload["stop"] = stop
+        payload.update(kwargs)
+
+        url = f"{self._client.base_url}/api/v1/chat/completions"
+        headers = {
+            "Authorization": f"Bearer {self._client.api_key}",
+            "Content-Type": "application/json",
+        }
+
+        if stream:
+            return self._stream(url, payload, headers)
+        else:
+            resp = await self._client._http.post(url, json=payload, headers=headers)
+            self._raise_for_status(resp)
+            return ChatCompletion.from_dict(resp.json())
+
+    async def _stream(
+        self, url: str, payload: dict, headers: dict
+    ) -> AsyncIterator[ChatCompletionChunk]:
+        async with self._client._http.stream("POST", url, json=payload, headers=headers) as resp:
+            self._raise_for_status(resp)
+            async for line in resp.aiter_lines():
+                line = line.strip()
+                if not line or not line.startswith("data: "):
+                    continue
+                data = line[6:]
+                if data == "[DONE]":
+                    break
+                try:
+                    yield ChatCompletionChunk.from_dict(json.loads(data))
+                except (json.JSONDecodeError, KeyError):
+                    continue
+
+    def _raise_for_status(self, response) -> None:
+        if response.status_code == 401:
+            raise AuthenticationError()
+        if response.status_code == 429:
+            raise RateLimitError()
+        if response.status_code >= 400:
+            try:
+                detail = response.json().get("detail", response.text)
+            except Exception:
+                detail = response.text
+            raise APIStatusError(detail, status_code=response.status_code)
+
+
+class AsyncChat:
+    def __init__(self, client: "AsyncPendra"):
+        self.completions = AsyncCompletions(client)

pendra-0.1.0/pendra/resources/async_models.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .models import Model
+
+if TYPE_CHECKING:
+    from .._client import AsyncPendra
+
+
+class AsyncModels:
+    def __init__(self, client: "AsyncPendra"):
+        self._client = client
+
+    async def list(self) -> list[Model]:
+        """List all available models on this Pendra instance."""
+        url = f"{self._client.base_url}/api/v1/models"
+        headers = {"Authorization": f"Bearer {self._client.api_key}"}
+        resp = await self._client._http.get(url, headers=headers)
+        resp.raise_for_status()
+        return [Model.from_dict(m) for m in resp.json().get("data", [])]

pendra-0.1.0/pendra/resources/chat/__init__.py

@@ -0,0 +1,3 @@
+from .chat import Chat
+
+__all__ = ["Chat"]

pendra-0.1.0/pendra/resources/chat/chat.py

@@ -0,0 +1,6 @@
+from .completions import Completions
+
+
+class Chat:
+    def __init__(self, client):
+        self.completions = Completions(client)