outlaya 0.1.0__py3-none-any.whl

outlaya/__init__.py

@@ -0,0 +1,90 @@
+"""Outlaya Python SDK: AI cost attribution across providers.
+
+Wrap a supported provider client, read usage from its response, and send one
+normalized event to Outlaya without putting the ingest call on your request
+path.
+
+Supported providers: OpenAI, Anthropic, Gemini, OpenRouter (wrapped clients)
+and Cursor (Admin API pull sync).
+"""
+
+from __future__ import annotations
+
+from ._client import (
+    OutlayaClient,
+    OutlayaIngestError,
+    Transport,
+    TransportResponse,
+    flush,
+    get_client,
+    init,
+)
+from ._context import current_metadata, metadata, with_metadata
+from ._providers.anthropic import wrap_anthropic
+from ._providers.cursor import (
+    CursorSyncError,
+    CursorSyncResult,
+    CursorTransport,
+    CursorTransportInput,
+    CursorUsagePage,
+    CursorUsageRecord,
+    sync_cursor_usage,
+)
+from ._providers.gemini import wrap_gemini, wrap_google_genai
+from ._providers.openai import wrap_openai, wrap_openrouter
+from ._types import (
+    ClientStats,
+    JsonScalar,
+    OutlayaClientOptions,
+    OutlayaEvent,
+    OutlayaEventClient,
+    OutlayaMetadata,
+    UsageLike,
+    UsageReport,
+    WrapOptions,
+)
+from ._usage import track_usage
+from ._version import __version__
+from ._wrap import wrap
+
+SDK_VERSION = __version__
+OutlayaClientStats = ClientStats
+
+__all__ = [
+    "ClientStats",
+    "CursorSyncError",
+    "CursorSyncResult",
+    "CursorTransport",
+    "CursorTransportInput",
+    "CursorUsagePage",
+    "CursorUsageRecord",
+    "JsonScalar",
+    "OutlayaClient",
+    "OutlayaClientOptions",
+    "OutlayaClientStats",
+    "OutlayaEvent",
+    "OutlayaEventClient",
+    "OutlayaIngestError",
+    "OutlayaMetadata",
+    "SDK_VERSION",
+    "Transport",
+    "TransportResponse",
+    "UsageLike",
+    "UsageReport",
+    "WrapOptions",
+    "__version__",
+    "current_metadata",
+    "flush",
+    "get_client",
+    "init",
+    "metadata",
+    "sync_cursor_usage",
+    "track_usage",
+    "with_metadata",
+    "wrap",
+    "wrap_anthropic",
+    "wrap_gemini",
+    "wrap_google_genai",
+    "wrap_openai",
+    "wrap_openrouter",
+]

outlaya/_batching.py

@@ -0,0 +1,96 @@
+"""Packing helpers for the Outlaya ingest request limits."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from typing import Callable, Generic, List, Sequence, TypeVar
+
+T = TypeVar("T")
+
+#: The ingest route rejects event batches above 500 entries.
+SDK_INGEST_MAX_BATCH_EVENTS = 500
+
+#: 4 MiB stays below the API's 5 MiB request ceiling.
+SDK_INGEST_MAX_CLIENT_BODY_BYTES = 4 * 1024 * 1024 - 1024
+
+
+def utf8_byte_length(text: str) -> int:
+    return len(text.encode("utf-8"))
+
+
+def json_byte_length(value: object) -> int:
+    return utf8_byte_length(json.dumps(value, separators=(",", ":")))
+
+
+@dataclass
+class RequestBatchPlan(Generic[T]):
+    batches: List[List[T]] = field(default_factory=list)
+    oversized_items: List[T] = field(default_factory=list)
+
+
+def plan_request_batches(
+    items: Sequence[T],
+    max_items: int,
+    max_bytes: int,
+    serialize: Callable[[List[T]], str],
+) -> RequestBatchPlan[T]:
+    """Pack items into JSON requests within the item and byte limits.
+
+    Items that cannot fit alone are returned separately.
+    """
+    plan: RequestBatchPlan[T] = RequestBatchPlan()
+    current: List[T] = []
+
+    def flush() -> None:
+        if current:
+            plan.batches.append(current.copy())
+            current.clear()
+
+    for item in items:
+        if len(current) >= max_items:
+            flush()
+
+        if not current:
+            if utf8_byte_length(serialize([item])) > max_bytes:
+                plan.oversized_items.append(item)
+            else:
+                current.append(item)
+            continue
+
+        candidate = [*current, item]
+        if utf8_byte_length(serialize(candidate)) <= max_bytes:
+            current.append(item)
+            continue
+
+        flush()
+        if utf8_byte_length(serialize([item])) > max_bytes:
+            plan.oversized_items.append(item)
+        else:
+            current.append(item)
+
+    flush()
+    return plan
+
+
+def prepend_and_bound(
+    existing: List[T],
+    earlier: List[T],
+    max_items: float,
+) -> List[T]:
+    """Prepend failed older items while dropping only newer tail items."""
+    combined = [*earlier, *existing]
+    if max_items == float("inf") or len(combined) <= max_items:
+        return combined
+    return combined[: max(0, int(max_items))]
+
+
+__all__ = [
+    "SDK_INGEST_MAX_BATCH_EVENTS",
+    "SDK_INGEST_MAX_CLIENT_BODY_BYTES",
+    "RequestBatchPlan",
+    "json_byte_length",
+    "plan_request_batches",
+    "prepend_and_bound",
+    "utf8_byte_length",
+]