Update loader.py

loader.py

@@ -1,11 +1,11 @@
-# loader.py — robust public proxy for PRIVATE Static Space using huggingface.co/resolve
+# loader.py — robust public proxy for PRIVATE Static Space (resolve + raw, root + static, SPA dirs)
 import os
 import mimetypes
 from urllib.parse import urljoin
-from typing import Optional
+from typing import Optional, Tuple
 
 from fastapi import FastAPI, Request
-from fastapi.responses import Response, HTMLResponse, PlainTextResponse
+from fastapi.responses import Response, HTMLResponse, PlainTextResponse, JSONResponse
 import httpx
 
 app = FastAPI()
@@ -13,7 +13,7 @@ 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")          # optional: pin branch/tag/commit
+REVISION = os.getenv("REVISION", "main")          # branch/tag/commit (defaults to main)
 # =============================
 
 if not SPACE_ID:
@@ -21,22 +21,20 @@ if not SPACE_ID:
         "PRIVATE_SPACE_ID is not set. Add it in Settings → Repository secrets (e.g. 'cheekeong2025/iip-grading')."
     )
 if not HF_TOKEN:
-    raise RuntimeError(
-        "HF_TOKEN is not set. Add a token with READ access to the private Space."
-    )
+    raise RuntimeError("HF_TOKEN is not set. Add a token with READ access to the private Space.")
 
-BASE_RESOLVE = f"https://huggingface.co/spaces/{SPACE_ID}/resolve/{REVISION}/"
 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 build(url_base: str, path: str) -> str:
-    return urljoin(url_base, path.lstrip("/"))
+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:
-    # crude but effective: treat last segment with a dot as a file
     return "." in path.split("/")[-1]
 
 def guess_mime(path: str, default: str = "application/octet-stream") -> str:
@@ -45,65 +43,87 @@ def guess_mime(path: str, default: str = "application/octet-stream") -> str:
     mime, _ = mimetypes.guess_type(path)
     return mime or default
 
-async def fetch(client: httpx.AsyncClient, path: str, request: Request) -> httpx.Response:
+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 multiple resolve locations:
-      1) path
-      2) static/path
-      3) if directory: path/index.html
-      4) if directory: static/path/index.html
+    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)
     """
-    # 1) as-is
-    url = with_query(build(BASE_RESOLVE, path), request)
-    r = await client.get(url, headers=HEADERS)
-    if r.status_code == 200:
-        return r
-
-    # 2) static/<path>
-    url_static = with_query(build(BASE_RESOLVE, f"static/{path.lstrip('/')}"), request)
-    r2 = await client.get(url_static, headers=HEADERS)
-    if r2.status_code == 200:
-        return r2
-
-    # If it doesn't look like a file, try directory index.html in both places
-    if not looks_like_file(path):
-        # 3) path/index.html
-        url_dir = with_query(build(BASE_RESOLVE, path.rstrip("/") + "/index.html"), request)
-        r3 = await client.get(url_dir, headers=HEADERS)
-        if r3.status_code == 200:
-            return r3
-
-        # 4) static/path/index.html
-        url_dir_static = with_query(build(BASE_RESOLVE, f"static/{path.rstrip('/')}/index.html"), request)
-        r4 = await client.get(url_dir_static, headers=HEADERS)
-        if r4.status_code == 200:
-            return r4
-
-    # Return the "best" (most recent) response even if 404, so caller can show message
-    return r2 if r2.status_code != 404 else r
+    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)
 
 @app.get("/health")
 async def health():
-    return {"status": "ok", "space": SPACE_ID, "revision": REVISION, "source": "huggingface.co/resolve"}
+    return {"status": "ok", "space": SPACE_ID, "revision": REVISION, "source": "resolve/raw"}
+
+@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
-      - Try /static/index.html
-      - As a last resort, try repo root (may 404)
+      - 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 = await fetch(client, "index.html", request)
+            r, tried = await fetch_variants(client, "index.html", request)
             if r.status_code == 404:
-                r = await fetch(client, "", request)  # fallback
+                r, tried2 = await fetch_variants(client, "", request)
+                tried += " || " + tried2
     except Exception as e:
         return PlainTextResponse(f"Error fetching root: {e}", status_code=500)
 
     ctype = r.headers.get("content-type", "text/html; charset=utf-8")
-    # If HTML, return text; else raw bytes
+    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)
@@ -112,13 +132,14 @@ async def root(request: Request):
 async def proxy(path: str, request: Request):
     """
     Proxy all assets (CSS, JS, images, fonts, SPA routes).
-    Tries root, then static/, and directory index.html fallbacks.
+    Tries resolve + raw, root + static, and directory index.html fallbacks.
     """
     try:
         async with httpx.AsyncClient(timeout=None, follow_redirects=True) as client:
-            r = await fetch(client, path, request)
+            r, tried = await fetch_variants(client, path, request)
     except Exception as e:
         return PlainTextResponse(f"Error fetching {path}: {e}", status_code=500)
 
     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)