Update loader.py

loader.py

@@ -1,145 +1,56 @@
-# loader.py — robust public proxy for PRIVATE Static Space (resolve + raw, root + static, SPA dirs)
+# loader.py — Public proxy loader for private static Hugging Face Space
 import os
-import mimetypes
-from urllib.parse import urljoin
-from typing import Optional, Tuple
-
 from fastapi import FastAPI, Request
-from fastapi.responses import Response, HTMLResponse, PlainTextResponse, JSONResponse
+from fastapi.responses import Response, HTMLResponse, PlainTextResponse
 import httpx
 
 app = FastAPI()
 
-# ==== Config from Secrets ====
-SPACE_ID = os.getenv("PRIVATE_SPACE_ID")          # e.g. "cheekeong2025/iip-grading"
-HF_TOKEN = os.getenv("HF_TOKEN")                  # must have read access
-REVISION = os.getenv("REVISION", "main")          # branch/tag/commit (defaults to main)
-# =============================
+# ========= CONFIG =========
+PRIVATE_SPACE_ID = os.getenv("PRIVATE_SPACE_ID")
+HF_TOKEN = os.getenv("HF_TOKEN")
 
-if not SPACE_ID:
+if not PRIVATE_SPACE_ID:
     raise RuntimeError(
-        "PRIVATE_SPACE_ID is not set. Add it in Settings → Repository secrets (e.g. 'cheekeong2025/iip-grading')."
+        "❌ PRIVATE_SPACE_ID is not set.\n"
+        "Go to your Hugging Face Space → Settings → Repository secrets\n"
+        "and add PRIVATE_SPACE_ID=cheekeong2025/iip-grading"
     )
-if not HF_TOKEN:
-    raise RuntimeError("HF_TOKEN is not set. Add a token with READ access to the private Space.")
-
-HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"}
-BASE_RESOLVE = f"https://huggingface.co/spaces/{SPACE_ID}/resolve/{REVISION}/"
-BASE_RAW     = f"https://huggingface.co/spaces/{SPACE_ID}/raw/{REVISION}/"
-
-def join(base: str, path: str) -> str:
-    return urljoin(base, path.lstrip("/"))
-
-def with_query(url: str, request: Request) -> str:
-    q = str(request.url.query or "")
-    return f"{url}?{q}" if q else url
-
-def looks_like_file(path: str) -> bool:
-    return "." in path.split("/")[-1]
-
-def guess_mime(path: str, default: str = "application/octet-stream") -> str:
-    if path.endswith("/") or path == "":
-        return "text/html; charset=utf-8"
-    mime, _ = mimetypes.guess_type(path)
-    return mime or default
-
-async def try_get(client: httpx.AsyncClient, url: str) -> httpx.Response:
-    r = await client.get(url, headers=HEADERS)
-    print(f"[proxy] GET {url} -> {r.status_code}")
-    return r
-
-async def fetch_variants(client: httpx.AsyncClient, path: str, request: Request) -> Tuple[httpx.Response, str]:
-    """
-    Try variants in this order (stop at first 200):
-      resolve:path
-      resolve:static/path
-      if dir → resolve:path/index.html
-      if dir → resolve:static/path/index.html
-      raw:path
-      raw:static/path
-      if dir → raw:path/index.html
-      if dir → raw:static/path/index.html
-    Returns (response, tried_description)
-    """
-    as_dir = not looks_like_file(path)
-    variants = []
-
-    # resolve
-    variants.append(("resolve", join(BASE_RESOLVE, path)))
-    variants.append(("resolve", join(BASE_RESOLVE, f"static/{path.lstrip('/')}")))
-    if as_dir:
-        variants.append(("resolve", join(BASE_RESOLVE, path.rstrip("/") + "/index.html")))
-        variants.append(("resolve", join(BASE_RESOLVE, f"static/{path.rstrip('/')}/index.html")))
-
-    # raw
-    variants.append(("raw", join(BASE_RAW, path)))
-    variants.append(("raw", join(BASE_RAW, f"static/{path.lstrip('/')}")))
-    if as_dir:
-        variants.append(("raw", join(BASE_RAW, path.rstrip("/") + "/index.html")))
-        variants.append(("raw", join(BASE_RAW, f"static/{path.rstrip('/')}/index.html")))
-
-    last = None
-    tried = []
-    for kind, base_url in variants:
-        url = with_query(base_url, request)
-        r = await try_get(client, url)
-        tried.append(f"{kind}:{base_url}")
-        if r.status_code == 200:
-            return r, " -> ".join(tried)
-        last = r
 
-    # nothing 200; return last attempt (or 404-ish) and the tried list for debug
-    return last, " -> ".join(tried)
+if not HF_TOKEN:
+    print("[loader] ⚠️  Warning: HF_TOKEN not set — attempting anonymous access.")
 
-@app.get("/health")
-async def health():
-    return {"status": "ok", "space": SPACE_ID, "revision": REVISION, "source": "resolve/raw"}
+HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"} if HF_TOKEN else {}
+# ===========================
 
-@app.get("/_debug/fetch/{path:path}")
-async def debug_fetch(path: str, request: Request):
-    """Manual debugging endpoint to see the exact chain we try and the final status."""
-    try:
-        async with httpx.AsyncClient(timeout=None, follow_redirects=True) as client:
-            r, tried = await fetch_variants(client, path, request)
-        return JSONResponse({"status": r.status_code, "content_type": r.headers.get("content-type"), "tried": tried})
-    except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=500)
 
 @app.get("/")
-async def root(request: Request):
-    """
-    Serve index.html robustly:
-      - Try index.html (resolve/raw, root/static)
-      - If that fails, try repo root as a last resort
-    """
-    try:
-        async with httpx.AsyncClient(timeout=None, follow_redirects=True) as client:
-            r, tried = await fetch_variants(client, "index.html", request)
-            if r.status_code == 404:
-                r, tried2 = await fetch_variants(client, "", request)
-                tried += " || " + tried2
-    except Exception as e:
-        return PlainTextResponse(f"Error fetching root: {e}", status_code=500)
+async def root():
+    """Serve the index.html from the private static Space."""
+    async with httpx.AsyncClient(timeout=None) as client:
+        try:
+            r = await client.get(PRIVATE_STATIC_URL, headers=HEADERS)
+            r.raise_for_status()
+        except Exception as e:
+            return PlainTextResponse(f"Error fetching root: {e}", status_code=500)
+    return HTMLResponse(r.text, status_code=r.status_code)
 
-    ctype = r.headers.get("content-type", "text/html; charset=utf-8")
-    print(f"[root] final status={r.status_code}, ctype={ctype}")
-    # If HTML, decode text; else serve bytes
-    if "text/html" in ctype:
-        return HTMLResponse(r.text, status_code=r.status_code, media_type=ctype)
-    return Response(content=r.content, status_code=r.status_code, media_type=ctype)
 
 @app.get("/{path:path}")
 async def proxy(path: str, request: Request):
-    """
-    Proxy all assets (CSS, JS, images, fonts, SPA routes).
-    Tries resolve + raw, root + static, and directory index.html fallbacks.
-    """
+    """Proxy all static assets (CSS, JS, images, etc.) from the private Space."""
+    url = f"{PRIVATE_STATIC_URL.rstrip('/')}/{path}"
     try:
-        async with httpx.AsyncClient(timeout=None, follow_redirects=True) as client:
-            r, tried = await fetch_variants(client, path, request)
+        async with httpx.AsyncClient(timeout=None) as client:
+            r = await client.get(url, headers=HEADERS)
+            r.raise_for_status()
     except Exception as e:
-        return PlainTextResponse(f"Error fetching {path}: {e}", status_code=500)
+        return PlainTextResponse(f"Error fetching {url}: {e}", status_code=500)
+
+    content_type = r.headers.get("content-type", "text/plain")
+    return Response(content=r.content, media_type=content_type, status_code=r.status_code)
+
 
-    ctype = r.headers.get("content-type") or guess_mime(path)
-    print(f"[proxy] path={path} final status={r.status_code}, ctype={ctype}")
-    return Response(content=r.content, media_type=ctype, status_code=r.status_code)
+@app.get("/health")
+async def health():
+    return {"status": "ok", "source": PRIVATE_STATIC_URL}