Upload folder using huggingface_hub

README.md

@@ -29,7 +29,8 @@ Live Space:
   `/v1/compress` returned 200.
 - `/v1/classify` is tokenizer/fallback KEEP-only until a trained KEEP/DROP head
   is mounted. `/v1/compress` is rules-first deletion-only compression with
-  safety receipts.
+  safety receipts. The Space app supports both single `input` requests and
+  managed `inputs[]` batches with per-item receipts and partial-error rows.
 - Mount `classifier_manifest.json`, tokenizer files, and optional `model.onnx`;
   set `TOUCHDOWN_CLASSIFIER_ARTIFACT_DIR` to let the Space use artifact DROP
   labels through ONNX Runtime or the manifest fallback. Those labels still pass

app.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import hashlib
 import json
 import math
 import os
@@ -13,6 +14,7 @@ from fastapi import FastAPI, HTTPException
 
 CLASSIFIER_MODEL = "microsoft/deberta-v3-small"
 CLASSIFIER_ARTIFACT_DIR = os.environ.get("TOUCHDOWN_CLASSIFIER_ARTIFACT_DIR")
+API_SCHEMA_VERSION = "0.1.0"
 RULES_VERSION = "hf-space-rules-v0.1.0"
 LOW_SIGNAL_PATTERNS = [
     re.compile(pattern, re.IGNORECASE)
@@ -264,6 +266,15 @@ def _is_subsequence(candidate: str, original: str) -> bool:
     return True
 
 
+def _sha256_text(value: str) -> str:
+    return hashlib.sha256(value.encode("utf-8")).hexdigest()
+
+
+def _receipt_id(payload: dict[str, Any]) -> str:
+    encoded = json.dumps(payload, sort_keys=True, separators=(",", ":"))
+    return "tdcr_" + hashlib.sha256(encoded.encode("utf-8")).hexdigest()[:24]
+
+
 def _protected_spans(
     text: str,
     protected_values: list[str],
@@ -388,43 +399,172 @@ def _compress_text(payload: dict[str, Any]) -> dict[str, Any]:
     ) else (
         "high_confidence" if saved > 0 and aggressiveness <= 0.65 else "no_op"
     )
+    dropped_segments = [
+        {"reason": reason, "preview": preview, "start": start, "end": end}
+        for start, end, reason, preview in drops[:20]
+    ]
+    receipt = {
+        "protected_spans_checked": len(protected_values),
+        "protected_spans_missing": len(missing),
+        "code_blocks_detected": len(code_spans),
+        "code_blocks_preserved": code_preserved,
+        "json_blocks_detected": len(json_spans),
+        "json_blocks_preserved": json_preserved,
+        "system_prompt_spans_detected": len(system_spans),
+        "system_prompts_preserved": system_preserved,
+        "decision": decision,
+        "compressor_latency_ms": round((time.perf_counter() - started) * 1000.0, 3),
+        "deletion_only": _is_subsequence(output, text),
+        "deterministic": True,
+        "rules_version": RULES_VERSION,
+        "classifier": {
+            "model": CLASSIFIER_MODEL,
+            "status": classifier_status,
+            "artifact_dir_configured": bool(CLASSIFIER_ARTIFACT_DIR),
+            "artifact_dir": CLASSIFIER_ARTIFACT_DIR,
+            "error": classifier_error,
+            "labels_received": len(classifier_labels),
+            "drop_labels": classifier_drop_labels,
+            "drop_spans_applied": classifier_applied,
+            "drop_spans_blocked_by_safety": classifier_blocked,
+        },
+        "dropped_segments_count": len(drops),
+        "dropped_segments": dropped_segments,
+    }
+    receipt["input_sha256"] = _sha256_text(text)
+    receipt["output_sha256"] = _sha256_text(output)
+    receipt["removed_sha256"] = _sha256_text(
+        "".join(text[start:end] for start, end in drop_ranges)
+    )
+    receipt["receipt_id"] = _receipt_id({
+        "input_sha256": receipt["input_sha256"],
+        "output_sha256": receipt["output_sha256"],
+        "removed_sha256": receipt["removed_sha256"],
+        "tokens_saved": saved,
+        "compression_percentage": round(100.0 * saved / before, 1),
+        "decision": decision,
+        "rules_version": RULES_VERSION,
+        "classifier": receipt["classifier"],
+        "dropped_segments": dropped_segments,
+    })
     return {
+        "schema_version": API_SCHEMA_VERSION,
+        "status": "ok",
+        "endpoint": "/v1/compress",
+        "maturity": "measurement_only",
         "output": output,
         "original_input_tokens": before,
         "output_tokens": after,
         "tokens_saved": saved,
         "compression_percentage": round(100.0 * saved / before, 1),
-        "receipt": {
-            "protected_spans_checked": len(protected_values),
-            "protected_spans_missing": len(missing),
-            "code_blocks_detected": len(code_spans),
-            "code_blocks_preserved": code_preserved,
-            "json_blocks_detected": len(json_spans),
-            "json_blocks_preserved": json_preserved,
-            "system_prompt_spans_detected": len(system_spans),
-            "system_prompts_preserved": system_preserved,
-            "decision": decision,
-            "compressor_latency_ms": round((time.perf_counter() - started) * 1000.0, 3),
-            "deletion_only": _is_subsequence(output, text),
-            "deterministic": True,
-            "rules_version": RULES_VERSION,
-            "classifier": {
-                "model": CLASSIFIER_MODEL,
-                "status": classifier_status,
-                "artifact_dir_configured": bool(CLASSIFIER_ARTIFACT_DIR),
-                "artifact_dir": CLASSIFIER_ARTIFACT_DIR,
-                "error": classifier_error,
-                "labels_received": len(classifier_labels),
-                "drop_labels": classifier_drop_labels,
-                "drop_spans_applied": classifier_applied,
-                "drop_spans_blocked_by_safety": classifier_blocked,
-            },
-            "dropped_segments_count": len(drops),
-            "dropped_segments": [
-                {"reason": reason, "preview": preview}
-                for _, _, reason, preview in drops[:20]
-            ],
-        },
+        "receipt": receipt,
+    }
+
+
+def _merge_batch_item_payload(
+    payload: dict[str, Any],
+    item: Any,
+    index: int,
+) -> tuple[str | None, dict[str, Any]]:
+    if isinstance(item, str):
+        return None, {
+            "input": item,
+            "compression_settings": payload.get("compression_settings"),
+            "protected_spans": payload.get("protected_spans"),
+        }
+    if not isinstance(item, dict):
+        raise ValueError(f"inputs[{index}] must be a string or an object")
+
+    item_id = item.get("id")
+    if item_id is not None and not isinstance(item_id, str):
+        raise ValueError(f"inputs[{index}].id must be a string")
+    if "input" not in item:
+        raise ValueError(f"inputs[{index}].input is required")
+
+    top_settings = payload.get("compression_settings")
+    item_settings = item.get("compression_settings")
+    if top_settings is not None and not isinstance(top_settings, dict):
+        raise ValueError("compression_settings must be an object")
+    if item_settings is not None and not isinstance(item_settings, dict):
+        raise ValueError(f"inputs[{index}].compression_settings must be an object")
+    settings = {
+        **(top_settings or {}),
+        **(item_settings or {}),
+    } or None
+
+    return item_id, {
+        "input": item.get("input"),
+        "compression_settings": settings,
+        "protected_spans": item.get("protected_spans", payload.get("protected_spans")),
+    }
+
+
+def _handle_batch(payload: dict[str, Any]) -> dict[str, Any]:
+    if "input" in payload:
+        raise HTTPException(status_code=400, detail="provide either input or inputs, not both")
+    inputs = payload.get("inputs")
+    if not isinstance(inputs, list):
+        raise HTTPException(status_code=400, detail="inputs must be a list")
+    if not inputs:
+        raise HTTPException(status_code=400, detail="inputs list is empty")
+
+    results: list[dict[str, Any]] = []
+    totals = {
+        "original_input_tokens": 0,
+        "output_tokens": 0,
+        "tokens_saved": 0,
+    }
+    succeeded = 0
+    failed = 0
+    for index, item in enumerate(inputs):
+        item_result: dict[str, Any] = {"index": index}
+        if isinstance(item, dict) and isinstance(item.get("id"), str):
+            item_result["id"] = item["id"]
+        try:
+            item_id, item_payload = _merge_batch_item_payload(payload, item, index)
+            if item_id is not None:
+                item_result["id"] = item_id
+            result = _compress_text(item_payload)
+        except HTTPException as exc:
+            item_result.update({"status": "error", "error": str(exc.detail)})
+            failed += 1
+            results.append(item_result)
+            continue
+        except ValueError as exc:
+            item_result.update({"status": "error", "error": str(exc)})
+            failed += 1
+            results.append(item_result)
+            continue
+
+        item_result.update({"status": "ok", **result})
+        totals["original_input_tokens"] += int(result["original_input_tokens"])
+        totals["output_tokens"] += int(result["output_tokens"])
+        totals["tokens_saved"] += int(result["tokens_saved"])
+        succeeded += 1
+        results.append(item_result)
+
+    compression_pct = (
+        round(100.0 * totals["tokens_saved"] / totals["original_input_tokens"], 1)
+        if totals["original_input_tokens"]
+        else 0.0
+    )
+    receipt_ids = [
+        result["receipt"]["receipt_id"]
+        for result in results
+        if result.get("status") == "ok" and result.get("receipt", {}).get("receipt_id")
+    ]
+    return {
+        "schema_version": API_SCHEMA_VERSION,
+        "status": "ok" if failed == 0 else "partial_error",
+        "endpoint": "/v1/compress",
+        "maturity": "measurement_only",
+        "input_count": len(inputs),
+        "succeeded": succeeded,
+        "failed": failed,
+        **totals,
+        "compression_percentage": compression_pct,
+        "receipt_ids": receipt_ids,
+        "results": results,
     }
 
 
@@ -501,4 +641,6 @@ def classify(payload: dict[str, Any]) -> dict[str, Any]:
 
 @app.post("/v1/compress")
 def compress(payload: dict[str, Any]) -> dict[str, Any]:
+    if "inputs" in payload:
+        return _handle_batch(payload)
     return _compress_text(payload)