Update app.py

app.py

@@ -13,6 +13,14 @@ Backing repos (private, read with the ``HF_TOKEN`` Space secret):
 Access control: the Space is public, but generation requires signing in with
 Hugging Face and being on the allowlist (the ``ALLOWLIST`` Space variable, a
 comma-separated list of usernames).
+
+Programmatic access (gradio_client / the MovetsaDataset loading script):
+  - named API endpoint ``/generate`` with the 5 inputs below, in this order:
+        window_size, overlap, normalize, include_baselines, include_familiarization
+  - identity is injected by Gradio: in the browser via ``gr.OAuthProfile``;
+    over the API via ``gr.OAuthToken`` (resolved with ``whoami``). Callers just
+    pass ``hf_token=...`` to ``gradio_client.Client(...)``.
+  - requires ``hf_oauth: true`` in the Space README front-matter.
 """
 
 import os
@@ -20,7 +28,7 @@ import sys
 import tempfile
 
 import gradio as gr
-from huggingface_hub import snapshot_download
+from huggingface_hub import snapshot_download, whoami
 
 TOKEN = os.environ.get("HF_TOKEN")
 CODE_REPO = os.environ.get("CODE_REPO", "thbndi/MoveTSA")
@@ -35,6 +43,12 @@ ALLOWLIST = {
     if u.strip()
 }
 
+# Optional server-side cache: identical parameters reuse the same parquet
+# instead of re-running the (heavy) pipeline. Keyed on ALL five parameters.
+CACHE_DIR = os.environ.get("MOVETSA_CACHE",
+                           os.path.join(tempfile.gettempdir(), "movetsa_out"))
+os.makedirs(CACHE_DIR, exist_ok=True)
+
 # ----------------------------------------------------------------- startup
 # 1) Pipeline code → importable as the `MoveTSA` package (cwd on sys.path).
 snapshot_download(CODE_REPO, repo_type="dataset", token=TOKEN,
@@ -48,34 +62,73 @@ RAW_DIR = snapshot_download(RAW_REPO, repo_type="dataset", token=TOKEN,
 from MoveTSA.export_hf_dataset import build_windows  # noqa: E402  (needs sys.path)
 
 
+def _resolve_username(profile, oauth_token):
+    """Identity from the browser OAuth profile, or from an API token."""
+    if profile is not None:
+        return profile.username
+    if oauth_token is not None and getattr(oauth_token, "token", None):
+        try:
+            return whoami(token=oauth_token.token).get("name")
+        except Exception:  # noqa: BLE001
+            return None
+    return None
+
+
 def generate(window_size, overlap, normalize, include_baselines,
-             include_familiarization, profile: gr.OAuthProfile | None):
-    """Run the pipeline with the chosen parameters and return a parquet file."""
-    if profile is None:
+             include_familiarization,
+             profile: gr.OAuthProfile | None = None,
+             oauth_token: gr.OAuthToken | None = None):
+    """Run the pipeline with the chosen parameters and return a parquet file.
+
+    ``profile`` (browser) and ``oauth_token`` (API) are injected by Gradio and
+    are NOT part of the API signature — the named endpoint only exposes the 5
+    parameters above.
+    """
+    username = _resolve_username(profile, oauth_token)
+    if username is None:
         return None, "Sign in with your Hugging Face account to generate."
-    if profile.username.lower() not in ALLOWLIST:
+    if username.lower() not in ALLOWLIST:
         return None, (
-            f"Access not granted for **@{profile.username}**.\n\n"
+            f"Access not granted for **@{username}**.\n\n"
             f"Request access from **@{OWNER}** (to be added to the allowlist)."
         )
 
+    # --- validate parameters (API callers are not bound by the sliders) ---
+    try:
+        ws = int(window_size)
+        ov = float(overlap)
+    except (TypeError, ValueError):
+        return None, "Invalid parameters."
+    if not (15 <= ws <= 180):
+        return None, "window_size must be between 15 and 180 s."
+    if not (0.0 <= ov <= 0.9):
+        return None, "overlap must be between 0 and 0.9."
+    if normalize not in ("zscore", "center", "none"):
+        return None, "normalize must be 'zscore', 'center' or 'none'."
+    include_baselines = bool(include_baselines)
+    include_familiarization = bool(include_familiarization)
+
+    # Stable filename = also the cache key (now includes the B/F flags).
+    fname = (f"movetsa_w{ws}_ov{int(ov * 100)}_{normalize}"
+             f"_b{int(include_baselines)}_f{int(include_familiarization)}.parquet")
+    cached = os.path.join(CACHE_DIR, fname)
+    if os.path.exists(cached):
+        return cached, f"Served from cache — `{fname}`"
+
     df = build_windows(
         RAW_DIR,
-        window_size=int(window_size),
-        window_overlap=float(overlap),
+        window_size=ws,
+        window_overlap=ov,
         normalize=(None if normalize == "none" else normalize),
-        include_baselines=bool(include_baselines),
-        include_familiarization=bool(include_familiarization),
+        include_baselines=include_baselines,
+        include_familiarization=include_familiarization,
         verbose=False,
     )
 
-    fname = (f"movetsa_w{int(window_size)}_ov{int(float(overlap) * 100)}"
-             f"_{normalize}.parquet")
-    out = os.path.join(tempfile.mkdtemp(), fname)
-    df.to_parquet(out, index=False)
+    df.to_parquet(cached, index=False)
     msg = (f"**{len(df)} windows × {df.shape[1]} columns** "
            f"({df['subject'].nunique()} subjects) — `{fname}`")
-    return out, msg
+    return cached, msg
 
 
 with gr.Blocks(title="MoveTSA dataset builder") as demo:
@@ -108,7 +161,8 @@ with gr.Blocks(title="MoveTSA dataset builder") as demo:
         inputs=[window_size, overlap, normalize, include_baselines,
                 include_familiarization],
         outputs=[out_file, status],
+        api_name="generate",   # => client.predict(..., api_name="/generate")
     )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()