Upload folder using huggingface_hub

README.md

@@ -47,6 +47,9 @@ Live Space:
   returned KEEP-only DeBERTa tokenizer labels. Receipts include
   removed-span/char totals, classifier DROP block reasons, and tool-schema
   preservation counts when `tools` or `tool_schemas` are supplied.
+  Matching `Idempotency-Key` retries replay the first in-memory response;
+  payload conflicts return HTTP 409. This is per-process memory on the Space,
+  not a durable distributed store.
   The HTTP surface accepts `Content-Encoding: gzip` request bodies and gzip
   responses for `Accept-Encoding: gzip` or gzipped requests. If an ingress
   strips the standard content-encoding header, also send

app.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
+import copy
 import gzip
 import hashlib
 import json
 import math
 import os
 import re
+import threading
 import time
 import uuid
 from functools import lru_cache
@@ -25,6 +27,8 @@ TOUCHDOWN_CONTENT_ENCODING_HEADER = "X-Touchdown-Content-Encoding"
 ACCEPT_ENCODING_HEADER = "Accept-Encoding"
 GZIP_ENCODING = "gzip"
 GZIP_MAGIC = b"\x1f\x8b"
+DEFAULT_IDEMPOTENCY_TTL_SECONDS = 24 * 60 * 60
+IDEMPOTENCY_TTL_ENV = "TOUCHDOWN_IDEMPOTENCY_TTL_SECONDS"
 LOW_SIGNAL_PATTERNS = [
     re.compile(pattern, re.IGNORECASE)
     for pattern in [
@@ -116,6 +120,10 @@ class UnsupportedContentEncoding(ValueError):
     """Raised when an HTTP request uses an unsupported content encoding."""
 
 
+_IDEMPOTENCY_LOCK = threading.Lock()
+_IDEMPOTENCY_CACHE: dict[tuple[str, str, str], dict[str, Any]] = {}
+
+
 def _content_encoding(value: str | None) -> str:
     return (value or "identity").split(";", 1)[0].strip().lower() or "identity"
 
@@ -156,6 +164,178 @@ def _should_gzip_response(
     return request_was_gzip or _accepts_gzip(accept_encoding)
 
 
+def _idempotency_ttl_seconds() -> int:
+    raw = os.environ.get(IDEMPOTENCY_TTL_ENV)
+    if raw is None:
+        return DEFAULT_IDEMPOTENCY_TTL_SECONDS
+    try:
+        parsed = int(raw)
+    except ValueError:
+        return DEFAULT_IDEMPOTENCY_TTL_SECONDS
+    return max(0, parsed)
+
+
+def _idempotency_key_from_payload(payload: dict[str, Any]) -> str | None:
+    value = payload.get("idempotency_key")
+    return value if isinstance(value, str) and value else None
+
+
+def _fingerprint_value(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {
+            key: _fingerprint_value(item)
+            for key, item in sorted(value.items())
+            if key not in {"request_id", "idempotency_key"}
+        }
+    if isinstance(value, list):
+        return [_fingerprint_value(item) for item in value]
+    return value
+
+
+def _idempotency_fingerprint(route: str, payload: dict[str, Any]) -> str:
+    encoded = json.dumps(
+        {
+            "route": route,
+            "payload": _fingerprint_value(payload),
+        },
+        ensure_ascii=False,
+        sort_keys=True,
+        separators=(",", ":"),
+    )
+    return hashlib.sha256(encoded.encode("utf-8")).hexdigest()
+
+
+def _walk_receipts(value: Any) -> list[dict[str, Any]]:
+    receipts: list[dict[str, Any]] = []
+    if isinstance(value, dict):
+        receipt = value.get("receipt")
+        if isinstance(receipt, dict):
+            receipts.append(receipt)
+        for item in value.values():
+            receipts.extend(_walk_receipts(item))
+    elif isinstance(value, list):
+        for item in value:
+            receipts.extend(_walk_receipts(item))
+    return receipts
+
+
+def _mark_idempotency(
+    body: dict[str, Any],
+    *,
+    key: str,
+    fingerprint: str,
+    replayed: bool,
+    original_request_id: str | None,
+) -> dict[str, Any]:
+    ttl_seconds = _idempotency_ttl_seconds()
+    marked = copy.deepcopy(body)
+    marked["idempotency_key"] = key
+    marked["idempotency_mode"] = "in_memory_response_replay"
+    marked["idempotency_replayed"] = replayed
+    marked["idempotency_fingerprint"] = fingerprint
+    marked["idempotency_ttl_seconds"] = ttl_seconds
+    if original_request_id:
+        marked["idempotency_original_request_id"] = original_request_id
+    for receipt in _walk_receipts(marked):
+        if receipt.get("idempotency_key") in (None, key):
+            receipt["idempotency_key"] = key
+        receipt["idempotency_mode"] = "in_memory_response_replay"
+        receipt["idempotency_replayed"] = replayed
+        receipt["idempotency_fingerprint"] = fingerprint
+        receipt["idempotency_ttl_seconds"] = ttl_seconds
+        if original_request_id:
+            receipt["idempotency_original_request_id"] = original_request_id
+    return marked
+
+
+def _cached_idempotency_body(
+    *,
+    route: str,
+    key: str,
+    fingerprint: str,
+) -> dict[str, Any] | None:
+    now = time.monotonic()
+    with _IDEMPOTENCY_LOCK:
+        expired = [
+            cache_key for cache_key, record in _IDEMPOTENCY_CACHE.items()
+            if float(record["expires_at"]) <= now
+        ]
+        for cache_key in expired:
+            _IDEMPOTENCY_CACHE.pop(cache_key, None)
+        prefix = (route, key)
+        for cache_key, record in _IDEMPOTENCY_CACHE.items():
+            if cache_key[:2] != prefix:
+                continue
+            if record["fingerprint"] != fingerprint:
+                raise HTTPException(status_code=409, detail={
+                    "schema_version": API_SCHEMA_VERSION,
+                    "status": "error",
+                    "error": "idempotency_key_reused_with_different_payload",
+                    "idempotency_key": key,
+                    "idempotency_fingerprint": fingerprint,
+                    "idempotency_existing_fingerprint": record["fingerprint"],
+                })
+            return _mark_idempotency(
+                record["body"],
+                key=key,
+                fingerprint=fingerprint,
+                replayed=True,
+                original_request_id=record.get("request_id"),
+            )
+    return None
+
+
+def _store_idempotency_body(
+    *,
+    route: str,
+    key: str,
+    fingerprint: str,
+    body: dict[str, Any],
+    request_id: str | None,
+) -> dict[str, Any]:
+    marked = _mark_idempotency(
+        body,
+        key=key,
+        fingerprint=fingerprint,
+        replayed=False,
+        original_request_id=request_id,
+    )
+    ttl_seconds = _idempotency_ttl_seconds()
+    if ttl_seconds > 0:
+        with _IDEMPOTENCY_LOCK:
+            _IDEMPOTENCY_CACHE[(route, key, fingerprint)] = {
+                "fingerprint": fingerprint,
+                "body": marked,
+                "request_id": request_id,
+                "expires_at": time.monotonic() + ttl_seconds,
+            }
+    return marked
+
+
+def _handle_compress_with_idempotency(payload: dict[str, Any]) -> dict[str, Any]:
+    key = _idempotency_key_from_payload(payload)
+    if not key:
+        return _handle_batch(payload) if "inputs" in payload else _compress_text(payload)
+    route = "/v1/compress"
+    fingerprint = _idempotency_fingerprint(route, payload)
+    cached = _cached_idempotency_body(
+        route=route,
+        key=key,
+        fingerprint=fingerprint,
+    )
+    if cached is not None:
+        return cached
+    body = _handle_batch(payload) if "inputs" in payload else _compress_text(payload)
+    request_id = payload.get("request_id") if isinstance(payload.get("request_id"), str) else None
+    return _store_idempotency_body(
+        route=route,
+        key=key,
+        fingerprint=fingerprint,
+        body=body,
+        request_id=request_id,
+    )
+
+
 async def _gzip_response_if_needed(
     request: Request,
     response: Response,
@@ -1007,6 +1187,4 @@ async def compress(request: Request) -> dict[str, Any]:
         request_id=getattr(request.state, "request_id", None),
         idempotency_key=request.headers.get(IDEMPOTENCY_KEY_HEADER),
     )
-    if "inputs" in payload:
-        return _handle_batch(payload)
-    return _compress_text(payload)
+    return _handle_compress_with_idempotency(payload)