notpixel 0.1.0__py3-none-any.whl

notpixel/__init__.py

@@ -0,0 +1,71 @@
+from .cache import AdCache, generate_cache_key
+from .client import Ads, AsyncAds
+from .compose import compose_text, format_ad_block
+from .embedding import (
+    DEFAULT_MODEL,
+    LocalEmbeddingResult,
+    generate_local_embedding,
+    get_model_info,
+    is_model_loaded,
+    preload_embedding_model,
+    unload_model,
+)
+from .mock import MOCK_ADS
+from .sanitize import sanitize_and_truncate, sha256
+from .types import (
+    AD_EXPIRATION_MS,
+    Ad,
+    AdCTA,
+    AdEmptyEvent,
+    AdEmptyReason,
+    AdErrorEvent,
+    AdFetchedEvent,
+    AdsBatchResult,
+    AnalyticsHooks,
+    CacheConfig,
+    FeedbackResponse,
+    PrefetchResult,
+    PrivacyConfig,
+    RespondResult,
+    TrackClickResponse,
+    TrackConversionResponse,
+    is_ad_expired,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "AD_EXPIRATION_MS",
+    "DEFAULT_MODEL",
+    "MOCK_ADS",
+    "Ad",
+    "AdCTA",
+    "AdCache",
+    "AdEmptyEvent",
+    "AdEmptyReason",
+    "AdErrorEvent",
+    "AdFetchedEvent",
+    "Ads",
+    "AdsBatchResult",
+    "AnalyticsHooks",
+    "AsyncAds",
+    "CacheConfig",
+    "FeedbackResponse",
+    "LocalEmbeddingResult",
+    "PrefetchResult",
+    "PrivacyConfig",
+    "RespondResult",
+    "TrackClickResponse",
+    "TrackConversionResponse",
+    "compose_text",
+    "format_ad_block",
+    "generate_cache_key",
+    "generate_local_embedding",
+    "get_model_info",
+    "is_ad_expired",
+    "is_model_loaded",
+    "preload_embedding_model",
+    "sanitize_and_truncate",
+    "sha256",
+    "unload_model",
+]

notpixel/cache.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import dataclass
+from typing import Any, Generic, TypeVar
+
+from .sanitize import sha256
+
+T = TypeVar("T")
+
+
+@dataclass
+class CacheEntry(Generic[T]):
+    value: T
+    expires_at: float
+
+
+class AdCache(Generic[T]):
+    def __init__(self, ttl_ms: int = 5 * 60 * 1000, max_size: int = 100) -> None:
+        self._cache: dict[str, CacheEntry[T]] = {}
+        self.ttl_ms = ttl_ms
+        self.max_size = max_size
+
+    def get(self, key: str) -> T | None:
+        entry = self._cache.get(key)
+        if entry is None:
+            return None
+        if time.time() * 1000 > entry.expires_at:
+            self._cache.pop(key, None)
+            return None
+        return entry.value
+
+    def set(self, key: str, value: T) -> None:
+        if len(self._cache) >= self.max_size:
+            self.cleanup()
+        if len(self._cache) >= self.max_size and self._cache:
+            oldest_key = next(iter(self._cache))
+            self._cache.pop(oldest_key, None)
+        self._cache[key] = CacheEntry(
+            value=value,
+            expires_at=time.time() * 1000 + self.ttl_ms,
+        )
+
+    def delete(self, key: str) -> bool:
+        return self._cache.pop(key, None) is not None
+
+    def clear(self) -> None:
+        self._cache.clear()
+
+    def cleanup(self) -> int:
+        now = time.time() * 1000
+        expired = [k for k, v in self._cache.items() if now > v.expires_at]
+        for k in expired:
+            self._cache.pop(k, None)
+        return len(expired)
+
+    def stats(self) -> dict[str, Any]:
+        return {
+            "size": len(self._cache),
+            "maxSize": self.max_size,
+            "ttlMs": self.ttl_ms,
+        }
+
+
+def generate_cache_key(
+    publisher_id: str | None = None,
+    input_text: str | None = None,
+    mode: str | None = None,
+    embedding: list[float] | None = None,
+    context: dict[str, Any] | None = None,
+    request_id: str | None = None,
+) -> str:
+    embedding_key = (
+        sha256(",".join(f"{n:.6f}" for n in embedding))
+        if embedding
+        else ""
+    )
+    parts = [
+        publisher_id or "",
+        mode or "standard",
+        input_text or embedding_key or "",
+    ]
+    if context and len(context) > 0:
+        sorted_ctx = sorted(context.items(), key=lambda item: item[0])
+        parts.append(sha256(json.dumps(sorted_ctx, separators=(",", ":"))))
+    else:
+        parts.append("")
+    parts.append(sha256(request_id) if request_id else "")
+    # Fixed positions distinguish context, opportunity IDs and delimiters in input.
+    return json.dumps(parts, separators=(",", ":"))