loopers-client 0.4.0__tar.gz

loopers_client-0.4.0/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: loopers-client
+Version: 0.4.0
+Summary: A premium Python client wrapper for the Loopers AI budget & rate-limit proxy.
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.20.0
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.3.0; extra == "anthropic"
+
+# Loopers Python Client SDK (`loopers-client`)
+
+The `loopers-client` package provides a drop-in wrapper around official OpenAI and Anthropic SDK clients to make integration with the Loopers cost firewall seamless.
+
+## Installation
+
+```bash
+pip install loopers-client
+```
+
+Additionally, install the official provider package you plan to use:
+
+```bash
+pip install openai
+# or
+pip install anthropic
+```
+
+## Features
+
+- **Automatic Headers Injection**: Automatically handles injection of Loopers proxy keys (`Authorization`), upstream provider keys (`X-Loopers-Provider-Key`), and session budget limits.
+- **Custom Attributes**: Intercepts response headers and attaches cost metadata directly to the returned objects.
+
+## Usage
+
+### OpenAI Integration
+
+Replace `openai.OpenAI` with `LoopersOpenAI`:
+
+```python
+from loopers_client import LoopersOpenAI
+
+# Initialize client
+client = LoopersOpenAI(
+    loopers_url="http://localhost:8080",
+    loopers_key="lp-xxx",          # Loopers proxy key
+    provider_key="sk-proj-xxx",    # Upstream OpenAI key
+    session_id="agent-run-123",    # Optional: track steps and budget for an agent session
+    session_budget=2.50,           # Optional: limit session to $2.50
+    max_steps=20                   # Optional: limit session to 20 steps
+)
+
+# Call completions exactly like the official client
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "Hello!"}],
+)
+
+# Inspect budget/cost metadata attached to response
+print(f"Request Cost: ${response.loopers_cost} USD")
+print(f"Estimated Cost: ${response.loopers_cost_estimated} USD")
+print(f"Session Spend: ${response.loopers_session_spend} USD")
+print(f"Session Steps: {response.loopers_session_steps}")
+print(f"Session Remaining: ${response.loopers_session_remaining} USD")
+```
+
+### Async OpenAI
+
+```python
+import asyncio
+from loopers_client import LoopersAsyncOpenAI
+
+async def main():
+    client = LoopersAsyncOpenAI(
+        loopers_url="http://localhost:8080",
+        loopers_key="lp-xxx",
+        provider_key="sk-proj-xxx"
+    )
+    
+    response = await client.chat.completions.create(
+        model="gpt-4o",
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+    print(response.loopers_cost)
+
+asyncio.run(main())
+```
+
+### Anthropic Integration
+
+```python
+from loopers_client import LoopersAnthropic
+
+client = LoopersAnthropic(
+    loopers_url="http://localhost:8080",
+    loopers_key="lp-xxx",
+    provider_key="sk-ant-xxx"
+)
+
+response = client.messages.create(
+    model="claude-3-5-sonnet-latest",
+    max_tokens=1000,
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+
+print(response.loopers_cost)
+```
+
+## License
+
+MIT

loopers_client-0.4.0/README.md

@@ -0,0 +1,101 @@
+# Loopers Python Client SDK (`loopers-client`)
+
+The `loopers-client` package provides a drop-in wrapper around official OpenAI and Anthropic SDK clients to make integration with the Loopers cost firewall seamless.
+
+## Installation
+
+```bash
+pip install loopers-client
+```
+
+Additionally, install the official provider package you plan to use:
+
+```bash
+pip install openai
+# or
+pip install anthropic
+```
+
+## Features
+
+- **Automatic Headers Injection**: Automatically handles injection of Loopers proxy keys (`Authorization`), upstream provider keys (`X-Loopers-Provider-Key`), and session budget limits.
+- **Custom Attributes**: Intercepts response headers and attaches cost metadata directly to the returned objects.
+
+## Usage
+
+### OpenAI Integration
+
+Replace `openai.OpenAI` with `LoopersOpenAI`:
+
+```python
+from loopers_client import LoopersOpenAI
+
+# Initialize client
+client = LoopersOpenAI(
+    loopers_url="http://localhost:8080",
+    loopers_key="lp-xxx",          # Loopers proxy key
+    provider_key="sk-proj-xxx",    # Upstream OpenAI key
+    session_id="agent-run-123",    # Optional: track steps and budget for an agent session
+    session_budget=2.50,           # Optional: limit session to $2.50
+    max_steps=20                   # Optional: limit session to 20 steps
+)
+
+# Call completions exactly like the official client
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "Hello!"}],
+)
+
+# Inspect budget/cost metadata attached to response
+print(f"Request Cost: ${response.loopers_cost} USD")
+print(f"Estimated Cost: ${response.loopers_cost_estimated} USD")
+print(f"Session Spend: ${response.loopers_session_spend} USD")
+print(f"Session Steps: {response.loopers_session_steps}")
+print(f"Session Remaining: ${response.loopers_session_remaining} USD")
+```
+
+### Async OpenAI
+
+```python
+import asyncio
+from loopers_client import LoopersAsyncOpenAI
+
+async def main():
+    client = LoopersAsyncOpenAI(
+        loopers_url="http://localhost:8080",
+        loopers_key="lp-xxx",
+        provider_key="sk-proj-xxx"
+    )
+    
+    response = await client.chat.completions.create(
+        model="gpt-4o",
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+    print(response.loopers_cost)
+
+asyncio.run(main())
+```
+
+### Anthropic Integration
+
+```python
+from loopers_client import LoopersAnthropic
+
+client = LoopersAnthropic(
+    loopers_url="http://localhost:8080",
+    loopers_key="lp-xxx",
+    provider_key="sk-ant-xxx"
+)
+
+response = client.messages.create(
+    model="claude-3-5-sonnet-latest",
+    max_tokens=1000,
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+
+print(response.loopers_cost)
+```
+
+## License
+
+MIT

loopers_client-0.4.0/loopers_client/__init__.py

@@ -0,0 +1,13 @@
+from .client import (
+    LoopersOpenAI,
+    LoopersAsyncOpenAI,
+    LoopersAnthropic,
+    LoopersAsyncAnthropic,
+)
+
+__all__ = [
+    "LoopersOpenAI",
+    "LoopersAsyncOpenAI",
+    "LoopersAnthropic",
+    "LoopersAsyncAnthropic",
+]

loopers_client-0.4.0/loopers_client/client.py

@@ -0,0 +1,294 @@
+import contextvars
+from typing import Optional, Any
+
+import httpx
+
+# Context variable to hold response headers of the last request safely in multithreaded/async contexts
+_last_headers_context = contextvars.ContextVar("last_headers", default={})
+
+def _get_last_headers() -> dict:
+    return _last_headers_context.get()
+
+def _set_last_headers(headers: dict):
+    _last_headers_context.set(headers)
+
+def _response_hook(response: httpx.Response):
+    headers = response.headers
+    loopers_headers = {
+        "cost": headers.get("X-Loopers-Request-Cost"),
+        "cost_estimated": headers.get("X-Loopers-Request-Cost-Estimated"),
+        "session_spend": headers.get("X-Loopers-Session-Spend"),
+        "session_steps": headers.get("X-Loopers-Session-Steps"),
+        "session_remaining": headers.get("X-Loopers-Session-Remaining"),
+    }
+    _set_last_headers(loopers_headers)
+
+async def _async_response_hook(response: httpx.Response):
+    _response_hook(response)
+
+def _attach_loopers_attributes(res: Any):
+    headers = _get_last_headers()
+    if not headers:
+        return
+    
+    # Safely attach Loopers metrics to the returned resource/completion/stream object
+    for name, header_key in [
+        ("loopers_cost", "cost"),
+        ("loopers_cost_estimated", "cost_estimated"),
+        ("loopers_session_spend", "session_spend"),
+        ("loopers_session_remaining", "session_remaining"),
+    ]:
+        val = headers.get(header_key)
+        try:
+            setattr(res, name, float(val) if val else None)
+        except Exception:
+            pass
+
+    steps_val = headers.get("session_steps")
+    try:
+        setattr(res, "loopers_session_steps", int(steps_val) if steps_val else None)
+    except Exception:
+        pass
+
+
+# Try importing openai
+try:
+    import openai
+    HAS_OPENAI = True
+except ImportError:
+    HAS_OPENAI = False
+
+if HAS_OPENAI:
+    class LoopersOpenAI(openai.OpenAI):
+        """
+        A subclass of openai.OpenAI that automatically routes calls through
+        the Loopers budget/rate-limit proxy and parses response metrics.
+        """
+        def __init__(
+            self,
+            loopers_url: str,
+            loopers_key: str,
+            provider_key: Optional[str] = None,
+            session_id: Optional[str] = None,
+            session_budget: Optional[float] = None,
+            max_steps: Optional[int] = None,
+            **kwargs
+        ):
+            # Intercept event hooks to capture Loopers response headers
+            event_hooks = kwargs.pop("event_hooks", {})
+            if "response" not in event_hooks:
+                event_hooks["response"] = []
+            event_hooks["response"].append(_response_hook)
+
+            if "http_client" not in kwargs:
+                kwargs["http_client"] = httpx.Client(event_hooks=event_hooks)
+
+            base_url = f"{loopers_url.rstrip('/')}/openai/v1"
+
+            default_headers = kwargs.pop("default_headers", {})
+            default_headers["Authorization"] = f"Bearer {loopers_key}"
+            if provider_key:
+                default_headers["X-Loopers-Provider-Key"] = provider_key
+            if session_id:
+                default_headers["X-Loopers-Session-ID"] = session_id
+            if session_budget is not None:
+                default_headers["X-Loopers-Session-Budget"] = str(session_budget)
+            if max_steps is not None:
+                default_headers["X-Loopers-Session-Max-Steps"] = str(max_steps)
+
+            super().__init__(
+                base_url=base_url,
+                api_key=loopers_key,
+                default_headers=default_headers,
+                **kwargs
+            )
+
+        def request(self, *args, **kwargs):
+            _set_last_headers({})
+            res = super().request(*args, **kwargs)
+            _attach_loopers_attributes(res)
+            return res
+
+    class LoopersAsyncOpenAI(openai.AsyncOpenAI):
+        """
+        A subclass of openai.AsyncOpenAI that automatically routes calls through
+        the Loopers budget/rate-limit proxy and parses response metrics.
+        """
+        def __init__(
+            self,
+            loopers_url: str,
+            loopers_key: str,
+            provider_key: Optional[str] = None,
+            session_id: Optional[str] = None,
+            session_budget: Optional[float] = None,
+            max_steps: Optional[int] = None,
+            **kwargs
+        ):
+            event_hooks = kwargs.pop("event_hooks", {})
+            if "response" not in event_hooks:
+                event_hooks["response"] = []
+            event_hooks["response"].append(_async_response_hook)
+
+            if "http_client" not in kwargs:
+                kwargs["http_client"] = httpx.AsyncClient(event_hooks=event_hooks)
+
+            base_url = f"{loopers_url.rstrip('/')}/openai/v1"
+
+            default_headers = kwargs.pop("default_headers", {})
+            default_headers["Authorization"] = f"Bearer {loopers_key}"
+            if provider_key:
+                default_headers["X-Loopers-Provider-Key"] = provider_key
+            if session_id:
+                default_headers["X-Loopers-Session-ID"] = session_id
+            if session_budget is not None:
+                default_headers["X-Loopers-Session-Budget"] = str(session_budget)
+            if max_steps is not None:
+                default_headers["X-Loopers-Session-Max-Steps"] = str(max_steps)
+
+            super().__init__(
+                base_url=base_url,
+                api_key=loopers_key,
+                default_headers=default_headers,
+                **kwargs
+            )
+
+        async def request(self, *args, **kwargs):
+            _set_last_headers({})
+            res = await super().request(*args, **kwargs)
+            _attach_loopers_attributes(res)
+            return res
+else:
+    class LoopersOpenAI:
+        def __init__(self, *args, **kwargs):
+            raise ImportError(
+                "The 'openai' package is required to use LoopersOpenAI. "
+                "Install it via 'pip install openai'."
+            )
+
+    class LoopersAsyncOpenAI:
+        def __init__(self, *args, **kwargs):
+            raise ImportError(
+                "The 'openai' package is required to use LoopersAsyncOpenAI. "
+                "Install it via 'pip install openai'."
+            )
+
+
+# Try importing anthropic
+try:
+    import anthropic
+    HAS_ANTHROPIC = True
+except ImportError:
+    HAS_ANTHROPIC = False
+
+if HAS_ANTHROPIC:
+    class LoopersAnthropic(anthropic.Anthropic):
+        """
+        A subclass of anthropic.Anthropic that automatically routes calls through
+        the Loopers budget/rate-limit proxy and parses response metrics.
+        """
+        def __init__(
+            self,
+            loopers_url: str,
+            loopers_key: str,
+            provider_key: Optional[str] = None,
+            session_id: Optional[str] = None,
+            session_budget: Optional[float] = None,
+            max_steps: Optional[int] = None,
+            **kwargs
+        ):
+            event_hooks = kwargs.pop("event_hooks", {})
+            if "response" not in event_hooks:
+                event_hooks["response"] = []
+            event_hooks["response"].append(_response_hook)
+
+            if "http_client" not in kwargs:
+                kwargs["http_client"] = httpx.Client(event_hooks=event_hooks)
+
+            base_url = f"{loopers_url.rstrip('/')}/anthropic"
+
+            default_headers = kwargs.pop("default_headers", {})
+            default_headers["Authorization"] = f"Bearer {loopers_key}"
+            if provider_key:
+                default_headers["X-Loopers-Provider-Key"] = provider_key
+            if session_id:
+                default_headers["X-Loopers-Session-ID"] = session_id
+            if session_budget is not None:
+                default_headers["X-Loopers-Session-Budget"] = str(session_budget)
+            if max_steps is not None:
+                default_headers["X-Loopers-Session-Max-Steps"] = str(max_steps)
+
+            super().__init__(
+                base_url=base_url,
+                auth_token=loopers_key,
+                default_headers=default_headers,
+                **kwargs
+            )
+
+        def request(self, *args, **kwargs):
+            _set_last_headers({})
+            res = super().request(*args, **kwargs)
+            _attach_loopers_attributes(res)
+            return res
+
+    class LoopersAsyncAnthropic(anthropic.AsyncAnthropic):
+        """
+        A subclass of anthropic.AsyncAnthropic that automatically routes calls through
+        the Loopers budget/rate-limit proxy and parses response metrics.
+        """
+        def __init__(
+            self,
+            loopers_url: str,
+            loopers_key: str,
+            provider_key: Optional[str] = None,
+            session_id: Optional[str] = None,
+            session_budget: Optional[float] = None,
+            max_steps: Optional[int] = None,
+            **kwargs
+        ):
+            event_hooks = kwargs.pop("event_hooks", {})
+            if "response" not in event_hooks:
+                event_hooks["response"] = []
+            event_hooks["response"].append(_async_response_hook)
+
+            if "http_client" not in kwargs:
+                kwargs["http_client"] = httpx.AsyncClient(event_hooks=event_hooks)
+
+            base_url = f"{loopers_url.rstrip('/')}/anthropic"
+
+            default_headers = kwargs.pop("default_headers", {})
+            default_headers["Authorization"] = f"Bearer {loopers_key}"
+            if provider_key:
+                default_headers["X-Loopers-Provider-Key"] = provider_key
+            if session_id:
+                default_headers["X-Loopers-Session-ID"] = session_id
+            if session_budget is not None:
+                default_headers["X-Loopers-Session-Budget"] = str(session_budget)
+            if max_steps is not None:
+                default_headers["X-Loopers-Session-Max-Steps"] = str(max_steps)
+
+            super().__init__(
+                base_url=base_url,
+                auth_token=loopers_key,
+                default_headers=default_headers,
+                **kwargs
+            )
+
+        async def request(self, *args, **kwargs):
+            _set_last_headers({})
+            res = await super().request(*args, **kwargs)
+            _attach_loopers_attributes(res)
+            return res
+else:
+    class LoopersAnthropic:
+        def __init__(self, *args, **kwargs):
+            raise ImportError(
+                "The 'anthropic' package is required to use LoopersAnthropic. "
+                "Install it via 'pip install anthropic'."
+            )
+
+    class LoopersAsyncAnthropic:
+        def __init__(self, *args, **kwargs):
+            raise ImportError(
+                "The 'anthropic' package is required to use LoopersAsyncAnthropic. "
+                "Install it via 'pip install anthropic'."
+            )

loopers_client-0.4.0/loopers_client.egg-info/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: loopers-client
+Version: 0.4.0
+Summary: A premium Python client wrapper for the Loopers AI budget & rate-limit proxy.
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.20.0
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == "openai"
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.3.0; extra == "anthropic"
+
+# Loopers Python Client SDK (`loopers-client`)
+
+The `loopers-client` package provides a drop-in wrapper around official OpenAI and Anthropic SDK clients to make integration with the Loopers cost firewall seamless.
+
+## Installation
+
+```bash
+pip install loopers-client
+```
+
+Additionally, install the official provider package you plan to use:
+
+```bash
+pip install openai
+# or
+pip install anthropic
+```
+
+## Features
+
+- **Automatic Headers Injection**: Automatically handles injection of Loopers proxy keys (`Authorization`), upstream provider keys (`X-Loopers-Provider-Key`), and session budget limits.
+- **Custom Attributes**: Intercepts response headers and attaches cost metadata directly to the returned objects.
+
+## Usage
+
+### OpenAI Integration
+
+Replace `openai.OpenAI` with `LoopersOpenAI`:
+
+```python
+from loopers_client import LoopersOpenAI
+
+# Initialize client
+client = LoopersOpenAI(
+    loopers_url="http://localhost:8080",
+    loopers_key="lp-xxx",          # Loopers proxy key
+    provider_key="sk-proj-xxx",    # Upstream OpenAI key
+    session_id="agent-run-123",    # Optional: track steps and budget for an agent session
+    session_budget=2.50,           # Optional: limit session to $2.50
+    max_steps=20                   # Optional: limit session to 20 steps
+)
+
+# Call completions exactly like the official client
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "Hello!"}],
+)
+
+# Inspect budget/cost metadata attached to response
+print(f"Request Cost: ${response.loopers_cost} USD")
+print(f"Estimated Cost: ${response.loopers_cost_estimated} USD")
+print(f"Session Spend: ${response.loopers_session_spend} USD")
+print(f"Session Steps: {response.loopers_session_steps}")
+print(f"Session Remaining: ${response.loopers_session_remaining} USD")
+```
+
+### Async OpenAI
+
+```python
+import asyncio
+from loopers_client import LoopersAsyncOpenAI
+
+async def main():
+    client = LoopersAsyncOpenAI(
+        loopers_url="http://localhost:8080",
+        loopers_key="lp-xxx",
+        provider_key="sk-proj-xxx"
+    )
+    
+    response = await client.chat.completions.create(
+        model="gpt-4o",
+        messages=[{"role": "user", "content": "Hello!"}]
+    )
+    print(response.loopers_cost)
+
+asyncio.run(main())
+```
+
+### Anthropic Integration
+
+```python
+from loopers_client import LoopersAnthropic
+
+client = LoopersAnthropic(
+    loopers_url="http://localhost:8080",
+    loopers_key="lp-xxx",
+    provider_key="sk-ant-xxx"
+)
+
+response = client.messages.create(
+    model="claude-3-5-sonnet-latest",
+    max_tokens=1000,
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+
+print(response.loopers_cost)
+```
+
+## License
+
+MIT

loopers_client-0.4.0/loopers_client.egg-info/SOURCES.txt

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

loopers_client-0.4.0/loopers_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

loopers_client-0.4.0/loopers_client.egg-info/requires.txt

@@ -0,0 +1,7 @@
+httpx>=0.20.0
+
+[anthropic]
+anthropic>=0.3.0
+
+[openai]
+openai>=1.0.0

loopers_client-0.4.0/loopers_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+loopers_client

loopers_client-0.4.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "loopers-client"
+version = "0.4.0"
+description = "A premium Python client wrapper for the Loopers AI budget & rate-limit proxy."
+readme = "README.md"
+requires-python = ">=3.7"
+license = { text = "MIT" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "httpx>=0.20.0",
+]
+
+[project.optional-dependencies]
+openai = ["openai>=1.0.0"]
+anthropic = ["anthropic>=0.3.0"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["loopers_client*"]

loopers_client-0.4.0/setup.cfg

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