Upload folder using huggingface_hub

README.md

@@ -31,9 +31,9 @@ Live Space:
   prompts. Use `hf spaces info wchen22/touchdown-compression-classifier --format
   json` for the current repo/runtime SHA.
 - Live smoke:
-  `python3 scripts/smoke_compression_api.py --base-url https://wchen22-touchdown-compression-classifier.hf.space --include-classify --include-batch`
+  `python3 scripts/smoke_compression_api.py --base-url https://wchen22-touchdown-compression-classifier.hf.space --include-classify --include-batch --include-gzip`
   validates `/health`, `/v1/classify`, single `/v1/compress`, and managed
-  `inputs[]` batch.
+  `inputs[]` batch, plus gzipped JSON request/response transport.
 - Full deployment receipt:
   `python3 scripts/verify_compression_space.py --expected-sha <sha> --out reports/generated/compression_space/hf_space_verification.json`
   validates HF runtime metadata, repo/runtime SHA agreement, API smoke, and
@@ -46,6 +46,8 @@ Live Space:
   and `/v1/classify` 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.
+  The HTTP surface accepts `Content-Encoding: gzip` request bodies and gzip
+  responses for `Accept-Encoding: gzip` or gzipped requests.
 - `/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. The Space app supports both single `input` requests and

app.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import gzip
 import hashlib
 import json
 import math
@@ -11,7 +12,7 @@ from functools import lru_cache
 from pathlib import Path
 from typing import Any
 
-from fastapi import FastAPI, HTTPException, Request
+from fastapi import FastAPI, HTTPException, Request, Response
 
 CLASSIFIER_MODEL = "microsoft/deberta-v3-small"
 CLASSIFIER_ARTIFACT_DIR = os.environ.get("TOUCHDOWN_CLASSIFIER_ARTIFACT_DIR")
@@ -19,6 +20,9 @@ API_SCHEMA_VERSION = "0.1.0"
 RULES_VERSION = "hf-space-rules-v0.1.0"
 REQUEST_ID_HEADER = "X-Request-ID"
 IDEMPOTENCY_KEY_HEADER = "Idempotency-Key"
+CONTENT_ENCODING_HEADER = "Content-Encoding"
+ACCEPT_ENCODING_HEADER = "Accept-Encoding"
+GZIP_ENCODING = "gzip"
 LOW_SIGNAL_PATTERNS = [
     re.compile(pattern, re.IGNORECASE)
     for pattern in [
@@ -35,12 +39,129 @@ app = FastAPI(title="Touchdown Compression Classifier", version="0.1.0")
 
 
 @app.middleware("http")
-async def request_id_middleware(request: Request, call_next):
+async def transport_middleware(request: Request, call_next):
     request_id = request.headers.get(REQUEST_ID_HEADER) or f"tdreq_{uuid.uuid4().hex}"
+    try:
+        body, request_was_gzip = _decode_request_body(
+            await request.body(),
+            request.headers.get(CONTENT_ENCODING_HEADER),
+        )
+    except UnsupportedContentEncoding as exc:
+        response = Response(
+            content=json.dumps({
+                "status": "error",
+                "error": str(exc),
+                "request_id": request_id,
+            }),
+            status_code=415,
+            media_type="application/json",
+            headers={REQUEST_ID_HEADER: request_id},
+        )
+        return await _gzip_response_if_needed(
+            request,
+            response,
+            request_was_gzip=False,
+        )
+    except ValueError as exc:
+        response = Response(
+            content=json.dumps({
+                "status": "error",
+                "error": str(exc),
+                "request_id": request_id,
+            }),
+            status_code=400,
+            media_type="application/json",
+            headers={REQUEST_ID_HEADER: request_id},
+        )
+        return await _gzip_response_if_needed(
+            request,
+            response,
+            request_was_gzip=False,
+        )
+
+    async def receive() -> dict[str, Any]:
+        return {"type": "http.request", "body": body, "more_body": False}
+
+    request = Request(request.scope, receive)
     request.state.request_id = request_id
     response = await call_next(request)
     response.headers[REQUEST_ID_HEADER] = request_id
-    return response
+    return await _gzip_response_if_needed(
+        request,
+        response,
+        request_was_gzip=request_was_gzip,
+    )
+
+
+class UnsupportedContentEncoding(ValueError):
+    """Raised when an HTTP request uses an unsupported content encoding."""
+
+
+def _content_encoding(value: str | None) -> str:
+    return (value or "identity").split(";", 1)[0].strip().lower() or "identity"
+
+
+def _decode_request_body(raw: bytes, content_encoding: str | None) -> tuple[bytes, bool]:
+    encoding = _content_encoding(content_encoding)
+    if encoding == "identity":
+        return raw, False
+    if encoding != GZIP_ENCODING:
+        raise UnsupportedContentEncoding(
+            f"unsupported content encoding: {content_encoding}"
+        )
+    try:
+        return gzip.decompress(raw), True
+    except OSError as exc:
+        raise ValueError("invalid gzip request body") from exc
+
+
+def _accepts_gzip(accept_encoding: str | None) -> bool:
+    for part in (accept_encoding or "").split(","):
+        normalized = part.replace(" ", "").lower()
+        token = normalized.split(";", 1)[0]
+        if token in (GZIP_ENCODING, "*") and "q=0" not in normalized:
+            return True
+    return False
+
+
+def _should_gzip_response(
+    *,
+    accept_encoding: str | None,
+    request_was_gzip: bool,
+) -> bool:
+    return request_was_gzip or _accepts_gzip(accept_encoding)
+
+
+async def _gzip_response_if_needed(
+    request: Request,
+    response: Response,
+    *,
+    request_was_gzip: bool,
+) -> Response:
+    should_gzip = _should_gzip_response(
+        accept_encoding=request.headers.get(ACCEPT_ENCODING_HEADER),
+        request_was_gzip=request_was_gzip,
+    )
+    if not should_gzip or response.headers.get(CONTENT_ENCODING_HEADER):
+        return response
+
+    if hasattr(response, "body_iterator"):
+        body = b""
+        async for chunk in response.body_iterator:
+            body += chunk
+    else:
+        body = getattr(response, "body", b"")
+    compressed = gzip.compress(body)
+    headers = dict(response.headers)
+    headers[CONTENT_ENCODING_HEADER] = GZIP_ENCODING
+    headers["Vary"] = ACCEPT_ENCODING_HEADER
+    headers["Content-Length"] = str(len(compressed))
+    return Response(
+        content=compressed,
+        status_code=response.status_code,
+        headers=headers,
+        background=getattr(response, "background", None),
+    )
 
 
 @lru_cache(maxsize=1)
@@ -799,6 +920,12 @@ def health() -> dict[str, Any]:
         "classifier_artifact_dir_configured": bool(CLASSIFIER_ARTIFACT_DIR),
         "classifier_error": classifier_error,
         "phase": "rules_api_first",
+        "transport": {
+            "request_id_header": REQUEST_ID_HEADER,
+            "idempotency_key_header": IDEMPOTENCY_KEY_HEADER,
+            "gzip_request_bodies": True,
+            "gzip_responses": True,
+        },
     }