parapet 0.1.0__py3-none-any.whl

parapet/__init__.py

@@ -0,0 +1,131 @@
+# Copyright 2026 The Parapet Project
+# SPDX-License-Identifier: Apache-2.0
+
+# Parapet Python SDK — defined in M1.11
+#
+# Public API:
+#   parapet.init(config_path)  — validate config, start engine sidecar, patch httpx
+#   parapet.session(...)       — context manager that sets W3C Baggage for the scope
+#   parapet.untrusted(content) — mark a string as untrusted content
+from __future__ import annotations
+
+import logging
+from contextlib import contextmanager
+from contextvars import ContextVar
+from pathlib import Path
+from typing import Generator
+
+from parapet.header import build_baggage_header
+from parapet.sidecar import EngineState, start_engine
+from parapet.transport import patch_httpx
+from parapet.trust import _ensure_registry
+from typing import Iterable
+
+__all__ = ["init", "session", "untrusted"]
+
+logger = logging.getLogger("parapet")
+
+_DEFAULT_PORT = 9800
+
+# Module-level engine state — single instance shared across init/session.
+_engine_state = EngineState()
+
+# Active baggage for the current context (set inside session(), cleared on exit).
+_active_baggage: ContextVar[str | None] = ContextVar(
+    "parapet_active_baggage", default=None
+)
+
+
+class SessionContext:
+    """Holds the baggage string for the duration of a session scope."""
+
+    __slots__ = ("baggage",)
+
+    def __init__(self, baggage: str) -> None:
+        self.baggage = baggage
+
+
+def init(
+    config_path: str,
+    *,
+    port: int = _DEFAULT_PORT,
+    extra_hosts: Iterable[str] | None = None,
+) -> None:
+    """Initialize the parapet SDK.
+
+    Validates that *config_path* exists, starts the engine sidecar (if not
+    already running), and patches httpx to route LLM requests through the
+    engine.
+
+    Args:
+        config_path: Path to the parapet.yaml configuration file.
+        port: Port for the engine to listen on (default 9800).
+        extra_hosts: Additional LLM API hosts to intercept beyond the
+            built-in defaults (e.g., ``["api.together.xyz"]``).
+
+    Raises:
+        FileNotFoundError: If *config_path* does not exist.
+    """
+    path = Path(config_path)
+    if not path.exists():
+        raise FileNotFoundError(
+            f"Config file not found: {config_path}"
+        )
+
+    hosts = frozenset(extra_hosts) if extra_hosts else None
+    start_engine(config_path=config_path, port=port, state=_engine_state)
+    patch_httpx(port=port, extra_hosts=hosts)
+
+
+@contextmanager
+def session(
+    *,
+    user_id: str | None = None,
+    role: str | None = None,
+) -> Generator[SessionContext, None, None]:
+    """Set W3C Baggage headers for the duration of this scope.
+
+    Must be called after ``init()``.
+
+    Args:
+        user_id: Optional user identifier to include in baggage.
+        role: Optional role string to include in baggage.
+
+    Yields:
+        A ``SessionContext`` with the computed baggage string.
+
+    Raises:
+        RuntimeError: If ``init()`` has not been called.
+    """
+    if not _engine_state.initialized:
+        raise RuntimeError(
+            "parapet.session() called before init(). Call parapet.init() first."
+        )
+
+    baggage = build_baggage_header(user_id=user_id, role=role)
+    token = _active_baggage.set(baggage)
+    try:
+        yield SessionContext(baggage=baggage)
+    finally:
+        _active_baggage.reset(token)
+
+
+def untrusted(content: str, source: str = "unknown") -> str:
+    """Mark a string as untrusted content.
+
+    Registers the string in the per-context trust registry so the SDK
+    can locate it in serialized requests and emit byte-range trust spans.
+
+    The string is returned unchanged for inline use::
+
+        prompt = f"Context: {parapet.untrusted(rag_snippet, source='rag')}"
+
+    Args:
+        content: The untrusted content string.
+        source: Provenance label (e.g., "rag", "user_input", "web_search").
+
+    Returns:
+        The content string, unchanged.
+    """
+    registry = _ensure_registry()
+    return registry.register(content, source=source)

parapet/header.py

@@ -0,0 +1,85 @@
+# Copyright 2026 The Parapet Project
+# SPDX-License-Identifier: Apache-2.0
+
+"""Header serialization for Parapet SDK.
+
+Includes:
+- W3C Baggage header (``baggage: key1=value1,key2=value2``)
+- X-Guard-Trust header (``inline:<base64-encoded JSON>``)
+
+Values are percent-encoded to handle special characters safely.
+"""
+from __future__ import annotations
+
+import base64
+import json
+import logging
+from urllib.parse import quote
+
+__all__ = ["build_baggage_header", "build_trust_header"]
+
+MAX_TRUST_HEADER_BYTES = 4096  # 4KB inline limit
+
+# Characters that must be percent-encoded in baggage values.
+# W3C Baggage uses a subset of RFC 3986 — commas, semicolons, equals,
+# and spaces are delimiters and must not appear unescaped in values.
+_SAFE_CHARS = ""  # encode everything except unreserved chars
+
+
+def _encode_value(value: str) -> str:
+    """Percent-encode a baggage value per W3C Baggage spec."""
+    return quote(value, safe=_SAFE_CHARS)
+
+
+def build_baggage_header(
+    *,
+    user_id: str | None = None,
+    role: str | None = None,
+) -> str:
+    """Build a W3C Baggage header value from optional fields.
+
+    Args:
+        user_id: Optional user identifier.
+        role: Optional role string.
+
+    Returns:
+        Baggage header value string (e.g. ``user_id=u_1,role=admin``).
+        Returns empty string when no fields are provided.
+    """
+    parts: list[str] = []
+
+    if user_id is not None:
+        parts.append(f"user_id={_encode_value(user_id)}")
+
+    if role is not None:
+        parts.append(f"role={_encode_value(role)}")
+
+    return ",".join(parts)
+
+
+def build_trust_header(spans: list) -> str | None:
+    """Serialize trust spans as X-Guard-Trust header value.
+
+    Format: ``inline:<base64-encoded JSON>``
+    JSON schema: ``[{"s": start, "e": end, "src": source}, ...]``
+
+    Returns None if no spans or if encoded value exceeds 4KB limit.
+    Compact keys (s/e/src) to minimize header size.
+    """
+    if not spans:
+        return None
+
+    compact = [{"s": s.start, "e": s.end, "src": s.source} for s in spans]
+    payload = json.dumps(compact, separators=(",", ":")).encode("utf-8")
+
+    if len(payload) > MAX_TRUST_HEADER_BYTES:
+        logging.getLogger("parapet.header").warning(
+            "X-Guard-Trust header exceeds %d byte limit (%d spans, %d bytes); dropping",
+            MAX_TRUST_HEADER_BYTES,
+            len(spans),
+            len(payload),
+        )
+        return None
+
+    encoded = base64.b64encode(payload).decode("ascii")
+    return f"inline:{encoded}"

parapet/sidecar.py

@@ -0,0 +1,212 @@
+# Copyright 2026 The Parapet Project
+# SPDX-License-Identifier: Apache-2.0
+
+"""Engine process lifecycle management.
+
+Manages spawning the Rust engine as a subprocess, PID file tracking,
+stale PID cleanup, heartbeat watchdog, and clean shutdown via atexit.
+"""
+from __future__ import annotations
+
+import atexit
+import logging
+import os
+import subprocess
+import threading
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import IO
+
+import httpx
+
+__all__ = ["EngineState", "start_engine", "stop_engine"]
+
+logger = logging.getLogger("parapet.sidecar")
+
+_HEARTBEAT_INTERVAL_SECONDS = 10
+_PARAPET_DIR = Path.home() / ".parapet"
+_DEFAULT_PID_PATH = _PARAPET_DIR / "engine.pid"
+_DEFAULT_LOG_PATH = _PARAPET_DIR / "engine.log"
+
+
+@dataclass
+class EngineState:
+    """Holds the state of the running engine sidecar.
+
+    This is not global mutable state scattered across the module --
+    it is a single, explicit object passed to functions that need it.
+    """
+
+    process: subprocess.Popen | None = None
+    initialized: bool = False
+    port: int | None = None
+    _log_file: IO[bytes] | None = field(default=None, repr=False)
+    _heartbeat_thread: threading.Thread | None = field(
+        default=None, repr=False
+    )
+    _heartbeat_stop: threading.Event = field(
+        default_factory=threading.Event, repr=False
+    )
+
+
+def _is_process_alive(pid: int) -> bool:
+    """Check whether a process with the given PID is still running."""
+    try:
+        os.kill(pid, 0)
+        return True
+    except (OSError, ProcessLookupError):
+        return False
+
+
+def _start_heartbeat(state: EngineState, port: int) -> None:
+    """Start a daemon thread that pings the engine heartbeat endpoint."""
+
+    def _heartbeat_loop() -> None:
+        while not state._heartbeat_stop.is_set():
+            try:
+                httpx.get(
+                    f"http://127.0.0.1:{port}/v1/heartbeat",
+                    timeout=5.0,
+                )
+            except Exception:
+                logger.debug("Heartbeat send failed (engine may be starting)")
+            state._heartbeat_stop.wait(_HEARTBEAT_INTERVAL_SECONDS)
+
+    thread = threading.Thread(
+        target=_heartbeat_loop,
+        name="parapet-heartbeat",
+        daemon=True,
+    )
+    thread.start()
+    state._heartbeat_thread = thread
+
+
+def start_engine(
+    config_path: str,
+    port: int,
+    *,
+    state: EngineState,
+    pid_path: Path = _DEFAULT_PID_PATH,
+    log_path: Path = _DEFAULT_LOG_PATH,
+) -> None:
+    """Spawn the Rust engine as a subprocess.
+
+    Idempotent: if the engine is already running (tracked via *state*),
+    this is a no-op. If a PID file exists from a previous run but the
+    process is dead, the stale PID is cleaned up and a fresh engine
+    is started.
+
+    Args:
+        config_path: Path to the parapet.yaml configuration file.
+        port: Port for the engine to listen on.
+        state: Mutable engine state object.
+        pid_path: Path to write the engine PID file.
+        log_path: Path to write the engine log file.
+    """
+    # Already running in this process -- reuse.
+    if state.initialized and state.process is not None:
+        if state.process.poll() is None:
+            logger.debug("Engine already running (pid=%d), reusing", state.process.pid)
+            return
+        # Process died unexpectedly; fall through to restart.
+        logger.warning("Engine process died unexpectedly, restarting")
+        state.process = None
+        state.initialized = False
+
+    # Check for stale PID file from a previous run.
+    if pid_path.exists():
+        try:
+            old_pid = int(pid_path.read_text().strip())
+        except (ValueError, OSError):
+            old_pid = None
+
+        if old_pid is not None and _is_process_alive(old_pid):
+            # Another engine is still running -- reuse it.
+            logger.info(
+                "Reusing existing engine from PID file (pid=%d)", old_pid
+            )
+            state.initialized = True
+            state.port = port
+            _start_heartbeat(state, port)
+            return
+
+        # Stale PID file -- clean up.
+        logger.info("Cleaning up stale PID file (pid=%s)", old_pid)
+        pid_path.unlink(missing_ok=True)
+
+    # Ensure the parapet directory exists.
+    pid_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Open log file for engine stdout/stderr.
+    log_file: IO[bytes] = open(log_path, "ab")
+
+    # Spawn the engine process.
+    proc = subprocess.Popen(
+        [
+            "parapet-engine",
+            "--config",
+            config_path,
+            "--port",
+            str(port),
+        ],
+        stdout=log_file,
+        stderr=log_file,
+    )
+
+    state.process = proc
+    state.initialized = True
+    state.port = port
+    state._log_file = log_file
+
+    # Write PID file.
+    pid_path.write_text(str(proc.pid))
+    logger.info("Engine started (pid=%d, port=%d)", proc.pid, port)
+
+    # Start heartbeat watchdog.
+    _start_heartbeat(state, port)
+
+    # Register atexit handler for clean shutdown.
+    atexit.register(stop_engine, state=state, pid_path=pid_path)
+
+
+def stop_engine(
+    *,
+    state: EngineState,
+    pid_path: Path = _DEFAULT_PID_PATH,
+) -> None:
+    """Terminate the engine subprocess and clean up.
+
+    Args:
+        state: The engine state to clean up.
+        pid_path: Path to the PID file to remove.
+    """
+    # Signal heartbeat thread to stop.
+    state._heartbeat_stop.set()
+
+    if state.process is not None:
+        logger.info("Stopping engine (pid=%d)", state.process.pid)
+        try:
+            state.process.terminate()
+            state.process.wait(timeout=5)
+        except Exception:
+            logger.warning("Engine did not stop gracefully, killing")
+            try:
+                state.process.kill()
+            except Exception:
+                pass
+
+    # Close the log file handle.
+    if state._log_file is not None:
+        try:
+            state._log_file.close()
+        except Exception:
+            pass
+        state._log_file = None
+
+    state.process = None
+    state.initialized = False
+
+    if pid_path.exists():
+        pid_path.unlink(missing_ok=True)
+        logger.debug("Removed PID file %s", pid_path)

parapet/transport.py

@@ -0,0 +1,257 @@
+# Copyright 2026 The Parapet Project
+# SPDX-License-Identifier: Apache-2.0
+
+"""httpx transport patch for routing LLM API requests through the parapet engine.
+
+Monkey-patches ``httpx.Client`` and ``httpx.AsyncClient`` so that requests
+to known LLM API hosts are transparently routed through ``localhost:<port>``.
+
+Failopen behavior:
+    Connection refused -> fall back to original URL (engine down is not fatal).
+Failclosed behavior:
+    Timeout -> raise error (do not silently bypass).
+"""
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+import httpx
+
+from parapet.header import build_trust_header
+from parapet.trust import get_registry
+
+__all__ = [
+    "DEFAULT_LLM_HOSTS",
+    "LLM_HOSTS",
+    "ParapetTransport",
+    "AsyncParapetTransport",
+    "patch_httpx",
+    "should_intercept",
+]
+
+logger = logging.getLogger("parapet.transport")
+
+# Default LLM API hosts that should be routed through the engine.
+# Strict equality match -- subdomains are NOT intercepted.
+DEFAULT_LLM_HOSTS: frozenset[str] = frozenset(
+    {
+        "api.openai.com",
+        "api.anthropic.com",
+        # OpenAI-compatible providers
+        "api.cerebras.ai",
+        "api.groq.com",
+        "generativelanguage.googleapis.com",
+    }
+)
+
+# Active host set — starts as defaults, extended by patch_httpx(extra_hosts=...).
+LLM_HOSTS: frozenset[str] = DEFAULT_LLM_HOSTS
+
+
+def should_intercept(url: httpx.URL) -> bool:
+    """Return True if the request URL targets a known LLM API host.
+
+    Uses strict host equality -- subdomains like ``evil.api.openai.com``
+    are not matched.
+    """
+    return url.host in LLM_HOSTS
+
+
+def _rewrite_url(original_url: httpx.URL, port: int) -> httpx.URL:
+    """Rewrite a URL to target localhost on the given port.
+
+    Preserves the path, query, and fragment from the original URL.
+    Forces http scheme since the engine listens locally.
+    """
+    return original_url.copy_with(
+        scheme="http",
+        host="127.0.0.1",
+        port=port,
+    )
+
+
+class ParapetTransport(httpx.BaseTransport):
+    """Synchronous httpx transport that routes LLM requests through the engine.
+
+    Non-LLM requests are passed through to the wrapped transport unchanged.
+    Connection errors to the engine trigger failopen -- the original URL is
+    retried directly.
+    """
+
+    def __init__(
+        self,
+        wrapped: httpx.BaseTransport,
+        port: int,
+        hosts: Optional[frozenset[str]] = None,
+    ) -> None:
+        self._wrapped = wrapped
+        self._port = port
+        self._hosts = hosts or LLM_HOSTS
+
+    def handle_request(self, request: httpx.Request) -> httpx.Response:
+        if request.url.host not in self._hosts:
+            return self._wrapped.handle_request(request)
+
+        original_url = request.url
+        proxy_url = _rewrite_url(original_url, self._port)
+
+        # Build a new request targeting the engine.
+        # Carry the original host so the engine can forward to the right upstream.
+        # Remove the original Host header so httpx sets it from proxy_url.
+        headers = {k: v for k, v in request.headers.items() if k.lower() != "host"}
+        headers["x-parapet-original-host"] = original_url.host
+
+        # Inject trust spans if registry has entries
+        registry = get_registry()
+        if registry is not None:
+            spans = registry.find_spans(request.content)
+            trust_header = build_trust_header(spans)
+            if trust_header is not None:
+                headers["x-guard-trust"] = trust_header
+
+        proxy_request = httpx.Request(
+            method=request.method,
+            url=proxy_url,
+            headers=headers,
+            content=request.content,
+            extensions=request.extensions,
+        )
+
+        try:
+            return self._wrapped.handle_request(proxy_request)
+        except (ConnectionError, OSError) as exc:
+            # Failopen: engine is unreachable, fall back to original URL.
+            logger.warning(
+                "Engine unreachable (%s), failing open to %s",
+                exc,
+                original_url,
+            )
+            fallback_request = httpx.Request(
+                method=request.method,
+                url=original_url,
+                headers=request.headers,
+                content=request.content,
+                extensions=request.extensions,
+            )
+            return self._wrapped.handle_request(fallback_request)
+
+    def close(self) -> None:
+        self._wrapped.close()
+
+
+class AsyncParapetTransport(httpx.AsyncBaseTransport):
+    """Async httpx transport that routes LLM requests through the engine.
+
+    Same failopen/failclosed semantics as ``ParapetTransport``.
+    """
+
+    def __init__(
+        self,
+        wrapped: httpx.AsyncBaseTransport,
+        port: int,
+        hosts: Optional[frozenset[str]] = None,
+    ) -> None:
+        self._wrapped = wrapped
+        self._port = port
+        self._hosts = hosts or LLM_HOSTS
+
+    async def handle_async_request(
+        self, request: httpx.Request
+    ) -> httpx.Response:
+        if request.url.host not in self._hosts:
+            return await self._wrapped.handle_async_request(request)
+
+        original_url = request.url
+        proxy_url = _rewrite_url(original_url, self._port)
+
+        # Carry the original host so the engine can forward to the right upstream.
+        # Remove the original Host header so httpx sets it from proxy_url.
+        headers = {k: v for k, v in request.headers.items() if k.lower() != "host"}
+        headers["x-parapet-original-host"] = original_url.host
+
+        # Inject trust spans if registry has entries
+        registry = get_registry()
+        if registry is not None:
+            spans = registry.find_spans(request.content)
+            trust_header = build_trust_header(spans)
+            if trust_header is not None:
+                headers["x-guard-trust"] = trust_header
+
+        proxy_request = httpx.Request(
+            method=request.method,
+            url=proxy_url,
+            headers=headers,
+            content=request.content,
+            extensions=request.extensions,
+        )
+
+        try:
+            return await self._wrapped.handle_async_request(proxy_request)
+        except (ConnectionError, OSError) as exc:
+            logger.warning(
+                "Engine unreachable (%s), failing open to %s",
+                exc,
+                original_url,
+            )
+            fallback_request = httpx.Request(
+                method=request.method,
+                url=original_url,
+                headers=request.headers,
+                content=request.content,
+                extensions=request.extensions,
+            )
+            return await self._wrapped.handle_async_request(fallback_request)
+
+    async def aclose(self) -> None:
+        await self._wrapped.aclose()
+
+
+def patch_httpx(
+    port: int,
+    extra_hosts: Optional[frozenset[str]] = None,
+) -> None:
+    """Monkey-patch httpx.Client and httpx.AsyncClient constructors.
+
+    After this call, all newly created ``httpx.Client`` and
+    ``httpx.AsyncClient`` instances will route LLM API requests through
+    the parapet engine at ``localhost:<port>``.
+
+    Args:
+        port: The port the engine is listening on.
+        extra_hosts: Additional hosts to intercept beyond the defaults.
+    """
+    global LLM_HOSTS
+    if extra_hosts:
+        LLM_HOSTS = DEFAULT_LLM_HOSTS | extra_hosts
+    else:
+        LLM_HOSTS = DEFAULT_LLM_HOSTS
+
+    hosts = LLM_HOSTS
+    _original_client_init = httpx.Client.__init__
+    _original_async_init = httpx.AsyncClient.__init__
+
+    def _patched_client_init(self: httpx.Client, *args, **kwargs) -> None:
+        _original_client_init(self, *args, **kwargs)
+        original_transport = self._transport
+        self._transport = ParapetTransport(
+            wrapped=original_transport,
+            port=port,
+            hosts=hosts,
+        )
+
+    def _patched_async_init(
+        self: httpx.AsyncClient, *args, **kwargs
+    ) -> None:
+        _original_async_init(self, *args, **kwargs)
+        original_transport = self._transport
+        self._transport = AsyncParapetTransport(
+            wrapped=original_transport,
+            port=port,
+            hosts=hosts,
+        )
+
+    httpx.Client.__init__ = _patched_client_init  # type: ignore[assignment]
+    httpx.AsyncClient.__init__ = _patched_async_init  # type: ignore[assignment]
+
+    logger.info("httpx patched to route LLM requests through port %d", port)

parapet/trust.py

@@ -0,0 +1,157 @@
+# Copyright 2026 The Parapet Project
+# SPDX-License-Identifier: Apache-2.0
+
+"""Byte-range trust registry for marking untrusted content.
+
+SDK users call ``parapet.untrusted(content, source)`` to register strings
+that originate from untrusted sources (RAG, user input, web search).
+
+On request intercept, the transport layer builds an Aho-Corasick automaton
+from registered strings, searches the serialized request body, and emits
+byte ranges as ``X-Guard-Trust`` header spans.
+"""
+from __future__ import annotations
+
+import json
+from contextvars import ContextVar
+from dataclasses import dataclass
+
+__all__ = ["TrustRegistry", "TrustSpan", "get_registry"]
+
+# Per-context registry (thread/async-safe via contextvars)
+_registry: ContextVar[TrustRegistry | None] = ContextVar(
+    "parapet_trust_registry", default=None
+)
+
+
+@dataclass(frozen=True)
+class TrustSpan:
+    """A byte range in the request body marked as untrusted."""
+    start: int
+    end: int
+    source: str = "unknown"
+
+
+@dataclass
+class _Entry:
+    """A registered untrusted string."""
+    content: str
+    source: str
+
+
+class TrustRegistry:
+    """Registry of untrusted content strings for the current request scope.
+
+    Thread-safe via contextvars -- each async context gets its own registry.
+
+    Usage:
+        registry = TrustRegistry()
+        registry.register("some RAG content", source="rag")
+        spans = registry.find_spans(serialized_body_bytes)
+    """
+
+    MAX_ENTRIES = 1000  # Configurable cap per request
+
+    def __init__(self, max_entries: int = MAX_ENTRIES) -> None:
+        self._entries: list[_Entry] = []
+        self._max_entries = max_entries
+
+    def register(self, content: str, source: str = "unknown") -> str:
+        """Register a string as untrusted. Returns the string unchanged.
+
+        Args:
+            content: The untrusted content string.
+            source: Provenance label (e.g., "rag", "user_input", "web_search").
+
+        Returns:
+            The content string, unchanged (for inline use).
+
+        Raises:
+            ValueError: If the registry is full (> max_entries).
+        """
+        if not content:
+            return content
+
+        if len(self._entries) >= self._max_entries:
+            raise ValueError(
+                f"TrustRegistry full: {self._max_entries} entries. "
+                "Increase max_entries or reduce untrusted content registrations."
+            )
+
+        self._entries.append(_Entry(content=content, source=source))
+        return content
+
+    def find_spans(self, body: bytes) -> list[TrustSpan]:
+        """Find all registered untrusted strings in a serialized request body.
+
+        Uses a simple multi-pattern search (str.find-based for correctness in v2;
+        Aho-Corasick library can be swapped in for performance if needed).
+
+        Handles JSON string escaping: searches for the JSON-escaped form of each
+        registered string, since the body is JSON-serialized.
+
+        Args:
+            body: The serialized request body bytes.
+
+        Returns:
+            List of TrustSpan for each occurrence found, sorted by start offset.
+        """
+        if not self._entries:
+            return []
+
+        text = body.decode("utf-8", errors="replace")
+        spans: list[TrustSpan] = []
+
+        for entry in self._entries:
+            # Search for JSON-escaped form of the string since the body is JSON.
+            # json.dumps adds quotes, so strip them to get the escaped interior.
+            escaped = json.dumps(entry.content)[1:-1]
+
+            # Find all occurrences of the escaped string in the body
+            start = 0
+            while True:
+                idx = text.find(escaped, start)
+                if idx == -1:
+                    break
+                # Convert char offset to byte offset
+                byte_start = len(text[:idx].encode("utf-8"))
+                byte_end = byte_start + len(escaped.encode("utf-8"))
+                spans.append(TrustSpan(
+                    start=byte_start, end=byte_end, source=entry.source,
+                ))
+                start = idx + 1
+
+        # Sort by start offset, then by end offset (longer spans first for same start)
+        spans.sort(key=lambda s: (s.start, -s.end))
+        return spans
+
+    @property
+    def entry_count(self) -> int:
+        """Number of registered entries."""
+        return len(self._entries)
+
+    def clear(self) -> None:
+        """Remove all registered entries."""
+        self._entries.clear()
+
+
+def get_registry() -> TrustRegistry | None:
+    """Get the trust registry for the current context, if any."""
+    return _registry.get()
+
+
+def _ensure_registry() -> TrustRegistry:
+    """Get or create the trust registry for the current context."""
+    reg = _registry.get()
+    if reg is None:
+        reg = TrustRegistry()
+        _registry.set(reg)
+    return reg
+
+
+def _clear_registry() -> None:
+    """Clear the trust registry for the current context."""
+    reg = _registry.get()
+    if reg is not None:
+        reg.clear()
+    _registry.set(None)

parapet-0.1.0.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: parapet
+Version: 0.1.0
+Summary: Python SDK for Parapet LLM proxy firewall
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest-httpx>=0.34; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: respx>=0.22; extra == 'dev'

parapet-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+parapet/__init__.py,sha256=agkImlhdz6uwpfk7ljE8wCVpGavUiMFYQ2aPdOomFAc,4076
+parapet/header.py,sha256=jZBrdgZFRksV3lU1B96k784tqsFgWkUweQ2nNcuXB6A,2589
+parapet/sidecar.py,sha256=gGWsA-ZMX0Uc3wiiBPoZHyyqb5jmVbcx8GpRuasPmDI,6430
+parapet/transport.py,sha256=fOca6o9pRe-K7qD_h2jLjxPudYun95vFRZkT1Djucps,8727
+parapet/trust.py,sha256=AWmINJlfum_ZoSzeFR0nfsb7vEzHmrzE_MdaaWWz8ao,5176
+parapet-0.1.0.dist-info/METADATA,sha256=vHnB98-E__Ca1AtmlASf2ayNz76E5zCLB5S1oqwfhcU,390
+parapet-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+parapet-0.1.0.dist-info/RECORD,,

parapet-0.1.0.dist-info/WHEEL

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