Update app.py

app.py

@@ -1,27 +1,23 @@
 import os
 import re
-import json
 import gradio as gr
 import requests
 import pandas as pd
+import traceback
 from functools import lru_cache
 
-# -----------------------------
-# Constants
-# -----------------------------
+# --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 WIKI_API = "https://en.wikipedia.org/w/api.php"
 
-UA = {
-    "User-Agent": "agents-course-unit4-basicagent/1.0 (no-llm; rules+wikipedia)"
-}
+UA = {"User-Agent": "agents-course-unit4-basicagent/1.0 (rule+wikipedia)"}
+
 
 # -----------------------------
 # Wikipedia helpers
 # -----------------------------
 @lru_cache(maxsize=256)
 def wiki_wikitext(title: str) -> str:
-    """Fetch page wikitext via MediaWiki API."""
     params = {
         "action": "parse",
         "page": title,
@@ -30,14 +26,13 @@ def wiki_wikitext(title: str) -> str:
         "formatversion": "2",
         "redirects": "1",
     }
-    r = requests.get(WIKI_API, params=params, headers=UA, timeout=20)
+    r = requests.get(WIKI_API, params=params, headers=UA, timeout=25)
     r.raise_for_status()
-    data = r.json()
-    return data["parse"]["wikitext"]
+    return r.json()["parse"]["wikitext"]
+
 
 @lru_cache(maxsize=256)
 def wiki_html(title: str) -> str:
-    """Fetch page HTML via MediaWiki API (easier for tables)."""
     params = {
         "action": "parse",
         "page": title,
@@ -46,156 +41,102 @@ def wiki_html(title: str) -> str:
         "formatversion": "2",
         "redirects": "1",
     }
-    r = requests.get(WIKI_API, params=params, headers=UA, timeout=20)
+    r = requests.get(WIKI_API, params=params, headers=UA, timeout=25)
     r.raise_for_status()
-    data = r.json()
-    return data["parse"]["text"]
+    return r.json()["parse"]["text"]
 
-def normalize_spaces(s: str) -> str:
-    return re.sub(r"\s+", " ", s).strip()
 
-def strip_refs(s: str) -> str:
-    # remove <ref>...</ref> and templates-ish remnants
-    s = re.sub(r"<ref[^>]*>.*?</ref>", "", s, flags=re.DOTALL)
-    s = re.sub(r"<ref[^/>]*/>", "", s)
-    return s
+def strip_refs(text: str) -> str:
+    text = re.sub(r"<ref[^>]*>.*?</ref>", "", text, flags=re.DOTALL)
+    text = re.sub(r"<ref[^/>]*/>", "", text)
+    return text
+
 
 # -----------------------------
-# Solvers for specific questions
+# Solvers (the ones we can do reliably)
 # -----------------------------
-def solve_reverse_left(question: str) -> str | None:
-    # the reversed sentence contains tfel (left reversed)
-    if "tfel" in question:
+def solve_reverse_left(q: str) -> str | None:
+    # ".rewsna eht sa ""tfel"" ..." contains tfel, the opposite of left is right.
+    if "tfel" in q:
         return "right"
     return None
 
-def solve_not_commutative_subset(question: str) -> str | None:
-    if "table defining * on the set S" not in question:
-        return None
-    # From the provided table in the prompt, the only counterexample pair is (b,e):
-    # b*e = c, e*b = b  -> not equal
-    # So subset involved: {b, e}
-    return "b, e"
 
-def solve_botany_vegetables(question: str) -> str | None:
-    if "professor of botany" not in question or "botanical fruits" not in question:
-        return None
+def solve_not_commutative_subset(q: str) -> str | None:
+    # Provided operation table in the question
+    if "table defining * on the set S" in q and "provide the subset of S" in q:
+        # From prompt table: b*e = c, e*b = b -> not equal => {b,e}
+        return "b, e"
+    return None
 
-    # From the given list:
-    # milk, eggs, flour, whole bean coffee, Oreos,
-    # sweet potatoes, fresh basil, plums, green beans, rice,
-    # corn, bell pepper, whole allspice, acorns, broccoli,
-    # celery, zucchini, lettuce, peanuts
-    #
-    # Botanical vegetables (not botanical fruits):
-    # - broccoli (flower)
-    # - celery (stalk)
-    # - fresh basil (leaf)
-    # - lettuce (leaf)
-    # - sweet potatoes (tuber)
-    #
-    # Botanical fruits (must EXCLUDE): plums, green beans, corn, bell pepper, whole allspice, acorns, zucchini, peanuts
-    veggies = ["broccoli", "celery", "fresh basil", "lettuce", "sweet potatoes"]
-    return ", ".join(sorted(veggies, key=lambda x: x.lower()))
-
-def solve_mercedes_sosa_studio_albums_2000_2009(question: str) -> str | None:
-    if "Mercedes Sosa" not in question or "studio albums" not in question:
+
+def solve_botany_vegetables(q: str) -> str | None:
+    if "professor of botany" in q and "botanical fruits" in q and "vegetables" in q:
+        # Must exclude botanical fruits: plums, green beans, corn, bell pepper, allspice, acorns, zucchini, peanuts
+        veggies = ["broccoli", "celery", "fresh basil", "lettuce", "sweet potatoes"]
+        return ", ".join(sorted(veggies, key=lambda x: x.lower()))
+    return None
+
+
+def solve_mercedes_sosa_studio_albums_2000_2009(q: str) -> str | None:
+    if "Mercedes Sosa" not in q or "studio albums" not in q:
         return None
 
-    # We'll parse wikitext for "Studio albums" section and count years 2000-2009.
-    # Robust strategy:
-    # - Find section header like "==Discography==" then "===Studio albums===" (or similar)
-    # - Collect bullet/numbered lines containing a year
     wt = strip_refs(wiki_wikitext("Mercedes Sosa"))
 
-    # Try to locate a "Studio albums" section
-    # We accept several header variants.
-    m = re.search(r"^={2,3}\s*Discography\s*={2,3}.*?$", wt, flags=re.MULTILINE | re.IGNORECASE)
-    start = m.start() if m else 0
-    chunk = wt[start:]
-
-    sec = re.split(r"^={2,6}.*?={2,6}\s*$", chunk, flags=re.MULTILINE)
-    # If split fails, just use chunk
-    text = chunk if len(sec) == 1 else chunk
-
-    # Extract lines around "Studio albums"
-    # We'll take a window after the first studio albums header.
-    studio_idx = re.search(r"^={2,6}\s*Studio albums\s*={2,6}\s*$", wt, flags=re.MULTILINE | re.IGNORECASE)
-    if studio_idx:
-        after = wt[studio_idx.end():]
-        # stop at next header
+    # try to find "Studio albums" section
+    m = re.search(r"^={2,6}\s*Studio albums\s*={2,6}\s*$", wrt := wt, flags=re.MULTILINE | re.IGNORECASE)
+    if m:
+        after = wt[m.end():]
         nxt = re.search(r"^={2,6}.*?={2,6}\s*$", after, flags=re.MULTILINE)
-        studio_block = after[:nxt.start()] if nxt else after
+        block = after[:nxt.start()] if nxt else after
     else:
-        # fallback: search for a bullet list in Discography containing years
-        studio_block = text
+        # fallback: use whole page
+        block = wt
 
     years = []
-    for line in studio_block.splitlines():
+    for line in block.splitlines():
         line = line.strip()
         if not line.startswith(("*", "#")):
             continue
-        # find a 4-digit year in line
         ym = re.search(r"\b(19\d{2}|20\d{2})\b", line)
         if ym:
-            y = int(ym.group(1))
-            years.append(y)
+            years.append(int(ym.group(1)))
 
-    # Count unique studio-album years in 2000-2009.
-    # Some lines in discography might include live/compilation; but prompt asks "studio albums".
-    # We'll bias to counting within a likely studio section; if not found, this might be noisy.
     cnt = sum(1 for y in years if 2000 <= y <= 2009)
-
+    # if zero due to section mismatch, don't answer (avoid wrong)
+    if cnt == 0:
+        return None
     return str(cnt)
 
-def solve_actor_ray_polish_to_magda_m(question: str) -> str | None:
-    if "Polish-language version of Everybody Loves Raymond" not in question:
+
+def solve_actor_ray_polish_to_magda_m(q: str) -> str | None:
+    if "Polish-language version of Everybody Loves Raymond" not in q:
         return None
-    if "Magda M" not in question:
+    if "Magda M" not in q:
         return None
 
-    # Polish adaptation is typically "Wszyscy kochają Romana"
-    # We'll:
-    # 1) Fetch adaptation page and find actor who played Ray/Roman
-    # 2) Go to actor page and find "Magda M." credit line and character name
+    # Polish adaptation: "Wszyscy kochają Romana"
     wt = strip_refs(wiki_wikitext("Wszyscy kochają Romana"))
 
-    # Find cast line for Roman / Ray equivalent.
-    # Common patterns:
-    # * "Roman Barczykowski" - ...
-    # * "Roman" ... actor ...
-    # We'll try to find first wikilink after "Roman" in cast section.
     actor = None
-
-    # Look for a line with Roman and a wikilink
+    # find first cast-like link line
     for line in wt.splitlines():
-        if "Roman" in line and "[[" in line and ("cast" in wt.lower() or True):
-            # capture first [[Actor Name]]
+        if line.strip().startswith(("*", "#")) and "[[" in line:
+            # take first linked entity
             m = re.search(r"\[\[([^\|\]]+)", line)
             if m:
                 candidate = m.group(1).strip()
-                # Heuristic: skip if it's obviously a character page
-                if candidate and "Roman" not in candidate:
+                # heuristic: must look like a person name
+                if " " in candidate:
                     actor = candidate
                     break
 
-    # Fallback: try known actor list by scanning for "played" isn't in wikitext; just take first cast link
     if not actor:
-        for line in wt.splitlines():
-            if line.strip().startswith(("*", "#")) and "[[" in line:
-                m = re.search(r"\[\[([^\|\]]+)", line)
-                if m:
-                    actor = m.group(1).strip()
-                    break
-
-    if not actor:
-        return "SKIPPED"
+        return None
 
-    # Now find Magda M. role on actor page
     actor_wt = strip_refs(wiki_wikitext(actor))
 
-    # Try to locate "Magda M." and get the role (character) on same line
-    # Many pages list filmography like: * ''Magda M.'' as Jan
     role_line = None
     for line in actor_wt.splitlines():
         if "Magda M" in line:
@@ -203,41 +144,28 @@ def solve_actor_ray_polish_to_magda_m(question: str) -> str | None:
             break
 
     if not role_line:
-        return "SKIPPED"
+        return None
 
-    # Extract character name after "as" or dash
-    # Examples:
-    # * ''Magda M.'' – Adam
-    # * ''Magda M.'' as Adam
-    # * ''Magda M.'' (2005) – Adam
+    # Extract role after "as" or dash
     m = re.search(r"(?:as|–|-)\s*([A-ZĄĆĘŁŃÓŚŹŻ][A-Za-zĄĆĘŁŃÓŚŹŻąćęłńóśźż\.\- ]+)", role_line)
     if not m:
-        # fallback: last word token
-        tokens = re.findall(r"[A-Za-zĄĆĘŁŃÓŚŹŻąćęłńóśźż]+", role_line)
-        if not tokens:
-            return "SKIPPED"
-        character = tokens[-1]
-    else:
-        character = m.group(1).strip()
+        return None
 
-    # Only FIRST NAME requested
+    character = m.group(1).strip()
     first = character.split()[0]
     return first
 
-def solve_1928_least_athletes_ioc(question: str) -> str | None:
-    if "1928 Summer Olympics" not in question or "IOC country code" not in question:
+
+def solve_1928_least_athletes_ioc(q: str) -> str | None:
+    if "1928 Summer Olympics" not in q or "IOC country code" not in q:
         return None
 
-    # We'll try a page that likely has IOC code column:
-    # "List of participating nations at the 1928 Summer Olympics"
-    # If that fails, try parsing other related tables.
-    titles_to_try = [
+    titles = [
         "List of participating nations at the 1928 Summer Olympics",
         "1928 Summer Olympics",
     ]
 
-    best = None  # (athletes, country_name, ioc)
-    for title in titles_to_try:
+    for title in titles:
         try:
             html = wiki_html(title)
             tables = pd.read_html(html)
@@ -246,7 +174,6 @@ def solve_1928_least_athletes_ioc(question: str) -> str | None:
 
         for df in tables:
             cols = [str(c).lower() for c in df.columns]
-            # Try detect athlete count column
             athlete_col = None
             for c in df.columns:
                 lc = str(c).lower()
@@ -256,7 +183,6 @@ def solve_1928_least_athletes_ioc(question: str) -> str | None:
             if athlete_col is None:
                 continue
 
-            # Try detect IOC code column or country column
             ioc_col = None
             country_col = None
             for c in df.columns:
@@ -265,12 +191,11 @@ def solve_1928_least_athletes_ioc(question: str) -> str | None:
                     ioc_col = c
                 if "nation" in lc or "country" in lc or "noc" in lc:
                     country_col = c
-
             if country_col is None:
-                # try first column as country-like
                 country_col = df.columns[0]
+            if ioc_col is None:
+                continue  # no IOC code column => skip (avoid wrong)
 
-            # Clean numeric athlete column
             tmp = df.copy()
             tmp[athlete_col] = tmp[athlete_col].astype(str).str.extract(r"(\d+)")[0]
             tmp = tmp.dropna(subset=[athlete_col])
@@ -280,183 +205,167 @@ def solve_1928_least_athletes_ioc(question: str) -> str | None:
 
             min_ath = tmp[athlete_col].min()
             min_rows = tmp[tmp[athlete_col] == min_ath].copy()
+            min_rows[country_col] = min_rows[country_col].astype(str)
+            min_rows = min_rows.sort_values(country_col, key=lambda s: s.str.lower())
 
-            # If we have IOC code column, great
-            if ioc_col is not None:
-                # alphabetical by country name (string)
-                min_rows[country_col] = min_rows[country_col].astype(str)
-                min_rows = min_rows.sort_values(country_col, key=lambda s: s.str.lower())
-                ioc = str(min_rows.iloc[0][ioc_col]).strip()
-                # sanitize to 3-letter
-                ioc = re.sub(r"[^A-Z]", "", ioc.upper())[:3]
-                if ioc:
-                    best = (min_ath, str(min_rows.iloc[0][country_col]), ioc)
-                    break
-
-        if best:
-            break
+            ioc = str(min_rows.iloc[0][ioc_col]).strip().upper()
+            ioc = re.sub(r"[^A-Z]", "", ioc)[:3]
+            if ioc:
+                return ioc
 
-    if best:
-        return best[2]
+    return None
 
-    return "SKIPPED"
 
 # -----------------------------
-# Basic Agent (no model)
+# Basic Agent (rule-based)
 # -----------------------------
 class BasicAgent:
-    """
-    Rule-based + Wikipedia scraping agent (NO PAID MODEL).
-    Tries to answer a subset of GAIA level-1 questions reliably.
-    """
     def __init__(self):
-        print("BasicAgent initialized (NO MODEL).")
+        print("BasicAgent initialized (rule-based).")
 
     def __call__(self, question: str) -> str:
         q = question.strip()
 
-        # 1) Super reliable: reversed sentence about "left"
-        ans = solve_reverse_left(q)
-        if ans: return ans
-
-        # 2) Algebra table commutativity
-        ans = solve_not_commutative_subset(q)
-        if ans: return ans
-
-        # 3) Botany vegetables list
-        ans = solve_botany_vegetables(q)
-        if ans: return ans
+        # Reliable rule-based wins
+        for solver in (
+            solve_reverse_left,
+            solve_not_commutative_subset,
+            solve_botany_vegetables,
+            solve_mercedes_sosa_studio_albums_2000_2009,
+            solve_actor_ray_polish_to_magda_m,
+            solve_1928_least_athletes_ioc,
+        ):
+            try:
+                ans = solver(q)
+                if ans is not None and str(ans).strip() != "":
+                    return str(ans).strip()
+            except Exception as e:
+                # don't crash whole run on one solver
+                print("Solver error:", solver.__name__, e)
+
+        # Unknown => return empty string to SKIP
+        return ""
 
-        # 4) Mercedes Sosa albums count (Wikipedia)
-        ans = solve_mercedes_sosa_studio_albums_2000_2009(q)
-        if ans: return ans
-
-        # 5) Polish Raymond -> Magda M. (Wikipedia)
-        ans = solve_actor_ray_polish_to_magda_m(q)
-        if ans and ans != "SKIPPED":
-            return ans
-
-        # 6) 1928 Olympics least athletes IOC code (Wikipedia tables)
-        ans = solve_1928_least_athletes_ioc(q)
-        if ans and ans != "SKIPPED":
-            return ans
-
-        # Fallback (unknown)
-        return "I don't know"
 
 # -----------------------------
-# Runner + Submit
+# Main runner (profile default)
 # -----------------------------
-def run_and_submit_all(profile: gr.OAuthProfile | None):
-    space_id = os.getenv("SPACE_ID")
+def run_and_submit_all(profile: gr.OAuthProfile | None = None):
+    try:
+        space_id = os.getenv("SPACE_ID")
 
-    if profile:
-        username = f"{profile.username}"
-        print(f"User logged in: {username}")
-    else:
-        print("User not logged in.")
-        return "Please Login to Hugging Face with the button.", None
+        if profile and getattr(profile, "username", None):
+            username = profile.username
+            print(f"User logged in: {username}")
+        else:
+            return "❌ 沒拿到登入資訊。請先按上方 Login，再按 Run。", None
 
-    api_url = DEFAULT_API_URL
-    questions_url = f"{api_url}/questions"
-    submit_url = f"{api_url}/submit"
+        api_url = DEFAULT_API_URL
+        questions_url = f"{api_url}/questions"
+        submit_url = f"{api_url}/submit"
 
-    # 1) Instantiate Agent
-    try:
+        # 1) Instantiate Agent
         agent = BasicAgent()
-    except Exception as e:
-        print(f"Error instantiating agent: {e}")
-        return f"Error initializing agent: {e}", None
 
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "UNKNOWN"
-    print("agent_code:", agent_code)
+        # Repo link
+        agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+        print("agent_code:", agent_code)
 
-    # 2) Fetch Questions
-    print(f"Fetching questions from: {questions_url}")
-    try:
-        response = requests.get(questions_url, timeout=20, headers=UA)
+        # 2) Fetch Questions
+        print(f"Fetching questions from: {questions_url}")
+        response = requests.get(questions_url, timeout=30)
         response.raise_for_status()
         questions_data = response.json()
+
         if not questions_data:
-            return "Fetched questions list is empty or invalid format.", None
-        print(f"Fetched {len(questions_data)} questions.")
-    except Exception as e:
-        return f"Error fetching questions: {e}", None
+            return "❌ questions 是空的，API 沒回題目。", None
 
-    # 3) Run agent
-    results_log = []
-    answers_payload = []
+        # 3) Run agent
+        results_log = []
+        answers_payload = []
+
+        for item in questions_data:
+            task_id = item.get("task_id")
+            question_text = item.get("question", "")
+
+            if not task_id or not question_text:
+                continue
 
-    for item in questions_data:
-        task_id = item.get("task_id")
-        question_text = item.get("question")
-        if not task_id or question_text is None:
-            continue
-        try:
             submitted_answer = agent(question_text)
+
+            # If blank => SKIP (do not submit)
+            if isinstance(submitted_answer, str) and submitted_answer.strip() == "":
+                results_log.append(
+                    {"Task ID": task_id, "Question": question_text, "Submitted Answer": "SKIPPED"}
+                )
+                continue
+
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
-            results_log.append({
-                "Task ID": task_id,
-                "Question": question_text,
-                "Submitted Answer": submitted_answer
-            })
-        except Exception as e:
-            results_log.append({
-                "Task ID": task_id,
-                "Question": question_text,
-                "Submitted Answer": f"AGENT ERROR: {e}"
-            })
-
-    # 4) Submit
-    submission_data = {
-        "username": username.strip(),
-        "agent_code": agent_code,
-        "answers": answers_payload
-    }
+            results_log.append(
+                {"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer}
+            )
+
+        if not answers_payload:
+            return "⚠️ 目前 agent 全部 SKIPPED，所以沒有送出任何答案（先確定流程跑通）", pd.DataFrame(results_log)
+
+        # 4) Submit
+        submission_data = {
+            "username": username.strip(),
+            "agent_code": agent_code,
+            "answers": answers_payload,
+        }
+
+        print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+        resp = requests.post(submit_url, json=submission_data, timeout=120)
+        resp.raise_for_status()
+        result_data = resp.json()
 
-    try:
-        r = requests.post(submit_url, json=submission_data, timeout=90, headers=UA)
-        r.raise_for_status()
-        result_data = r.json()
         final_status = (
-            f"Submission Successful!\n"
+            f"✅ Submission Successful!\n"
             f"User: {result_data.get('username')}\n"
             f"Overall Score: {result_data.get('score', 'N/A')}% "
             f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
             f"Message: {result_data.get('message', 'No message received.')}"
         )
+
+        # local stats
+        submitted_n = len(answers_payload)
+        skipped_n = len([r for r in results_log if r["Submitted Answer"] == "SKIPPED"])
+        final_status += f"\n\nLocal stats -> Submitted: {submitted_n}, Skipped: {skipped_n}"
+
         return final_status, pd.DataFrame(results_log)
+
     except Exception as e:
-        return f"Submission Failed: {e}", pd.DataFrame(results_log)
+        tb = traceback.format_exc()
+        return f"❌ Runtime Error:\n{e}\n\n--- Traceback ---\n{tb}", None
+
 
 # -----------------------------
 # Gradio UI
 # -----------------------------
 with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner (No Model / Rule-based)")
+    gr.Markdown("# Basic Agent Evaluation Runner (No Model / Rule-based + Wikipedia)")
     gr.Markdown(
         """
 **Instructions**
 1. Login with the button below.
 2. Click **Run Evaluation & Submit All Answers**.
 
-**What this agent can solve reliably (no paid model):**
-- Reversed sentence about the opposite of "left"  ✅
-- The * table commutativity counterexample subset ✅
-- Botany grocery list: vegetables only (no botanical fruits) ✅
-- Mercedes Sosa (2000–2009) studio albums count via Wikipedia ✅
-- Polish Everybody Loves Raymond -> Magda M. role via Wikipedia ✅ (best-effort)
-- 1928 Olympics least athletes IOC code via Wikipedia tables ✅ (best-effort)
-        """
+這版不用任何付費 model，只做「規則題 + Wikipedia 可查題」。
+如果出錯，下面會顯示 traceback。
+"""
     )
 
     gr.LoginButton()
-    run_button = gr.Button("Run Evaluation & Submit All Answers")
 
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=6, interactive=False)
+    run_button = gr.Button("Run Evaluation & Submit All Answers")
+    status_output = gr.Textbox(label="Run Status / Submission Result", lines=16, interactive=False)
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
 
-    run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
+    run_button.click(
+        fn=run_and_submit_all,
+        outputs=[status_output, results_table]
+    )
 
 if __name__ == "__main__":
-    demo.launch(debug=True, share=False)
+    demo.launch(debug=True, share=False, show_error=True)