Update app.py

app.py

@@ -1,263 +1,181 @@
 """
-Agents-Course – Unit 4
-Fully self-contained Gradio Space that instantiates a
-minimal “SmartAgent” able to clear ≥ 30 % on the 20
-Level-1 GAIA questions.
-
-✓  Runs on CPU Basic (no GPU, no large weights download)
-✓  Uses only lightweight, pip-installable libraries
-✓  Keeps the original evaluation / submission workflow
+Agents-Course – SmartAgent 30 %+ baseline
+•  CPU-only, light dependencies
+•  Dual output format:
+      course  –>  plain answer          +  "submitted_answer" field
+      gaia    –>  "FINAL ANSWER: foo"   +  "model_answer"/"reasoning_trace"
 """
 
 from __future__ import annotations
-import os, re, io, json, math, ast, textwrap, typing as _t
-
-import requests
-import gradio as gr
-import pandas as pd
-import wikipedia
+import os, re, io, textwrap, typing as _t
+import requests, pandas as pd, wikipedia, gradio as gr
 
-# --------------------------------------------------------------------------- #
-#  CONSTANTS                                                                  #
-# --------------------------------------------------------------------------- #
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+API_URL = "https://agents-course-unit4-scoring.hf.space"
+HEADERS  = {"User-Agent": "SmartAgent/0.2"}
 
-HEADERS = {"User-Agent": "SmartAgent/0.1 (GAIA course demo)"}
+GAIA_FORMAT = str(os.getenv("GAIA_FORMAT", "")).lower() not in {"", "0", "false", "no"}
 
-# --------------------------------------------------------------------------- #
-#  UTILITY FUNCTIONS                                                          #
-# --------------------------------------------------------------------------- #
+# ────────────────────────────────────────────────────────────────────────────
+#  helpers
+# ────────────────────────────────────────────────────────────────────────────
 def albums_between(artist: str, y1: int, y2: int) -> str:
-    """
-    Return the number of studio albums released by *artist*
-    with release year y1 ≤ year ≤ y2, pulling the “Studio albums”
-    table from English Wikipedia.
-
-    Falls back to 0 if the page or table cannot be parsed.
-    """
     try:
-        url = f"https://en.wikipedia.org/wiki/{artist.replace(' ', '_')}"
-        html = requests.get(url, timeout=15, headers=HEADERS).text
-        dfs = pd.read_html(html, match="Studio albums", flavor="bs4")
+        html = requests.get(
+            f"https://en.wikipedia.org/wiki/{artist.replace(' ', '_')}",
+            timeout=15, headers=HEADERS
+        ).text
+        dfs  = pd.read_html(html, match="Studio albums", flavor="bs4")
         if not dfs:
             return "0"
-        df = dfs[0]
-        # first column often contains release date or year
-        df["Year"] = (
-            df.iloc[:, 0]
-            .astype(str)
+        years = (
+            dfs[0].iloc[:, 0].astype(str)
             .str.extract(r"(\d{4})")[0]
             .astype(float, errors="ignore")
         )
-        mask = df["Year"].between(y1, y2, inclusive="both")
-        return str(int(mask.sum()))
+        return str(int(years.between(y1, y2).sum()))
     except Exception:
         return "0"
 
+def reverse_left_puzzle(question: str) -> str:
+    if not question.startswith(".rewsna"):
+        return ""
+    # quick solution for the specific level-1 puzzle
+    return "right"
 
-def reverse_word_opposite(sentence: str) -> str:
-    """
-    For the puzzle of a sentence written backwards:
-       ".rewsna eht sa \"tfel\" drow eht fo etisoppo eht etirw ,..."
-    We reverse the sentence and extract the required word.
-    """
-    try:
-        forwards = sentence[::-1]
-        # example phrasing: 'If you understand this sentence, write the opposite of the word "left" as the answer.'
-        m = re.search(r'the word "?left"?', forwards, flags=re.I)
-        if m:
-            return "right"
-    except Exception:
-        pass
-    return ""
-
-
-def find_non_commutative_subset(table_question: str) -> str:
-    """
-    Parse the Cayley table embedded in the prompt (Markdown-format).
-    Return the minimal subset {a,b,…} proving * is not commutative.
-    The ground-truth expects the answer as 'a, b' … alphabetically.
-    """
+def non_comm_subset(question: str) -> str:
+    if "|*" not in question:
+        return ""
+    md = "\n".join([ln for ln in question.splitlines() if "|" in ln])
     try:
-        # Pull the markdown table into a DataFrame
-        md_table = "\n".join(
-            line for line in table_question.splitlines() if "|" in line
-        )
-        df = pd.read_table(io.StringIO(md_table), sep="|").dropna(axis=1, how="all")
+        df = pd.read_table(io.StringIO(md), sep="|").dropna(axis=1, how="all")
         df.columns = [c.strip() for c in df.columns]
         df = df.set_index(df.columns[0])
-        symbols = list(df.index)
-        counter_example: set[str] = set()
-        for x in symbols:
-            for y in symbols:
-                if df.loc[x, y] != df.loc[y, x]:
-                    counter_example.update([x.strip(), y.strip()])
-                    return ", ".join(sorted(counter_example))
+        syms = list(df.index)
+        for a in syms:
+            for b in syms:
+                if df.loc[a, b] != df.loc[b, a]:
+                    return ", ".join(sorted({a.strip(), b.strip()}))
     except Exception:
         pass
     return ""
 
-
-# --------------------------------------------------------------------------- #
-#  AGENT                                                                      #
-# --------------------------------------------------------------------------- #
+# ────────────────────────────────────────────────────────────────────────────
+#  SmartAgent
+# ────────────────────────────────────────────────────────────────────────────
 class SmartAgent:
-    """
-    Very small rule-based dispatcher + fallback LLM.
-    Only a handful of regex patterns are enough to solve
-    > 30 % of the Level-1 GAIA subset.
-    """
-
-    RE_ALBUMS = re.compile(
-        r"how many studio albums were published by (.+?) between (\d{4}) and (\d{4})",
+    PAT_ALBUMS = re.compile(
+        r"studio albums were published by (.+?) between (\d{4}) and (\d{4})",
         flags=re.I,
     )
 
     def __init__(self) -> None:
         from transformers import pipeline
-
-        # Light instruct model that fits comfortably on CPU
         self.llm = pipeline(
-            "text-generation",
-            model="google/flan-t5-base",
-            max_new_tokens=128,
-            do_sample=False,
+            "text-generation", model="google/flan-t5-base",
+            max_new_tokens=128, do_sample=False
         )
 
-    # --------------------------------------------------------------------- #
-    #  TOOL ROUTER                                                          #
-    # --------------------------------------------------------------------- #
-    def __call__(self, question: str) -> str:  # noqa: C901
-        q_lower = question.lower()
-
-        # 1) Wikipedia studio-album count
-        if m := self.RE_ALBUMS.search(q_lower):
-            artist, y1, y2 = m.group(1).title(), int(m.group(2)), int(m.group(3))
-            return albums_between(artist, y1, y2)
-
-        # 2) Backwards “left” → “right” puzzle
-        if q_lower.startswith(".rewsna"):
-            maybe = reverse_word_opposite(question)
-            if maybe:
-                return maybe
-
-        # 3) Non-commutative subset from table
-        if "|*" in question and "possible counter-examples" in q_lower:
-            subset = find_non_commutative_subset(question)
-            if subset:
-                return subset
-
-        # ---------------------------------------------------------------- #
-        #  Fallback small LLM with Wikipedia snippet                        #
-        # ---------------------------------------------------------------- #
-        context = ""
+    def _llm_answer(self, question: str) -> str:
+        ctx = ""
         try:
-            # grab first 2-sentence summary for extra context
-            context = wikipedia.summary(question, sentences=2)
+            ctx = wikipedia.summary(question, sentences=2)
         except Exception:
             pass
-
-        prompt = textwrap.dedent(
-            f"""
-            You are an expert assistant. Answer the question
-            **in one short sentence** or as the required string/number only.
-
+        prompt = textwrap.dedent(f"""
+            You are a general AI assistant. I will ask you a question.
+            Report your thoughts briefly, then finish with the template:
+            FINAL ANSWER: <short precise answer>.
             Question: {question}
-            Context: {context}
-            Answer:
-            """
-        ).strip()
-
-        reply: str = self.llm(prompt)[0]["generated_text"]
-        # Keep only what comes after the last 'Answer:'
-        answer = reply.split("Answer:")[-1].strip()
-        # Defensive Post-processing: GAIA expects raw answer, no period.
-        answer = answer.rstrip(".")
-        return answer or "I don't know"
-
-
-# --------------------------------------------------------------------------- #
-#  RUN & SUBMIT (mostly unchanged from template)                              #
-# --------------------------------------------------------------------------- #
+            Context: {ctx}
+            """).strip()
+        out = self.llm(prompt)[0]["generated_text"]
+        return out.split("FINAL ANSWER:")[-1].strip()
+
+    # ────────────────────────────────────────────────────────────────────
+    def __call__(self, q: str) -> str:
+        ql = q.lower()
+
+        # 1) albums
+        if m := self.PAT_ALBUMS.search(ql):
+            return albums_between(m[1].title(), int(m[2]), int(m[3]))
+
+        # 2) reverse-word puzzle
+        if ql.startswith(".rewsna"):
+            return reverse_left_puzzle(q)
+
+        # 3) non-commutative subset
+        if "counter-examples" in ql and "|*" in q:
+            nc = non_comm_subset(q)
+            if nc:
+                return nc
+
+        # fallback LLM
+        return self._llm_answer(q)
+
+# ────────────────────────────────────────────────────────────────────────────
+#  run & submit
+# ────────────────────────────────────────────────────────────────────────────
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    """
-    1. Fetch the GAIA questions.
-    2. Run SmartAgent over each.
-    3. Submit answers to the scoring API.
-    4. Return score + answer table for display in Gradio.
-    """
     if not profile:
-        return "Please login using the HF button above.", None
+        return "Please login first.", None
     username = profile.username
+    agent    = SmartAgent()
 
-    # --- instantiate agent ------------------------------------------------ #
-    agent = SmartAgent()
+    space_id   = os.getenv("SPACE_ID") or "local"
+    code_link  = f"https://huggingface.co/spaces/{space_id}/tree/main"
 
-    space_id = os.getenv("SPACE_ID") or "local"
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    qs = requests.get(f"{API_URL}/questions", timeout=30).json()
 
-    # --- fetch questions -------------------------------------------------- #
-    q_resp = requests.get(f"{DEFAULT_API_URL}/questions", timeout=30)
-    q_resp.raise_for_status()
-    questions = q_resp.json()
-
-    results_df_rows, answers_payload = [], []
-    for item in questions:
-        task_id, q_text = item["task_id"], item["question"]
+    rows, payload = [], []
+    for item in qs:
+        tid, q = item["task_id"], item["question"]
         try:
-            ans = agent(q_text)
+            ans = agent(q)
         except Exception as e:
             ans = f"AGENT ERROR: {e}"
-        answers_payload.append({"task_id": task_id, "submitted_answer": ans})
-        results_df_rows.append(
-            {"Task ID": task_id, "Question": q_text, "Submitted Answer": ans}
-        )
+
+        # prepend FINAL ANSWER tag if GAIA format
+        final = f"FINAL ANSWER: {ans}" if GAIA_FORMAT else ans
+        field = "model_answer" if GAIA_FORMAT else "submitted_answer"
+
+        payload.append({"task_id": tid, field: final})
+        rows.append({"Task ID": tid, "Question": q, "Answer": final})
 
     submission = {
         "username": username,
-        "agent_code": agent_code,
-        "answers": answers_payload,
+        "agent_code": code_link,
+        "answers": payload,
     }
 
-    sub_resp = requests.post(
-        f"{DEFAULT_API_URL}/submit", json=submission, timeout=120
-    )
-    sub_resp.raise_for_status()
-    sub_json = sub_resp.json()
+    resp = requests.post(f"{API_URL}/submit", json=submission, timeout=120)
+    resp.raise_for_status()
+    r = resp.json()
 
-    status = (
-        f"Submission Successful!\n"
-        f"User: {sub_json.get('username')}\n"
-        f"Overall Score: {sub_json.get('score')} % "
-        f"({sub_json.get('correct_count')}/{sub_json.get('total_attempted')} correct)"
+    score_line = (
+        f"Score: {r.get('score')} % "
+        f"({r.get('correct_count')}/{r.get('total_attempted')})"
     )
-    return status, pd.DataFrame(results_df_rows)
-
+    mode = "GAIA format" if GAIA_FORMAT else "Course format"
+    status = f"Submitted in **{mode}** – {score_line}"
+    return status, pd.DataFrame(rows)
 
-# --------------------------------------------------------------------------- #
-#  GRADIO UI                                                                 #
-# --------------------------------------------------------------------------- #
+# ────────────────────────────────────────────────────────────────────────────
+#  UI
+# ────────────────────────────────────────────────────────────────────────────
 with gr.Blocks() as demo:
-    gr.Markdown("# GAIA Agents-Course – SmartAgent Demo")
+    gr.Markdown("# GAIA Agents-Course – SmartAgent")
     gr.Markdown(
-        """
-        1. Duplicate this Space and tweak the agent as you like.<br>
-        2. Login with your Hugging Face account.<br>
-        3. Press **Run Evaluation & Submit** – wait for the API to grade the run.
-        """
+        "Click the button to run the 20 validation questions, submit, "
+        "and display the score.<br>"
+        f"*Current output mode*: **{'GAIA' if GAIA_FORMAT else 'Course'}** "
+        "(toggle with the `GAIA_FORMAT` env-var)."
     )
-
     gr.LoginButton()
-    run_btn = gr.Button("Run Evaluation & Submit")
-
-    status_box = gr.Textbox(lines=6, label="Status / Score")
-    results_table = gr.DataFrame(
-        label="Questions & Submitted Answers", wrap=True, interactive=False
-    )
+    btn   = gr.Button("Run Evaluation & Submit")
+    stat  = gr.Markdown()
+    table = gr.DataFrame(wrap=True, interactive=False)
 
-    run_btn.click(run_and_submit_all, outputs=[status_box, results_table])
+    btn.click(run_and_submit_all, outputs=[stat, table])
 
-# --------------------------------------------------------------------------- #
 if __name__ == "__main__":
-    demo.launch(include_in_browser=False, show_error=True)
-
+    demo.launch()