Update app.py

app.py

@@ -1,81 +1,122 @@
 import os
+import gradio as gr
 import requests
-from smolagents import CodeAgent, tool, OpenAIServerModel
-
-# ------------------------
-# Constants
-# ------------------------
-API_URL = "https://agents-course-unit4-scoring.hf.space"
-
-# ------------------------
-# Tool definitions
-# ------------------------
-@tool
-def fetch_questions() -> list:
-    """
-    Fetch the full list of GAIA evaluation questions.
+import pandas as pd
 
-    Returns:
-        list: A list of question dicts, each with 'task_id' and 'question'.
-    """
-    resp = requests.get(f"{API_URL}/questions", timeout=15)
-    resp.raise_for_status()
-    return resp.json()
+from agent import create_agent, fetch_random_question
 
+# --- Constants ---
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-@tool
-def fetch_random_question() -> dict:
-    """
-    Fetch a single random GAIA question.
 
-    Returns:
-        dict: A dict with keys 'task_id' and 'question'.
+def run_and_submit_all(profile):
     """
-    resp = requests.get(f"{API_URL}/random-question", timeout=15)
-    resp.raise_for_status()
-    return resp.json()
+    Fetch all questions, run the SmolAgent on them, submit all answers,
+    and display the results.
+    """
+    space_id = os.getenv("SPACE_ID")
 
+    if profile is None:
+        return "Please login to Hugging Face with the button.", None
+    username = profile.username
 
-@tool
-def submit_answers(username: str, agent_code: str, answers: list) -> dict:
-    """
-    Submit the agent's answers to GAIA and get the scoring.
+    # Instantiate the agent
+    try:
+        agent = create_agent()
+    except Exception as e:
+        return f"Error initializing agent: {e}", None
 
-    Args:
-        username (str): The Hugging Face username identifying the submission.
-        agent_code (str): URL to your Space code repository for verification.
-        answers (list): A list of dicts, each with 'task_id' and 'submitted_answer'.
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
 
-    Returns:
-        dict: A dict containing 'score', 'correct_count', 'total_attempted', 'message', etc.
-    """
-    payload = {
-        "username": username,
-        "agent_code": agent_code,
-        "answers": answers
-    }
-    resp = requests.post(f"{API_URL}/submit", json=payload, timeout=60)
-    resp.raise_for_status()
-    return resp.json()
+    # Fetch questions
+    try:
+        response = requests.get(f"{DEFAULT_API_URL}/questions", timeout=15)
+        response.raise_for_status()
+        questions = response.json()
+    except Exception as e:
+        return f"Error fetching questions: {e}", None
 
+    if not questions:
+        return "No questions fetched.", None
 
-def create_agent() -> CodeAgent:
-    """
-    Build and return a configured CodeAgent using OpenAI GPT-3.5 Turbo.
-    Requires OPENAI_API_KEY in the environment.
+    # Run agent on each question
+    results = []
+    payload = []
+    for q in questions:
+        task_id = q.get("task_id")
+        question_text = q.get("question")
+        if not task_id or not question_text:
+            continue
+        try:
+            answer = agent.run(question=question_text)
+        except Exception as e:
+            answer = f"ERROR: {e}"
+        results.append({"Task ID": task_id, "Question": question_text, "Answer": answer})
+        payload.append({"task_id": task_id, "submitted_answer": answer})
 
-    Returns:
-        CodeAgent: An instance of CodeAgent configured with the GAIA tools.
-    """
-    # Use 'model_id' to match the OpenAIServerModel signature
-    model = OpenAIServerModel(model_id="gpt-3.5-turbo")
-    agent = CodeAgent(
-        tools=[fetch_questions, fetch_random_question, submit_answers],
-        model=model,
-        prompt_template=(
-            "Here is a GAIA question:\n"
-            "{question}\n"
-            "Provide ONLY the exact answer (exact-match), with no extra text."
+    # Submit answers
+    submit_payload = {"username": username, "agent_code": agent_code, "answers": payload}
+    try:
+        resp = requests.post(f"{DEFAULT_API_URL}/submit", json=submit_payload, timeout=60)
+        resp.raise_for_status()
+        data = resp.json()
+        status = (
+            f"Submission Successful!\n"
+            f"User: {data.get('username')}\n"
+            f"Score: {data.get('score')}% ({data.get('correct_count')}/{data.get('total_attempted')})\n"
+            f"Message: {data.get('message')}"
         )
+    except Exception as e:
+        status = f"Submission Failed: {e}"
+
+    return status, pd.DataFrame(results)
+
+
+def test_random_question(profile):
+    """
+    Fetch a random GAIA question and return its answer by the agent.
+    """
+    if profile is None:
+        return "Please login to test.", ""
+    try:
+        q = fetch_random_question()
+        agent = create_agent()
+        ans = agent.run(question=q.get("question", ""))
+        return q.get("question", ""), ans
+    except Exception as e:
+        return f"Error: {e}", ""
+
+
+# --- Gradio Interface ---
+with gr.Blocks() as demo:
+    gr.Markdown("# SmolAgent Evaluation Runner")
+    gr.Markdown(
+        """
+        **Istruzioni:**
+        1. Clone questo space e definisci la logica in agent.py.
+        2. Effettua il login con il tuo account Hugging Face.
+        3. Usa 'Run Evaluation & Submit All Answers' o 'Test Random Question'.
+        """
     )
-    return agent
+
+    # OAuth login and user state
+    login = gr.LoginButton()
+    user = gr.State()
+    # On login, store profile in state
+    login.click(fn=lambda profile: profile, inputs=[login], outputs=[user])
+
+    run_all = gr.Button("Run Evaluation & Submit All Answers")
+    test = gr.Button("Test Random Question")
+
+    status = gr.Textbox(label="Status / Risultato", lines=5, interactive=False)
+    table = gr.DataFrame(label="Risultati Completi", wrap=True)
+    qbox = gr.Textbox(label="Domanda Casuale", lines=3, interactive=False)
+    abox = gr.Textbox(label="Risposta Agente", lines=3, interactive=False)
+
+    # Use stored user state as input
+    run_all.click(fn=run_and_submit_all, inputs=[user], outputs=[status, table])
+    test.click(fn=test_random_question, inputs=[user], outputs=[qbox, abox])
+
+if __name__ == "__main__":
+    demo.launch(debug=True, share=False)
+    demo.launch(debug=True, share=False)