feat: switch to huggingface hub data

app.py

@@ -1,66 +1,138 @@
 import os
+import tempfile
 from datetime import datetime
+from pathlib import Path
 
 import gradio as gr
 import pandas as pd
+from huggingface_hub import HfApi, HfHubError, hf_hub_download
+
+# ------------------------------------------------------------
+# Cloud‑friendly Q/A preference rater for **Hugging Face Spaces**
+# ------------------------------------------------------------
+# This version swaps local CSV persistence for a tiny remote‑dataset
+# workflow that works on Spaces:
+#   • Ratings are stored in (and loaded from) a lightweight **dataset
+#     repo** on the Hugging Face Hub – no local file system required.
+#   • The dataset repo is set via the `RATINGS_REPO` env‑var.
+#   • You must pass a write‑enabled token (env‑var `HF_TOKEN`) that has
+#     `write` permission on that dataset.
+#
+# Quick setup guide
+# -----------------
+# 1.  Create a dataset repository to hold the ratings file, e.g.:
+#       https://huggingface.co/datasets/<org>/qa‑rater‑data
+# 2.  Inside **Space Settings ▸ Secrets**, add:
+#       • `RATINGS_REPO`  →  <org>/qa‑rater‑data
+#       • `HF_TOKEN`      →  a token with *Write* access to that repo
+# 3.  Add `huggingface‑hub` to your `requirements.txt` or
+#     `pip install huggingface‑hub` locally.
+# 4.  Deploy / push your updated Space – ratings will now persist in
+#     the dataset repo instead of the Space’s ephemeral storage.
+# ------------------------------------------------------------
+
 
 # -----------------------------------------------------------------------------
-# Configuration – adjust these paths to point at your data location
+# Configuration – constants & styling
 # -----------------------------------------------------------------------------
-DATA_PATH = "human_judgement/selected_samples.json"  # CSV with columns: question, answer1, answer2
-RATINGS_PATH = (
-    "human_judgement/human_judgement.csv"  # File where user ratings will be appended
-)
+DATA_PATH = "human_judgement/selected_samples.json"
+RATINGS_FILE = "human_judgement/human_judgement.csv"  # Name *inside* the dataset repo
+RATINGS_REPO = os.getenv("RATINGS_REPO")  # e.g. "org/qa‑rater‑data"
+HF_TOKEN = os.getenv("HF_TOKEN")  # write token for that repo
+MAX_HEIGHT_PX = 400  # Max visible height for answer Markdown blocks
+
+api = HfApi(token=HF_TOKEN) if HF_TOKEN else None
 
 # -----------------------------------------------------------------------------
-# Helper functions
+# Helper functions – data I/O
 # -----------------------------------------------------------------------------
 
 
 def load_data(path: str = DATA_PATH) -> pd.DataFrame:
-    """Load the Q/A pairs once and cache them inside gradio runtime."""
+    """Local read for the static Q/A CSV bundled with the Space repo."""
     if not os.path.exists(path):
-        raise FileNotFoundError(f"Could not find data file at {path}.")
+        raise FileNotFoundError(
+            f"Could not find data file at {path} – did you upload it?"
+        )
     df = pd.read_json(path, lines=True)
-    expected_cols = {"question", "response1", "response2"}
-    if not expected_cols.issubset(df.columns):
-        raise ValueError(f"CSV file must contain columns: {', '.join(expected_cols)}")
+    required = {"question", "response1", "response2"}
+    if not required.issubset(df.columns):
+        raise ValueError(f"CSV must contain columns: {', '.join(required)}")
     return df
 
 
-def load_ratings(path: str = RATINGS_PATH) -> pd.DataFrame:
-    """Load the ratings file (creates an empty one if absent)."""
-    if os.path.exists(path):
-        return pd.read_csv(path)
+# ---------- Rating persistence helpers ---------------------------------------
+
+
+def _download_remote_ratings() -> Path | None:
+    """Try to fetch the current ratings file from the Hub; returns path or None."""
+    if not RATINGS_REPO:
+        return None
+    try:
+        return Path(
+            hf_hub_download(
+                repo_id=RATINGS_REPO,
+                filename=RATINGS_FILE,
+                repo_type="dataset",
+                token=HF_TOKEN,
+                cache_dir=tempfile.gettempdir(),
+            )
+        )
+    except HfHubError:
+        # File/repo may not exist yet – caller will create empty DF.
+        return None
+
+
+def load_ratings() -> pd.DataFrame:
+    """Return ratings DataFrame from remote repo (or empty if none)."""
+    remote = _download_remote_ratings()
+    if remote and remote.exists():
+        return pd.read_csv(remote)
     return pd.DataFrame(columns=["user_id", "row_index", "choice", "timestamp"])
 
 
-def save_rating(user_id: str, row_index: int, choice: int, path: str = RATINGS_PATH):
-    """Append a single rating row to disk, avoiding accidental duplicates."""
-    ratings = load_ratings(path)
+def _upload_remote_ratings(df: pd.DataFrame):
+    """Upload CSV to the dataset repo with a commit per save."""
+    if not (RATINGS_REPO and api):
+        # Running locally (dev) – save to a temp file for inspection.
+        df.to_csv(RATINGS_FILE, index=False)
+        return
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        csv_path = Path(tmpdir) / RATINGS_FILE
+        df.to_csv(csv_path, index=False)
+        api.upload_file(
+            path_or_fileobj=str(csv_path),
+            path_in_repo=RATINGS_FILE,
+            repo_id=RATINGS_REPO,
+            repo_type="dataset",
+            commit_message="Add/Update rating",
+        )
+
 
-    # Prevent duplicate entries for the same user/question pair
+def save_rating(user_id: str, row_index: int, choice: int):
+    """Append a rating (deduplicated) and push to the Hub."""
+    ratings = load_ratings()
     duplicate = (ratings.user_id == user_id) & (ratings.row_index == row_index)
     if duplicate.any():
-        return  # already stored, nothing to do
+        return  # already stored
 
     new_entry = {
         "user_id": user_id,
         "row_index": row_index,
-        "choice": choice,  # 1 means answer1 preferred, 2 means answer2 preferred
+        "choice": choice,
         "timestamp": datetime.utcnow().isoformat(),
     }
     ratings = pd.concat([ratings, pd.DataFrame([new_entry])], ignore_index=True)
-    ratings.to_csv(path, index=False)
+    _upload_remote_ratings(ratings)
 
 
 def get_next_unrated(df: pd.DataFrame, ratings: pd.DataFrame, user_id: str):
-    """Return (row_index, question, answer1, answer2) or None if finished."""
-    rated_indices = ratings.loc[ratings.user_id == user_id, "row_index"].tolist()
-    unrated_df = df[~df.index.isin(rated_indices)]
-    if unrated_df.empty:
+    rated = ratings.loc[ratings.user_id == user_id, "row_index"].tolist()
+    unrated = df[~df.index.isin(rated)]
+    if unrated.empty:
         return None
-    row = unrated_df.iloc[0]
+    row = unrated.iloc[0]
     return row.name, row.question, row.response1, row.response2
 
 
@@ -70,25 +142,23 @@ def get_next_unrated(df: pd.DataFrame, ratings: pd.DataFrame, user_id: str):
 
 
 def start_or_resume(user_id: str, state_df):
-    """Initialise or resume a session for a given user id."""
     if not user_id.strip():
         return (
-            gr.update(visible=True),
-            gr.update(visible=False),
-            gr.update(visible=False),
+            gr.update(value=user_id, visible=True),
+            gr.update(visible=False),  # eval_col
+            gr.update(visible=False),  # submit_btn
             "",
             "",
             "",
-            "",
-            "Please enter a non‑empty identifier to begin.",
+            "",  # q, a1, a2, idx
+            "Please enter a non-empty identifier to begin.",
         )
 
     ratings = load_ratings()
     record = get_next_unrated(state_df, ratings, user_id)
     if record is None:
-        # Completed all tasks
         return (
-            gr.update(visible=True),
+            gr.update(value=user_id, visible=True),
             gr.update(visible=False),
             gr.update(visible=False),
             "",
@@ -100,10 +170,10 @@ def start_or_resume(user_id: str, state_df):
 
     idx, q, a1, a2 = record
     return (
-        gr.update(visible=True),  # keep user id input visible for reference
-        gr.update(visible=True),  # show evaluation section
-        gr.update(visible=True),  # enable submit button
-        "**" + q + "**",
+        gr.update(value=user_id, visible=True),
+        gr.update(visible=True),  # eval_col
+        gr.update(visible=True),  # submit_btn
+        q,
         a1,
         a2,
         str(idx),
@@ -112,10 +182,13 @@ def start_or_resume(user_id: str, state_df):
 
 
 def submit_preference(user_id: str, row_idx_str: str, choice: str, state_df):
-    """Handle a single preference submission and load the next question."""
     if choice not in {"answer1", "answer2"}:
-        return gr.update(
-            value="Please choose either Answer 1 or Answer 2 before submitting."
+        return (
+            "",
+            "",
+            "",
+            "",
+            "Please choose either Answer 1 or Answer 2 before submitting.",
         )
 
     row_idx = int(row_idx_str)
@@ -127,7 +200,7 @@ def submit_preference(user_id: str, row_idx_str: str, choice: str, state_df):
         return "", "", "", "", "🎉 You have evaluated every item – thank you!"
 
     idx, q, a1, a2 = record
-    return "**" + q + "**", a1, a2, str(idx), ""
+    return q, a1, a2, str(idx), ""
 
 
 # -----------------------------------------------------------------------------
@@ -138,44 +211,45 @@ def submit_preference(user_id: str, row_idx_str: str, choice: str, state_df):
 def build_demo():
     df = load_data()
 
+    # CSS to constrain very tall answers
+    overflow_css = f"""
+    <style>
+      .answerbox {{
+          max-height: {MAX_HEIGHT_PX}px;
+          overflow-y: auto;
+          white-space: pre-wrap;
+      }}
+    </style>
+    """
+
     with gr.Blocks(title="Question/Answer Preference Rater") as demo:
+        gr.HTML(overflow_css)
+
         gr.Markdown(
-            """# Q/A Preference Rater
-        Enter your identifier below to start or resume your evaluation session. For every question, select which answer you prefer. Your progress is saved automatically so you can return at any time using the **same identifier**."""
+            """# Q/A Preference Rater\nEnter your identifier below to start or resume. For every question, select which answer you prefer. Your progress is saved automatically so you can return at any time using the same identifier."""
         )
 
-        state_df = gr.State(df)  # keep dataset in memory for callbacks
+        state_df = gr.State(df)
         state_row_idx = gr.State("")
 
-        # User identifier section
-        id_input = gr.Textbox(
-            label="User Identifier", placeholder="e.g. Alice", scale=3
-        )
-        start_btn = gr.Button("Start / Resume", scale=1)
+        # Identifier input
+        id_input = gr.Textbox(label="User Identifier", placeholder="e.g. alice")
+        start_btn = gr.Button("Start / Resume")
 
-        # Feedback / status message
-        info_md = gr.Markdown("", visible=True)
+        info_md = gr.Markdown("")
 
-        # Evaluation section (initially hidden)
+        # Evaluation widgets
         with gr.Column(visible=False) as eval_col:
-            question_md = gr.Markdown("", label="Question")
+            question_md = gr.Markdown("")
             with gr.Row():
-                # answer1_box = gr.Textbox(
-                #     label="Answer\u00a01", interactive=False, lines=10
-                # )
-                # answer2_box = gr.Textbox(
-                #     label="Answer\u00a02", interactive=False, lines=10
-                # )
-                answer1_box = gr.Markdown(label="Answer 1")
-                answer2_box = gr.Markdown(label="Answer 2")
+                answer1_md = gr.Markdown(label="Answer 1", elem_classes=["answerbox"])
+                answer2_md = gr.Markdown(label="Answer 2", elem_classes=["answerbox"])
             choice_radio = gr.Radio(
-                ["answer1", "answer2"],
-                label="Which answer do you prefer?",
-                interactive=True,
+                ["answer1", "answer2"], label="Which answer do you prefer?"
             )
         submit_btn = gr.Button("Submit Preference", visible=False)
 
-        # Wire callbacks
+        # Callbacks wiring
         start_btn.click(
             fn=start_or_resume,
             inputs=[id_input, state_df],
@@ -184,8 +258,8 @@ def build_demo():
                 eval_col,
                 submit_btn,
                 question_md,
-                answer1_box,
-                answer2_box,
+                answer1_md,
+                answer2_md,
                 state_row_idx,
                 info_md,
             ],
@@ -194,12 +268,11 @@ def build_demo():
         submit_btn.click(
             fn=submit_preference,
             inputs=[id_input, state_row_idx, choice_radio, state_df],
-            outputs=[question_md, answer1_box, answer2_box, state_row_idx, info_md],
+            outputs=[question_md, answer1_md, answer2_md, state_row_idx, info_md],
         )
 
     return demo
 
 
-# if __name__ == "__main__":
-#     build_demo().launch()
-build_demo().launch()
+if __name__ == "__main__":
+    build_demo().launch()