Update app.py

app.py

@@ -4,14 +4,13 @@ import gradio as gr
 import requests
 import pandas as pd
 
-from smolagents import CodeAgent, OpenAIServerModel
-from smolagents.tools import DuckDuckGoSearchTool
+from smolagents import CodeAgent, OpenAIServerModel, DuckDuckGoSearchTool
 
 # Constants
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 MAX_QUESTION_LENGTH = 4000
 
-# --- Reliable DuckDuckGo Tool using smolagents ---
+# Reliable search tool with retry
 class ReliableDuckDuckGoTool(DuckDuckGoSearchTool):
     def run(self, query: str) -> str:
         for attempt in range(3):
@@ -19,136 +18,79 @@ class ReliableDuckDuckGoTool(DuckDuckGoSearchTool):
                 return super().run(query)
             except Exception as e:
                 if "rate" in str(e).lower():
-                    print(f"[DuckDuckGo] Rate limit hit. Retrying ({attempt + 1}/3)...")
+                    print(f"[DuckDuckGo] Rate limit, retry {attempt+1}/3")
                     time.sleep(2 * (attempt + 1))
                 else:
-                    raise e
+                    raise
         raise RuntimeError("DuckDuckGo search failed after retries")
 
-# --- Main Agent ---
+# Main agent using GPT-4 & tools
 class SmartGAIAAgent:
     def __init__(self):
-        self.api_key = os.getenv("OPENAI_API_KEY")
-        if not self.api_key:
+        key = os.getenv("OPENAI_API_KEY")
+        if not key:
             raise ValueError("Missing OPENAI_API_KEY")
-        self.model = OpenAIServerModel(model_id="gpt-4", api_key=self.api_key)
-
+        model = OpenAIServerModel(model_id="gpt-4", api_key=key)
         self.agent = CodeAgent(
             tools=[ReliableDuckDuckGoTool()],
-            model=self.model,
+            model=model,
             add_base_tools=True
         )
 
-    def truncate_question(self, question: str) -> str:
-        return question[:MAX_QUESTION_LENGTH]
-
     def __call__(self, question: str) -> str:
+        q = question[:MAX_QUESTION_LENGTH]
         try:
-            question = self.truncate_question(question)
-            return self.agent.run(question).strip()
+            return self.agent.run(q).strip()
         except Exception as e:
-            print(f"Agent error: {e}")
+            print("Agent error:", e)
             return "error"
 
-# --- Evaluation and Submission Logic ---
+# Fetch, filter, run, and submit answers
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    space_id = os.getenv("SPACE_ID")
-    if profile:
-        username = f"{profile.username}"
-        print(f"User logged in: {username}")
-    else:
-        return "Please Login to Hugging Face with the button.", None
-
-    questions_url = f"{DEFAULT_API_URL}/questions"
-    submit_url = f"{DEFAULT_API_URL}/submit"
+    username = profile.username if profile else None
+    if not username:
+        return "Please Login to Hugging Face", None
 
+    # instantiate agent
     try:
         agent = SmartGAIAAgent()
     except Exception as e:
         return f"Error initializing agent: {e}", None
 
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-
-    try:
-        response = requests.get(questions_url, timeout=15)
-        response.raise_for_status()
-        questions_data = response.json()
-    except Exception as e:
-        return f"Error fetching questions: {e}", None
-
-    answers_payload = []
-    results_log = []
-
-    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
-        if len(question_text) > MAX_QUESTION_LENGTH:
-            print(f"Skipping long question: {task_id}")
-            continue
-        if any(keyword in question_text.lower() for keyword in [
-            'attached', '.mp3', '.wav', '.png', '.jpg', '.jpeg',
-            'youtube', '.mp4', 'video', 'listen', 'watch'
-        ]):
-            print(f"Skipping unsupported question: {task_id}")
+    # get questions
+    resp = requests.get(f"{DEFAULT_API_URL}/questions", timeout=15)
+    resp.raise_for_status()
+    questions = resp.json()
+
+    payload, logs = [], []
+    skip_kw = ['.mp3','.wav','.png','.jpg','youtube','video','watch','listen']
+    for item in questions:
+        tid = item.get("task_id")
+        q = item.get("question","")
+        if not tid or not q or len(q)>MAX_QUESTION_LENGTH or any(k in q.lower() for k in skip_kw):
             continue
+        ans = agent(q)
+        payload.append({"task_id": tid, "submitted_answer": ans})
+        logs.append({"Task ID": tid, "Question": q, "Submitted Answer": ans})
 
-        try:
-            submitted_answer = agent(question_text)
-            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"ERROR: {e}"
-            })
+    if not payload:
+        return "No valid questions to submit.", pd.DataFrame(logs)
 
-    if not answers_payload:
-        return "No answers were submitted.", pd.DataFrame(results_log)
+    sub = {"username": username, "agent_code": f"https://huggingface.co/spaces/{os.getenv('SPACE_ID')}/tree/main", "answers": payload}
+    resp = requests.post(f"{DEFAULT_API_URL}/submit", json=sub, timeout=60)
+    resp.raise_for_status()
+    result = resp.json()
+    status = f"Score: {result.get('score')}% ({result.get('correct_count')}/{result.get('total_attempted')})"
+    return status, pd.DataFrame(logs)
 
-    submission_data = {
-        "username": username,
-        "agent_code": agent_code,
-        "answers": answers_payload
-    }
-
-    try:
-        response = requests.post(submit_url, json=submission_data, timeout=60)
-        response.raise_for_status()
-        result_data = response.json()
-        final_status = (
-            f"Submission Successful!\n"
-            f"User: {result_data.get('username')}\n"
-            f"Score: {result_data.get('score')}% "
-            f"({result_data.get('correct_count')}/{result_data.get('total_attempted')})\n"
-            f"Message: {result_data.get('message')}"
-        )
-        return final_status, pd.DataFrame(results_log)
-    except Exception as e:
-        return f"Submission failed: {e}", pd.DataFrame(results_log)
-
-# --- Gradio UI ---
+# Gradio UI
 with gr.Blocks() as demo:
-    gr.Markdown("# 🧠 GAIA Agent Evaluation")
-    gr.Markdown("""
-    1. Log in to Hugging Face
-    2. Click 'Run Evaluation & Submit All Answers'
-    3. View your score on the leaderboard
-    """)
+    gr.Markdown("# GAIA Agent")
     gr.LoginButton()
-    run_button = gr.Button("Run Evaluation & Submit All Answers")
-    status_output = gr.Textbox(label="Submission Status", lines=5)
-    results_table = gr.DataFrame(label="Evaluation Results")
-
-    run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
+    run_btn = gr.Button("Run & Submit")
+    status = gr.Textbox(lines=5)
+    table = gr.DataFrame()
+    run_btn.click(run_and_submit_all, outputs=[status, table])
 
 if __name__ == "__main__":
-    print("Launching Gradio Interface...")
     demo.launch(debug=True, share=False)