sovergate 0.1.0a1__py3-none-any.whl

sovergate/__init__.py

@@ -0,0 +1,4 @@
+from .client import init, instrument, shutdown
+
+__all__ = ["init", "instrument", "shutdown"]
+__version__ = "0.1.0a1"

sovergate/client.py

@@ -0,0 +1,138 @@
+"""Public entry point — init() and instrument()."""
+
+import logging
+from typing import Any, Optional
+
+from .sender import send
+from .queue import LogQueue
+
+logger = logging.getLogger("sovergate")
+
+_state: dict = {
+    "api_key": None,
+    "base_url": "https://api.sovergate.com",
+    "pii_key": None,
+    "queue": None,
+}
+
+
+def init(
+    api_key: str,
+    base_url: str = "https://api.sovergate.com",
+    pii_key: Optional[str] = None,
+    debug: bool = False,
+) -> None:
+    """
+    Call once at app startup before any LLM calls.
+
+    Args:
+        api_key:  Your sovergate SDK key (starts with sov_).
+        base_url: Override API endpoint (useful for self-hosted or local dev).
+        pii_key:  Secret used to derive deterministic, irreversible PII tokens.
+                  The same value always maps to the same token, so the platform
+                  can count unique entities without ever holding raw PII. Keep it
+                  secret and stable — it NEVER leaves your infrastructure. If
+                  omitted, tokens are positional and not correlatable across logs.
+        debug:    Enable verbose logging from the SDK.
+    """
+    try:
+        if debug:
+            _enable_debug_logging()
+
+        _state["api_key"] = api_key
+        _state["base_url"] = base_url.rstrip("/")
+        _state["pii_key"] = pii_key.encode("utf-8") if pii_key else None
+        if _state["pii_key"] is None:
+            logger.debug(
+                "sovergate: no pii_key set — PII tokens will be positional and not "
+                "correlatable across logs (unique-entity metrics unavailable)."
+            )
+
+        def _send(payload: dict) -> bool:
+            return send(api_key, payload, base_url=_state["base_url"])
+
+        q = LogQueue(send_fn=_send)
+        q.start()
+        _state["queue"] = q
+
+        logger.debug("sovergate initialised (base_url=%s)", _state["base_url"])
+    except Exception as e:
+        # Never let SDK setup break the host app; logging just stays disabled.
+        _state["queue"] = None
+        logger.warning("sovergate: init failed, logging disabled: %s", e)
+
+
+def _enable_debug_logging() -> None:
+    """Verbose output for the SDK's own loggers only — never the app's root logger."""
+    logger.setLevel(logging.DEBUG)
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        handler.setFormatter(logging.Formatter("%(name)s %(levelname)s %(message)s"))
+        logger.addHandler(handler)
+
+
+def instrument(library: Any) -> None:
+    """
+    Patch an LLM client library so all calls are automatically logged.
+
+    Supported:
+        - the openai module, or an OpenAI / AsyncOpenAI client   (chat.completions.create)
+        - an Anthropic / AsyncAnthropic client                     (messages.create)
+
+    Usage:
+        import openai
+        sovergate.instrument(openai)
+
+        import anthropic
+        client = anthropic.Anthropic()
+        sovergate.instrument(client)
+
+    The original library and its responses are completely unchanged.
+    Never raises: if instrumentation isn't possible, a warning is logged and
+    the library is left untouched.
+    """
+    if _state["queue"] is None:
+        logger.warning(
+            "sovergate: instrument() called before init(api_key=...) — LLM calls will not be logged."
+        )
+        return
+
+    try:
+        enqueue = _state["queue"].enqueue
+        pii_key = _state["pii_key"]
+        module_name = getattr(library, "__name__", "") or getattr(library, "__class__", type(library)).__name__
+
+        if module_name == "openai" or hasattr(library, "chat"):
+            from .patcher import patch_openai
+            patch_openai(library, enqueue, pii_key)
+            return
+
+        if module_name == "anthropic" and not hasattr(library, "messages"):
+            logger.warning(
+                "sovergate: pass an Anthropic client instance, not the anthropic module — "
+                "e.g. sovergate.instrument(anthropic.Anthropic()). LLM calls will not be logged."
+            )
+            return
+
+        if hasattr(library, "messages"):
+            from .patcher import patch_anthropic
+            patch_anthropic(library, enqueue, pii_key)
+            return
+
+        logger.warning(
+            "sovergate: unsupported library '%s' — LLM calls will not be logged. "
+            "Supported: openai, anthropic. Open an issue at "
+            "https://github.com/sovergate/sdk-python/issues",
+            module_name,
+        )
+    except Exception as e:
+        logger.warning("sovergate: instrument() failed, LLM calls will not be logged: %s", e)
+
+
+def shutdown() -> None:
+    """Stop the background sender thread. Records still queued at that point are discarded."""
+    try:
+        if _state["queue"]:
+            _state["queue"].stop()
+    except Exception as e:
+        logger.debug("sovergate: shutdown error: %s", e)

sovergate/patcher.py

@@ -0,0 +1,141 @@
+"""Patches OpenAI / Anthropic clients so completed calls are logged after the fact."""
+
+import inspect
+import logging
+import threading
+import time
+from datetime import datetime, timezone
+from typing import Any, Callable, Optional
+
+from .scrubber import scrub, scrub_messages
+
+logger = logging.getLogger("sovergate.patcher")
+
+_PATCHED = "__sovergate_patched__"
+
+Enqueue = Callable[[dict], None]
+BuildPayload = Callable[[dict, Any, str, int], dict]
+
+
+def _utcnow() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _log_in_background(build: BuildPayload, enqueue: Enqueue, kwargs: dict, response: Any,
+                       request_at: str, latency_ms: int) -> None:
+    def run() -> None:
+        try:
+            enqueue(build(kwargs, response, request_at, latency_ms))
+        except Exception as e:
+            logger.debug("sovergate background log error: %s", e)
+
+    try:
+        threading.Thread(target=run, daemon=True, name="sovergate-log").start()
+    except Exception as e:
+        logger.debug("sovergate could not start log thread: %s", e)
+
+
+def _wrap(target: Any, build: BuildPayload, enqueue: Enqueue) -> None:
+    """
+    Replace target.create with a wrapper that returns the original result unchanged
+    and logs a scrubbed copy in a daemon thread. Works for sync and async clients:
+    async SDK methods are sync wrappers returning a coroutine, so awaitability is
+    checked on the result rather than on the function.
+    """
+    original = target.create
+    if getattr(original, _PATCHED, False):
+        return
+
+    def patched_create(*args: Any, **kwargs: Any) -> Any:
+        request_at = _utcnow()
+        t0 = time.monotonic()
+
+        result = original(*args, **kwargs)
+
+        # Streams can only be consumed once and belong to the app; not logged yet.
+        if kwargs.get("stream") is True:
+            return result
+
+        def log(response: Any) -> None:
+            latency_ms = int((time.monotonic() - t0) * 1000)
+            _log_in_background(build, enqueue, kwargs, response, request_at, latency_ms)
+
+        if inspect.isawaitable(result):
+            async def await_and_log() -> Any:
+                response = await result
+                log(response)
+                return response
+
+            return await_and_log()
+
+        log(result)
+        return result  # returned immediately — logging happens in the background
+
+    setattr(patched_create, _PATCHED, True)
+    patched_create.__wrapped__ = original  # type: ignore[attr-defined]
+    target.create = patched_create
+
+
+def patch_openai(openai_module: Any, enqueue: Enqueue, pii_key: Optional[bytes] = None) -> None:
+    """Wraps chat.completions.create on the openai module or an OpenAI / AsyncOpenAI client."""
+
+    def build(kwargs: dict, response: Any, request_at: str, latency_ms: int) -> dict:
+        scrubbed_messages, detections = scrub_messages(kwargs.get("messages", []), pii_key)
+
+        choice = response.choices[0] if response.choices else None
+        response_text = choice.message.content if choice else ""
+        scrubbed_response = scrub(response_text, pii_key).text if response_text else ""
+
+        usage = response.usage
+        return {
+            "model": response.model or kwargs.get("model", ""),
+            "messages": scrubbed_messages,
+            "response": scrubbed_response,
+            "prompt_tokens": usage.prompt_tokens if usage else 0,
+            "completion_tokens": usage.completion_tokens if usage else 0,
+            "latency_ms": latency_ms,
+            "timestamp": request_at,
+            "finish_reason": choice.finish_reason if choice else None,
+            "pii_detections": [
+                {"category": d.category, "placeholder": d.placeholder} for d in detections
+            ],
+        }
+
+    _wrap(openai_module.chat.completions, build, enqueue)
+    logger.debug("sovergate: patched chat.completions.create")
+
+
+def patch_anthropic(anthropic_client: Any, enqueue: Enqueue, pii_key: Optional[bytes] = None) -> None:
+    """Wraps messages.create on an Anthropic / AsyncAnthropic client."""
+
+    def build(kwargs: dict, response: Any, request_at: str, latency_ms: int) -> dict:
+        all_messages = []
+        system = kwargs.get("system")
+        if system:
+            all_messages.append({"role": "system", "content": system})
+        all_messages.extend(kwargs.get("messages", []))
+
+        scrubbed_messages, detections = scrub_messages(all_messages, pii_key)
+
+        response_text = "".join(
+            block.text for block in (response.content or []) if getattr(block, "type", None) == "text"
+        )
+        scrubbed_response = scrub(response_text, pii_key).text if response_text else ""
+
+        usage = response.usage
+        return {
+            "model": response.model or kwargs.get("model", ""),
+            "messages": scrubbed_messages,
+            "response": scrubbed_response,
+            "prompt_tokens": usage.input_tokens if usage else 0,
+            "completion_tokens": usage.output_tokens if usage else 0,
+            "latency_ms": latency_ms,
+            "timestamp": request_at,
+            "finish_reason": response.stop_reason,
+            "pii_detections": [
+                {"category": d.category, "placeholder": d.placeholder} for d in detections
+            ],
+        }
+
+    _wrap(anthropic_client.messages, build, enqueue)
+    logger.debug("sovergate: patched messages.create")

sovergate/queue.py

@@ -0,0 +1,68 @@
+"""Local queue with retry/backoff — survives transient API outages without blocking the app."""
+
+import threading
+import time
+import logging
+from collections import deque
+from typing import Any, Callable
+
+logger = logging.getLogger("sovergate.queue")
+
+_MAX_QUEUE = 10_000
+_RETRY_DELAYS = [1, 2, 4, 8, 16, 30, 60]  # seconds between retries
+
+
+class LogQueue:
+    def __init__(self, send_fn: Callable[[dict[str, Any]], bool]) -> None:
+        self._send = send_fn
+        self._queue: deque[dict[str, Any]] = deque(maxlen=_MAX_QUEUE)
+        self._lock = threading.Lock()
+        self._event = threading.Event()
+        self._running = False
+        self._thread: threading.Thread | None = None
+
+    def start(self) -> None:
+        self._running = True
+        self._thread = threading.Thread(target=self._worker, daemon=True, name="sovergate-queue")
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._running = False
+        self._event.set()
+
+    def enqueue(self, payload: dict[str, Any]) -> None:
+        with self._lock:
+            self._queue.append(payload)
+        self._event.set()
+
+    def _worker(self) -> None:
+        retry_index = 0
+        while self._running:
+            with self._lock:
+                has_item = bool(self._queue)
+
+            if not has_item:
+                # Nothing to send — block until something is enqueued or stop() is called
+                self._event.wait()
+                self._event.clear()
+                continue
+
+            with self._lock:
+                payload = self._queue[0]
+
+            success = False
+            try:
+                success = self._send(payload)
+            except Exception as e:
+                logger.debug("sovergate queue send error: %s", e)
+
+            if success:
+                with self._lock:
+                    self._queue.popleft()
+                retry_index = 0
+            else:
+                delay = _RETRY_DELAYS[min(retry_index, len(_RETRY_DELAYS) - 1)]
+                retry_index += 1
+                logger.debug("sovergate retrying in %ds", delay)
+                time.sleep(delay)
+                # loop continues — item stays in queue, we try again

sovergate/scrubber.py

@@ -0,0 +1,115 @@
+"""PII detection and scrubbing — runs locally, before any data leaves the customer's infra."""
+
+import re
+import hmac
+import hashlib
+from dataclasses import dataclass
+from typing import Optional
+
+# Hex chars of the HMAC digest shown in a token. 12 hex = 48 bits — enough to
+# keep entity collisions negligible at realistic volumes while staying readable.
+_TOKEN_HEX_LEN = 12
+
+
+def _normalize(value: str) -> str:
+    """Fold trivial formatting differences so the same logical value (e.g. a
+    spaced vs. unspaced IBAN, or differently-cased email) yields one token."""
+    return re.sub(r"[\s\-]", "", value).lower()
+
+
+def _hmac_token(key: bytes, base_placeholder: str, value: str) -> str:
+    digest = hmac.new(key, _normalize(value).encode("utf-8"), hashlib.sha256).hexdigest()
+    return f"[{base_placeholder}_{digest[:_TOKEN_HEX_LEN]}]"
+
+# Each rule: (category, compiled regex, placeholder template)
+_RULES: list[tuple[str, re.Pattern, str]] = [
+    ("email",     re.compile(r'\b[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}\b'), "EMAIL_REDACTED"),
+    # IP before phone — phone regex would otherwise swallow dotted quads
+    ("ip",        re.compile(r'\b(?:\d{1,3}\.){3}\d{1,3}\b'), "IP_REDACTED"),
+    # IBAN: tolerate the conventional 4-char grouping (e.g. "DE89 3704 0044 ...")
+    # so a spaced IBAN can't leak its country/check digits to the phone rule.
+    ("iban",      re.compile(r'\b[A-Z]{2}\d{2}(?:[ ]?[A-Z0-9]){11,30}\b'), "IBAN_REDACTED"),
+    # Credit card before phone — captures the FULL grouped PAN (13–20 digits in
+    # groups of 4) so the phone rule's length cap can't leave a trailing group.
+    # Emitted as id_number until a first-class credit_card category exists in the
+    # ingest DTO + DB CHECK constraint. See follow-up.
+    ("id_number", re.compile(r'\b\d{4}(?:[ -]?\d{4}){2,4}\b'), "CARD_REDACTED"),
+    # Phone: require at least 7 digits (not just any digit-like chars)
+    ("phone",     re.compile(r'\b(?:\+?\d[\d\s\-().]{5,14}\d)\b'), "PHONE_REDACTED"),
+    ("dob",       re.compile(r'\b(?:\d{1,2}[\/\-\.]\d{1,2}[\/\-\.]\d{2,4}|\d{4}[\/\-\.]\d{1,2}[\/\-\.]\d{1,2})\b'), "DOB_REDACTED"),
+    ("id_number", re.compile(r'\b[A-Z]{1,3}\d{6,9}\b'), "ID_REDACTED"),
+    # Names last — broad heuristic, apply only inside common name patterns
+    ("name",      re.compile(r'\b(?:Mr|Mrs|Ms|Dr|Prof)\.?\s+[A-Z][a-z]+(?: [A-Z][a-z]+)*\b'), "NAME_REDACTED"),
+]
+
+
+@dataclass
+class Detection:
+    category: str
+    placeholder: str
+
+
+@dataclass
+class ScrubResult:
+    text: str
+    detections: list[Detection]
+
+
+def scrub(text: str, key: Optional[bytes] = None) -> ScrubResult:
+    """Replace PII in text with placeholders. Returns scrubbed text + detection list.
+
+    If ``key`` is given, each value is replaced with a deterministic, irreversible
+    HMAC token — the same value yields the same token across every log, which lets
+    the platform count unique entities without ever holding the raw PII. The key
+    is the customer's secret and is never sent to our servers. Without a key, we
+    fall back to per-text positional numbering (tokens are not correlatable).
+    """
+    if not text:
+        return ScrubResult(text=text, detections=[])
+
+    detections: list[Detection] = []
+    counters: dict[str, int] = {}
+
+    for category, pattern, base_placeholder in _RULES:
+        def replace(m: re.Match, cat: str = category, ph: str = base_placeholder) -> str:
+            if key is not None:
+                placeholder = _hmac_token(key, ph, m.group(0))
+            else:
+                counters[cat] = counters.get(cat, 0) + 1
+                placeholder = f"[{ph}_{counters[cat]}]"
+            detections.append(Detection(category=cat, placeholder=placeholder))
+            return placeholder
+
+        text = pattern.sub(replace, text)
+
+    return ScrubResult(text=text, detections=detections)
+
+
+def scrub_messages(
+    messages: list[dict], key: Optional[bytes] = None
+) -> tuple[list[dict], list[Detection]]:
+    """Scrub a list of OpenAI-style message dicts. Returns scrubbed messages + all detections."""
+    all_detections: list[Detection] = []
+    scrubbed: list[dict] = []
+
+    for msg in messages:
+        content = msg.get("content", "")
+        if isinstance(content, str):
+            result = scrub(content, key)
+            scrubbed.append({**msg, "content": result.text})
+            all_detections.extend(result.detections)
+        elif isinstance(content, list):
+            # multi-modal content blocks
+            new_blocks = []
+            for block in content:
+                if block.get("type") == "text":
+                    result = scrub(block.get("text", ""), key)
+                    new_blocks.append({**block, "text": result.text})
+                    all_detections.extend(result.detections)
+                else:
+                    new_blocks.append(block)
+            scrubbed.append({**msg, "content": new_blocks})
+        else:
+            scrubbed.append(msg)
+
+    return scrubbed, all_detections

sovergate/sender.py

@@ -0,0 +1,38 @@
+"""Async HTTP sender — fire-and-forget, 2s timeout, never raises."""
+
+import json
+import logging
+import urllib.request
+import urllib.error
+from typing import Any
+
+logger = logging.getLogger("sovergate.sender")
+
+_BASE_URL = "https://api.sovergate.com"
+_TIMEOUT = 2  # seconds — never exceed this
+
+
+def send(api_key: str, payload: dict[str, Any], base_url: str = _BASE_URL) -> bool:
+    """
+    POST payload to /ingest. Returns True on success, False on any failure.
+    Never raises — the caller's app must not be affected by our failures.
+    """
+    try:
+        body = json.dumps(payload).encode("utf-8")
+        req = urllib.request.Request(
+            url=f"{base_url}/ingest",
+            data=body,
+            method="POST",
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
+        )
+        with urllib.request.urlopen(req, timeout=_TIMEOUT) as resp:
+            return resp.status < 400
+    except urllib.error.HTTPError as e:
+        logger.debug("sovergate ingest HTTP %s: %s", e.code, e.reason)
+        return False
+    except Exception as e:
+        logger.debug("sovergate ingest error: %s", e)
+        return False

sovergate-0.1.0a1.dist-info/METADATA

@@ -0,0 +1,185 @@
+Metadata-Version: 2.5
+Name: sovergate
+Version: 0.1.0a1
+Summary: EU AI Act compliance SDK — automatic, non-invasive audit logging for LLM calls
+Project-URL: Homepage, https://sovergate.com
+Project-URL: Repository, https://github.com/Sovergate/sdk-python
+Project-URL: Issues, https://github.com/Sovergate/sdk-python/issues
+Author: Roberto Postolovski
+License-Expression: MIT
+License-File: LICENSE
+Keywords: anthropic,audit,compliance,eu-ai-act,gdpr,llm,observability,openai,pii
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+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: Programming Language :: Python :: 3.14
+Classifier: Topic :: Security
+Classifier: Topic :: System :: Logging
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: anthropic>=2.0; extra == 'dev'
+Requires-Dist: httpx2; extra == 'dev'
+Requires-Dist: httpx>=0.27; extra == 'dev'
+Requires-Dist: openai>=1.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# sovergate
+
+Python SDK for [Sovergate](https://sovergate.com): EU AI Act Article 12 audit
+logging for LLM calls, with PII scrubbed inside your own infrastructure.
+
+> **Early access.** The SDK is published as an alpha and the hosted ingest
+> service is not generally available yet. APIs may change before 1.0.
+
+## How it works
+
+Your app keeps calling OpenAI or Anthropic directly. Sovergate does not proxy
+or intercept the request. After a call completes, the SDK takes a copy,
+scrubs personal data **locally**, and sends the scrubbed copy to Sovergate
+from a background thread.
+
+```
+Your app ─────────────────────────────► OpenAI / Anthropic
+              │
+              └──► scrub PII locally ──► Sovergate (background, fire and forget)
+```
+
+## Install
+
+```bash
+pip install --pre sovergate
+```
+
+`--pre` is needed while the SDK is in alpha. Requires Python 3.10+. No runtime
+dependencies.
+
+## Quick start
+
+```python
+import openai
+import sovergate
+
+sovergate.init(api_key="sov_prod_xxxx")
+sovergate.instrument(openai)
+
+# Your existing code is unchanged
+response = openai.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "Hello"}],
+)
+# The response is returned immediately; logging happens in the background
+```
+
+You can also instrument a client instance, sync or async:
+
+```python
+from openai import AsyncOpenAI
+
+client = AsyncOpenAI()
+sovergate.instrument(client)
+```
+
+### Anthropic
+
+Pass a client instance (the `anthropic` module itself has no client to patch):
+
+```python
+import anthropic
+import sovergate
+
+client = anthropic.Anthropic()        # or anthropic.AsyncAnthropic()
+sovergate.init(api_key="sov_prod_xxxx")
+sovergate.instrument(client)
+```
+
+## Stable PII tokens (recommended)
+
+By default, detected PII is replaced with positional placeholders
+(`[EMAIL_REDACTED_1]`), which are not correlatable between logs. Pass a
+`pii_key` to replace values with deterministic, irreversible HMAC-SHA256 tokens
+instead. The same value always maps to the same token, so Sovergate can count
+unique people, IBANs and so on without ever receiving the raw values.
+
+```python
+sovergate.init(api_key="sov_prod_xxxx", pii_key="<your-secret>")
+```
+
+The `pii_key` is your secret. Keep it stable, and never send it to us: it stays
+on your infrastructure, and without it the tokens cannot be reversed.
+
+## Options
+
+```python
+sovergate.init(
+    api_key="sov_prod_xxxx",           # required
+    base_url="https://...",            # default: https://api.sovergate.com
+    pii_key="<your-secret>",           # optional, see above
+    debug=True,                        # verbose output from the "sovergate" logger only
+)
+```
+
+## What is sent to Sovergate
+
+For each completed call, one JSON record:
+
+| Field | Content |
+|---|---|
+| `model` | Model name returned by the provider |
+| `messages` | Your prompt messages (and Anthropic `system` prompt), **after** PII scrubbing |
+| `response` | The model's text output, **after** PII scrubbing |
+| `prompt_tokens`, `completion_tokens` | Token counts from the provider |
+| `latency_ms`, `timestamp` | Call duration and start time |
+| `finish_reason` | Why the model stopped |
+| `pii_detections` | Category and placeholder of each scrubbed item, never the original value |
+
+Never sent: the raw prompt or response, your `pii_key`, your LLM provider API
+key, or request headers.
+
+### What the scrubber detects
+
+Regex-based, applied to every text part of the prompt and response: email
+addresses, IP addresses, IBANs (including the spaced format), card numbers,
+phone numbers, dates of birth, ID numbers, and names that follow a title (Mr,
+Mrs, Ms, Dr, Prof). Other personal data, such as names without a title, is
+**not** detected yet, so keep data minimisation in mind when you build prompts.
+The code is in [`sovergate/scrubber.py`](sovergate/scrubber.py).
+
+## Guarantees
+
+- Never blocks your call: logging runs in a background daemon thread
+- Never raises: if setup fails, the SDK logs a warning on the `sovergate`
+  logger and stays out of the way
+- Returns the provider's response unchanged; `with_raw_response` keeps working
+- Never changes your app's logging configuration, even with `debug=True`
+- 2 second timeout on every HTTP call to Sovergate
+- If Sovergate is unreachable, records are queued in memory (up to 10,000) and
+  retried with exponential backoff
+
+## Current limitations
+
+- Streaming calls (`stream=True`) are passed through untouched but not logged yet.
+- Calls made through `with_raw_response` are not logged.
+- The retry queue is in memory, so queued records are lost if the process exits.
+
+## Development
+
+```bash
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+```
+
+## Security
+
+Please report vulnerabilities privately. See [SECURITY.md](SECURITY.md).
+
+## License
+
+[MIT](LICENSE)

sovergate-0.1.0a1.dist-info/RECORD

@@ -0,0 +1,11 @@
+sovergate/__init__.py,sha256=II8IbizprpBr6bWxEw4QJzYSwqt7xOPCzRDDTUJ-CqA,117
+sovergate/client.py,sha256=PjTbJam3aC6peBOQqmokGz-D8bCjJEKiwVwX6i_hnhY,4866
+sovergate/patcher.py,sha256=WFcGg2AYN-18aAOidI5wjjbRfwl4S3sQMZuywiTmkaU,5391
+sovergate/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sovergate/queue.py,sha256=uMmxKSIr2XLdzYGID4m9czyPhkVGQLzHx2DW3MHPjaU,2188
+sovergate/scrubber.py,sha256=nW76ho1FbhG1jpOMB8xfEpKyTtM-alNJ29QfIjZNtGQ,4985
+sovergate/sender.py,sha256=TRC_ZKF0RsckL_dMfNoZFfaAp1sq3V8rsyeERFWg4LU,1231
+sovergate-0.1.0a1.dist-info/METADATA,sha256=xcsuwzl0ovVYS-As47ADNvv9Nboc9sKmoCEjR5XR_6g,6189
+sovergate-0.1.0a1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+sovergate-0.1.0a1.dist-info/licenses/LICENSE,sha256=WTZWv7-Yhn7hxEtx60bKB5QfVAlJK_6FL6sj2RqmvIw,1076
+sovergate-0.1.0a1.dist-info/RECORD,,

sovergate-0.1.0a1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

sovergate-0.1.0a1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Roberto Postolovski
+
+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.