byok 0.2.0__tar.gz

byok-0.2.0/PKG-INFO

@@ -0,0 +1,169 @@
+Metadata-Version: 2.4
+Name: byok
+Version: 0.2.0
+Summary: BYO - Python SDK for BYOK
+License: FSL-1.1-MIT
+Project-URL: Homepage, https://github.com/treadiehq/byo
+Project-URL: Repository, https://github.com/treadiehq/byo/tree/main/packages/sdk-python
+Project-URL: Issues, https://github.com/treadiehq/byo/issues
+Keywords: byo,byok,openai,anthropic,proxy,api-keys
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.25.0
+
+# BYO PYTHON SDK for BYOK
+
+Official Python SDK for BYO — BYOK (Bring Your Own Key).
+
+## Installation
+
+```bash
+pip install byok
+```
+
+## Quick Start
+
+```python
+import os
+from byo import BYOK
+
+byok = BYOK(api_key=os.environ["BYOK_API_KEY"])
+
+# Proxy an OpenAI request
+openai = byok.openai(ref_id="customer_123")
+response = openai.responses.create(
+    model="gpt-4.1",
+    input="Hello from BYOK!"
+)
+print(response)
+```
+
+## OpenAI
+
+### Responses API
+
+```python
+openai = byok.openai(ref_id="customer_123")
+response = openai.responses.create(model="gpt-4.1", input="What is BYOK?")
+```
+
+### Chat Completions API
+
+```python
+openai = byok.openai(ref_id="customer_123")
+response = openai.chat.completions.create(
+    model="gpt-4.1",
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+```
+
+## Anthropic
+
+### Messages API
+
+```python
+claude = byok.anthropic(ref_id="customer_123")
+response = claude.messages.create(
+    model="claude-sonnet-4-20250514",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+```
+
+## Google AI Studio
+
+### Generate Content
+
+```python
+gemini = byok.google(ref_id="customer_123")
+response = gemini.generate_content.create(
+    model="gemini-2.0-flash",
+    contents=[{"parts": [{"text": "Hello!"}]}]
+)
+```
+
+## Azure OpenAI
+
+### Chat Completions
+
+```python
+azure = byok.azure_openai(ref_id="customer_123")
+response = azure.chat.completions.create(
+    model="gpt-4",
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+```
+
+Azure OpenAI requires `provider_config` when connecting the key:
+
+```python
+byok.keys.connect(
+    provider="azure-openai",
+    ref_id="customer_123",
+    provider_key="your-azure-api-key",
+    provider_config={
+        "baseUrl": "https://your-resource.openai.azure.com",
+        "deploymentName": "gpt-4",
+    },
+)
+```
+
+## AWS Bedrock
+
+### Converse
+
+```python
+bedrock = byok.bedrock(ref_id="customer_123")
+response = bedrock.converse.create(
+    modelId="anthropic.claude-3-haiku-20240307-v1:0",
+    messages=[{"role": "user", "content": [{"text": "Hello!"}]}]
+)
+```
+
+AWS Bedrock requires `provider_config` when connecting the key:
+
+```python
+byok.keys.connect(
+    provider="bedrock",
+    ref_id="customer_123",
+    provider_key="your-aws-secret-access-key",
+    provider_config={
+        "accessKeyId": "AKIA...",
+        "region": "us-east-1",
+    },
+)
+```
+
+## Key Management
+
+```python
+# Connect a provider key
+byok.keys.connect(
+    provider="openai",
+    ref_id="customer_123",
+    provider_key="sk-..."
+)
+
+# Validate a stored key
+result = byok.keys.validate(provider="openai", ref_id="customer_123")
+
+# Revoke a stored key
+byok.keys.revoke(provider="openai", ref_id="customer_123")
+```
+
+## Error Handling
+
+```python
+from byo import BYOK, BYOKError, AuthenticationError
+
+try:
+    response = openai.responses.create(model="gpt-4.1", input="Hello")
+except AuthenticationError:
+    print("Invalid API key")
+except BYOKError as e:
+    print(f"Error {e.status_code}: {e.message}")
+```
+
+## License
+
+[FSL-1.1-MIT](LICENSE)

byok-0.2.0/README.md

@@ -0,0 +1,156 @@
+# BYO PYTHON SDK for BYOK
+
+Official Python SDK for BYO — BYOK (Bring Your Own Key).
+
+## Installation
+
+```bash
+pip install byok
+```
+
+## Quick Start
+
+```python
+import os
+from byo import BYOK
+
+byok = BYOK(api_key=os.environ["BYOK_API_KEY"])
+
+# Proxy an OpenAI request
+openai = byok.openai(ref_id="customer_123")
+response = openai.responses.create(
+    model="gpt-4.1",
+    input="Hello from BYOK!"
+)
+print(response)
+```
+
+## OpenAI
+
+### Responses API
+
+```python
+openai = byok.openai(ref_id="customer_123")
+response = openai.responses.create(model="gpt-4.1", input="What is BYOK?")
+```
+
+### Chat Completions API
+
+```python
+openai = byok.openai(ref_id="customer_123")
+response = openai.chat.completions.create(
+    model="gpt-4.1",
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+```
+
+## Anthropic
+
+### Messages API
+
+```python
+claude = byok.anthropic(ref_id="customer_123")
+response = claude.messages.create(
+    model="claude-sonnet-4-20250514",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+```
+
+## Google AI Studio
+
+### Generate Content
+
+```python
+gemini = byok.google(ref_id="customer_123")
+response = gemini.generate_content.create(
+    model="gemini-2.0-flash",
+    contents=[{"parts": [{"text": "Hello!"}]}]
+)
+```
+
+## Azure OpenAI
+
+### Chat Completions
+
+```python
+azure = byok.azure_openai(ref_id="customer_123")
+response = azure.chat.completions.create(
+    model="gpt-4",
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+```
+
+Azure OpenAI requires `provider_config` when connecting the key:
+
+```python
+byok.keys.connect(
+    provider="azure-openai",
+    ref_id="customer_123",
+    provider_key="your-azure-api-key",
+    provider_config={
+        "baseUrl": "https://your-resource.openai.azure.com",
+        "deploymentName": "gpt-4",
+    },
+)
+```
+
+## AWS Bedrock
+
+### Converse
+
+```python
+bedrock = byok.bedrock(ref_id="customer_123")
+response = bedrock.converse.create(
+    modelId="anthropic.claude-3-haiku-20240307-v1:0",
+    messages=[{"role": "user", "content": [{"text": "Hello!"}]}]
+)
+```
+
+AWS Bedrock requires `provider_config` when connecting the key:
+
+```python
+byok.keys.connect(
+    provider="bedrock",
+    ref_id="customer_123",
+    provider_key="your-aws-secret-access-key",
+    provider_config={
+        "accessKeyId": "AKIA...",
+        "region": "us-east-1",
+    },
+)
+```
+
+## Key Management
+
+```python
+# Connect a provider key
+byok.keys.connect(
+    provider="openai",
+    ref_id="customer_123",
+    provider_key="sk-..."
+)
+
+# Validate a stored key
+result = byok.keys.validate(provider="openai", ref_id="customer_123")
+
+# Revoke a stored key
+byok.keys.revoke(provider="openai", ref_id="customer_123")
+```
+
+## Error Handling
+
+```python
+from byo import BYOK, BYOKError, AuthenticationError
+
+try:
+    response = openai.responses.create(model="gpt-4.1", input="Hello")
+except AuthenticationError:
+    print("Invalid API key")
+except BYOKError as e:
+    print(f"Error {e.status_code}: {e.message}")
+```
+
+## License
+
+[FSL-1.1-MIT](LICENSE)

byok-0.2.0/byo/__init__.py

@@ -0,0 +1,5 @@
+from byo.client import BYOK
+from byo.errors import BYOKError, AuthenticationError, ProviderError
+
+__all__ = ["BYOK", "BYOKError", "AuthenticationError", "ProviderError"]
+__version__ = "0.1.0"

byok-0.2.0/byo/client.py

@@ -0,0 +1,226 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from byo.errors import BYOKError, AuthenticationError, ProviderError
+
+DEFAULT_BASE_URL = "http://localhost:3000"
+
+
+class BYOK:
+    def __init__(self, api_key: str, base_url: str = DEFAULT_BASE_URL):
+        if not api_key:
+            raise AuthenticationError("API key is required")
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._client = httpx.Client(
+            base_url=self._base_url,
+            headers={
+                "Authorization": f"Bearer {self._api_key}",
+                "Content-Type": "application/json",
+            },
+            timeout=60.0,
+        )
+        self.keys = KeysClient(self._client)
+
+    def openai(self, *, ref_id: str) -> OpenAIClient:
+        return OpenAIClient(self._client, ref_id)
+
+    def anthropic(self, *, ref_id: str) -> AnthropicClient:
+        return AnthropicClient(self._client, ref_id)
+
+    def google(self, *, ref_id: str) -> GoogleClient:
+        return GoogleClient(self._client, ref_id)
+
+    def azure_openai(self, *, ref_id: str) -> AzureOpenAIClient:
+        return AzureOpenAIClient(self._client, ref_id)
+
+    def bedrock(self, *, ref_id: str) -> BedrockClient:
+        return BedrockClient(self._client, ref_id)
+
+    def close(self):
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+
+class KeysClient:
+    def __init__(self, client: httpx.Client):
+        self._client = client
+
+    def connect(
+        self,
+        *,
+        provider: str,
+        ref_id: str,
+        provider_key: str,
+        provider_config: dict[str, Any] | None = None,
+    ) -> dict:
+        body: dict[str, Any] = {
+            "provider": provider,
+            "refId": ref_id,
+            "providerKey": provider_key,
+        }
+        if provider_config is not None:
+            body["providerConfig"] = provider_config
+        return _request(self._client, "POST", "/keys/connect", json=body)
+
+    def validate(self, *, provider: str, ref_id: str) -> dict:
+        return _request(self._client, "POST", "/keys/validate", json={
+            "provider": provider,
+            "refId": ref_id,
+        })
+
+    def revoke(self, *, provider: str, ref_id: str) -> dict:
+        return _request(self._client, "DELETE", "/keys/revoke", json={
+            "provider": provider,
+            "refId": ref_id,
+        })
+
+
+class OpenAIClient:
+    def __init__(self, client: httpx.Client, ref_id: str):
+        self.responses = _OpenAIResponses(client, ref_id)
+        self.chat = _OpenAIChat(client, ref_id)
+
+
+class _OpenAIChat:
+    def __init__(self, client: httpx.Client, ref_id: str):
+        self.completions = _OpenAIChatCompletions(client, ref_id)
+
+
+class _OpenAIResponses:
+    def __init__(self, client: httpx.Client, ref_id: str):
+        self._client = client
+        self._ref_id = ref_id
+
+    def create(self, **kwargs) -> dict:
+        resp = _request(self._client, "POST", "/proxy/openai/responses", json={
+            "refId": self._ref_id,
+            "providerPayload": kwargs,
+        })
+        return _extract_proxy_data(resp)
+
+
+class _OpenAIChatCompletions:
+    def __init__(self, client: httpx.Client, ref_id: str):
+        self._client = client
+        self._ref_id = ref_id
+
+    def create(self, **kwargs) -> dict:
+        resp = _request(self._client, "POST", "/proxy/openai/chat/completions", json={
+            "refId": self._ref_id,
+            "providerPayload": kwargs,
+        })
+        return _extract_proxy_data(resp)
+
+
+class AnthropicClient:
+    def __init__(self, client: httpx.Client, ref_id: str):
+        self.messages = _AnthropicMessages(client, ref_id)
+
+
+class _AnthropicMessages:
+    def __init__(self, client: httpx.Client, ref_id: str):
+        self._client = client
+        self._ref_id = ref_id
+
+    def create(self, **kwargs) -> dict:
+        resp = _request(self._client, "POST", "/proxy/anthropic/messages", json={
+            "refId": self._ref_id,
+            "providerPayload": kwargs,
+        })
+        return _extract_proxy_data(resp)
+
+
+class GoogleClient:
+    def __init__(self, client: httpx.Client, ref_id: str):
+        self.generate_content = _GoogleGenerateContent(client, ref_id)
+
+
+class _GoogleGenerateContent:
+    def __init__(self, client: httpx.Client, ref_id: str):
+        self._client = client
+        self._ref_id = ref_id
+
+    def create(self, **kwargs) -> dict:
+        resp = _request(self._client, "POST", "/proxy/google/generateContent", json={
+            "refId": self._ref_id,
+            "providerPayload": kwargs,
+        })
+        return _extract_proxy_data(resp)
+
+
+class AzureOpenAIClient:
+    def __init__(self, client: httpx.Client, ref_id: str):
+        self.chat = _AzureOpenAIChat(client, ref_id)
+
+
+class _AzureOpenAIChat:
+    def __init__(self, client: httpx.Client, ref_id: str):
+        self.completions = _AzureOpenAIChatCompletions(client, ref_id)
+
+
+class _AzureOpenAIChatCompletions:
+    def __init__(self, client: httpx.Client, ref_id: str):
+        self._client = client
+        self._ref_id = ref_id
+
+    def create(self, **kwargs) -> dict:
+        resp = _request(self._client, "POST", "/proxy/azure-openai/chat/completions", json={
+            "refId": self._ref_id,
+            "providerPayload": kwargs,
+        })
+        return _extract_proxy_data(resp)
+
+
+class BedrockClient:
+    def __init__(self, client: httpx.Client, ref_id: str):
+        self.converse = _BedrockConverse(client, ref_id)
+
+
+class _BedrockConverse:
+    def __init__(self, client: httpx.Client, ref_id: str):
+        self._client = client
+        self._ref_id = ref_id
+
+    def create(self, **kwargs) -> dict:
+        resp = _request(self._client, "POST", "/proxy/bedrock/converse", json={
+            "refId": self._ref_id,
+            "providerPayload": kwargs,
+        })
+        return _extract_proxy_data(resp)
+
+
+def _extract_proxy_data(resp: dict) -> dict:
+    if not resp.get("success", True):
+        error_data = resp.get("data", {})
+        if isinstance(error_data, dict):
+            msg = error_data.get("error", error_data)
+            if isinstance(msg, dict):
+                msg = msg.get("message", str(msg))
+        else:
+            msg = str(error_data)
+        raise ProviderError(str(msg), status_code=resp.get("statusCode"))
+    return resp.get("data", resp)
+
+
+def _request(client: httpx.Client, method: str, path: str, **kwargs) -> dict:
+    resp = client.request(method, path, **kwargs)
+    if resp.status_code == 401:
+        raise AuthenticationError()
+    try:
+        data = resp.json()
+    except Exception:
+        text = resp.text[:200] if resp.text else f"Request failed ({resp.status_code})"
+        raise BYOKError(text, status_code=resp.status_code)
+    if not resp.is_success:
+        msg = data.get("message", "Request failed") if isinstance(data, dict) else str(data)
+        raise BYOKError(msg, status_code=resp.status_code)
+    return data

byok-0.2.0/byo/errors.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+
+class BYOKError(Exception):
+    def __init__(self, message: str, status_code: int | None = None, code: str | None = None):
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.code = code
+
+
+class AuthenticationError(BYOKError):
+    def __init__(self, message: str = "Invalid or missing API key"):
+        super().__init__(message, status_code=401, code="AUTHENTICATION_ERROR")
+
+
+class ProviderError(BYOKError):
+    def __init__(self, message: str, status_code: int | None = None):
+        super().__init__(message, status_code=status_code, code="PROVIDER_ERROR")

byok-0.2.0/byok.egg-info/PKG-INFO

@@ -0,0 +1,169 @@
+Metadata-Version: 2.4
+Name: byok
+Version: 0.2.0
+Summary: BYO - Python SDK for BYOK
+License: FSL-1.1-MIT
+Project-URL: Homepage, https://github.com/treadiehq/byo
+Project-URL: Repository, https://github.com/treadiehq/byo/tree/main/packages/sdk-python
+Project-URL: Issues, https://github.com/treadiehq/byo/issues
+Keywords: byo,byok,openai,anthropic,proxy,api-keys
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.25.0
+
+# BYO PYTHON SDK for BYOK
+
+Official Python SDK for BYO — BYOK (Bring Your Own Key).
+
+## Installation
+
+```bash
+pip install byok
+```
+
+## Quick Start
+
+```python
+import os
+from byo import BYOK
+
+byok = BYOK(api_key=os.environ["BYOK_API_KEY"])
+
+# Proxy an OpenAI request
+openai = byok.openai(ref_id="customer_123")
+response = openai.responses.create(
+    model="gpt-4.1",
+    input="Hello from BYOK!"
+)
+print(response)
+```
+
+## OpenAI
+
+### Responses API
+
+```python
+openai = byok.openai(ref_id="customer_123")
+response = openai.responses.create(model="gpt-4.1", input="What is BYOK?")
+```
+
+### Chat Completions API
+
+```python
+openai = byok.openai(ref_id="customer_123")
+response = openai.chat.completions.create(
+    model="gpt-4.1",
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+```
+
+## Anthropic
+
+### Messages API
+
+```python
+claude = byok.anthropic(ref_id="customer_123")
+response = claude.messages.create(
+    model="claude-sonnet-4-20250514",
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+```
+
+## Google AI Studio
+
+### Generate Content
+
+```python
+gemini = byok.google(ref_id="customer_123")
+response = gemini.generate_content.create(
+    model="gemini-2.0-flash",
+    contents=[{"parts": [{"text": "Hello!"}]}]
+)
+```
+
+## Azure OpenAI
+
+### Chat Completions
+
+```python
+azure = byok.azure_openai(ref_id="customer_123")
+response = azure.chat.completions.create(
+    model="gpt-4",
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+```
+
+Azure OpenAI requires `provider_config` when connecting the key:
+
+```python
+byok.keys.connect(
+    provider="azure-openai",
+    ref_id="customer_123",
+    provider_key="your-azure-api-key",
+    provider_config={
+        "baseUrl": "https://your-resource.openai.azure.com",
+        "deploymentName": "gpt-4",
+    },
+)
+```
+
+## AWS Bedrock
+
+### Converse
+
+```python
+bedrock = byok.bedrock(ref_id="customer_123")
+response = bedrock.converse.create(
+    modelId="anthropic.claude-3-haiku-20240307-v1:0",
+    messages=[{"role": "user", "content": [{"text": "Hello!"}]}]
+)
+```
+
+AWS Bedrock requires `provider_config` when connecting the key:
+
+```python
+byok.keys.connect(
+    provider="bedrock",
+    ref_id="customer_123",
+    provider_key="your-aws-secret-access-key",
+    provider_config={
+        "accessKeyId": "AKIA...",
+        "region": "us-east-1",
+    },
+)
+```
+
+## Key Management
+
+```python
+# Connect a provider key
+byok.keys.connect(
+    provider="openai",
+    ref_id="customer_123",
+    provider_key="sk-..."
+)
+
+# Validate a stored key
+result = byok.keys.validate(provider="openai", ref_id="customer_123")
+
+# Revoke a stored key
+byok.keys.revoke(provider="openai", ref_id="customer_123")
+```
+
+## Error Handling
+
+```python
+from byo import BYOK, BYOKError, AuthenticationError
+
+try:
+    response = openai.responses.create(model="gpt-4.1", input="Hello")
+except AuthenticationError:
+    print("Invalid API key")
+except BYOKError as e:
+    print(f"Error {e.status_code}: {e.message}")
+```
+
+## License
+
+[FSL-1.1-MIT](LICENSE)

byok-0.2.0/byok.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+byo/__init__.py
+byo/client.py
+byo/errors.py
+byok.egg-info/PKG-INFO
+byok.egg-info/SOURCES.txt
+byok.egg-info/dependency_links.txt
+byok.egg-info/requires.txt
+byok.egg-info/top_level.txt

byok-0.2.0/byok.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

byok-0.2.0/byok.egg-info/requires.txt

@@ -0,0 +1 @@
+httpx>=0.25.0

byok-0.2.0/byok.egg-info/top_level.txt

@@ -0,0 +1 @@
+byo

byok-0.2.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "byok"
+version = "0.2.0"
+description = "BYO - Python SDK for BYOK"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "FSL-1.1-MIT"}
+dependencies = ["httpx>=0.25.0"]
+keywords = ["byo", "byok", "openai", "anthropic", "proxy", "api-keys"]
+
+[project.urls]
+Homepage = "https://github.com/treadiehq/byo"
+Repository = "https://github.com/treadiehq/byo/tree/main/packages/sdk-python"
+Issues = "https://github.com/treadiehq/byo/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["byo*"]

byok-0.2.0/setup.cfg

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