Update app.py

app.py

@@ -1,13 +1,11 @@
 #!/usr/bin/env python3
-# app.py - Minimal GAIA-ready agent + runner (Gradio UI)
+# Minimal GAIA agent app.py (compatible toutes versions smolagents)
+
 import os
 import re
 import json
 import ast
 import operator
-import subprocess
-import sys
-import importlib
 import datetime
 import pytz
 import yaml
@@ -15,25 +13,16 @@ import requests
 import pandas as pd
 import gradio as gr
 
-# Ensure import helper (optional; mostly for local dev if you want auto-install)
-def ensure_import(pkg_name, import_name=None):
-    import_name = import_name or pkg_name
-    try:
-        return importlib.import_module(import_name)
-    except ImportError:
-        # don't auto-install in production spaces; keep simple behavior
-        raise
-
-# ---- smolagents & local tool imports ----
-# Assumes smolagents and tools.final_answer are available in your environment
-from smolagents import CodeAgent, HfApiModel, tool, DuckDuckGoSearchTool
+# -------------------------
+# smolagents imports
+# -------------------------
+from smolagents import CodeAgent, tool
 from tools.final_answer import FinalAnswerTool
 
 # -------------------------
-# Minimal toolset for GAIA
+# Minimal tools
 # -------------------------
 
-# Safe calculator using ast (no eval)
 _allowed_ops = {
     ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul,
     ast.Div: operator.truediv, ast.Pow: operator.pow, ast.USub: operator.neg,
@@ -41,15 +30,15 @@ _allowed_ops = {
 }
 
 def _eval_node(node):
-    if isinstance(node, ast.Constant):  # Python 3.8+: ast.Num replaced by ast.Constant
+    if isinstance(node, ast.Constant):
         return node.value
-    if isinstance(node, ast.Num):  # fallback for some versions
+    if isinstance(node, ast.Num):
         return node.n
     if isinstance(node, ast.UnaryOp) and type(node.op) in _allowed_ops:
         return _allowed_ops[type(node.op)](_eval_node(node.operand))
     if isinstance(node, ast.BinOp) and type(node.op) in _allowed_ops:
         return _allowed_ops[type(node.op)](_eval_node(node.left), _eval_node(node.right))
-    raise ValueError("Unsupported or unsafe expression")
+    raise ValueError("Unsupported expression")
 
 def safe_calc(expr: str):
     tree = ast.parse(expr, mode='eval')
@@ -57,18 +46,14 @@ def safe_calc(expr: str):
 
 @tool
 def calculator(expr: str) -> str:
-    """Compute numeric expressions safely (no eval). Returns JSON string."""
     try:
-        # clean expression (allow digits, operators, parentheses, spaces)
-        expr_clean = expr.strip()
-        val = safe_calc(expr_clean)
-        return json.dumps({"expression": expr_clean, "result": float(val)})
+        val = safe_calc(expr)
+        return json.dumps({"expression": expr, "result": float(val)})
     except Exception as e:
         return json.dumps({"error": f"Calc error: {e}"})
 
 @tool
 def get_current_time_in_timezone(timezone: str) -> str:
-    """Return current time in timezone as JSON string."""
     try:
         tz = pytz.timezone(timezone)
         local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
@@ -76,10 +61,10 @@ def get_current_time_in_timezone(timezone: str) -> str:
     except Exception as e:
         return json.dumps({"error": f"Timezone error: {e}"})
 
-# FinalAnswerTool (exists in repo)
+# FinalAnswerTool
 final_answer = FinalAnswerTool()
 
-# Load prompts if present (optional)
+# Load prompts.yaml if exists
 prompt_templates = None
 try:
     with open("prompts.yaml", "r") as fh:
@@ -87,36 +72,27 @@ try:
 except Exception:
     prompt_templates = None
 
-# Instantiate a compact CodeAgent (adjust model_id if needed)
+# -------------------------
+# CodeAgent minimal
+# -------------------------
+MODEL_ID = 'Qwen/Qwen2.5-Coder-32B-Instruct'
+
 code_agent = CodeAgent(
-    model=HfApiModel(
-        max_tokens=1024,
-        temperature=0.15,
-        model_id='Qwen/Qwen2.5-Coder-32B-Instruct'  # change if overloaded or unavailable
-    ),
+    model=MODEL_ID,  # directly pass string if HfApiModel missing
     tools=[final_answer, calculator, get_current_time_in_timezone],
     max_steps=6,
     verbosity_level=0,
     prompt_templates=prompt_templates
 )
 
-# Try to create a DuckDuckGo search tool for web fallback (may fail depending on smolagents version)
-search_tool = None
-try:
-    search_tool = DuckDuckGoSearchTool()
-except Exception:
-    search_tool = None  # fallback gracefully if unavailable
-
 # -------------------------
-# Minimal GaiaAgent wrapper
+# GAIA Agent wrapper
 # -------------------------
 class GaiaAgentMinimal:
-    def __init__(self, code_agent, search_tool=None):
+    def __init__(self, code_agent):
         self.code_agent = code_agent
-        self.search_tool = search_tool
 
     def _is_calc(self, q: str) -> bool:
-        # heuristics: contains digits and math operators
         return bool(re.search(r'[\d]', q)) and any(op in q for op in ['+', '-', '*', '/', '%', '^'])
 
     def _is_time(self, q: str) -> bool:
@@ -124,144 +100,87 @@ class GaiaAgentMinimal:
         return "time" in ql or "heure" in ql or "quelle heure" in ql or "what time" in ql
 
     def run(self, question: str) -> str:
-        """Return a string (or JSON string) answer for the GAIA runner."""
         try:
             q = question.strip()
 
-            # 1) calculator
+            # 1) Calculator
             if self._is_calc(q):
-                # extract the first expression-like substring
                 m = re.search(r'([0-9\.\s\+\-\*\/\^\%\(\)]+)', q)
                 expr = m.group(1) if m else q
                 return calculator(expr)
 
-            # 2) time requests
+            # 2) Time queries
             if self._is_time(q):
-                # quick timezone guess
                 if "paris" in q.lower() or "france" in q.lower():
                     tz = "Europe/Paris"
                 else:
-                    # try to extract "in X" patterns (e.g., in London)
-                    m = re.search(r'in\s+([A-Za-z_\/]+)', q, re.I)
-                    tz = m.group(1) if m else "UTC"
+                    tz = "UTC"
                 return get_current_time_in_timezone(tz)
 
-            # 3) quick web search fallback (if available)
-            if self.search_tool:
-                try:
-                    if hasattr(self.search_tool, "search"):
-                        res = self.search_tool.search(q, top_k=1)
-                    elif hasattr(self.search_tool, "run"):
-                        res = self.search_tool.run(q)
-                    else:
-                        res = self.search_tool(q)
-                    # Return as JSON string to be stable for scoring parsing
-                    return json.dumps({"source": "web_search", "snippet": str(res)})
-                except Exception:
-                    pass
-
-            # 4) fallback to LLM CodeAgent
-            try:
-                resp = None
-                # Try typical call signatures (some smolagents versions use call directly)
-                if hasattr(self.code_agent, "run"):
-                    resp = self.code_agent.run(q)
-                else:
-                    resp = self.code_agent(q)
-                # Normalize response
-                if isinstance(resp, dict):
-                    for key in ("final_answer", "answer", "result", "output"):
-                        if key in resp:
-                            return str(resp[key])
-                    return json.dumps(resp)
-                return str(resp)
-            except Exception as e:
-                # last-resort fallback
-                return json.dumps({"error": f"LLM error: {e}"})
+            # 3) fallback LLM
+            resp = self.code_agent.run(q)
+            if isinstance(resp, dict):
+                for key in ("final_answer", "answer", "result", "output"):
+                    if key in resp:
+                        return str(resp[key])
+                return json.dumps(resp)
+            return str(resp)
         except Exception as e:
             return json.dumps({"error": f"Agent internal error: {e}"})
 
-# Instantiate gaia_agent for the runner to use
-gaia_agent = GaiaAgentMinimal(code_agent, search_tool)
+# instantiate
+gaia_agent = GaiaAgentMinimal(code_agent)
 
 # -------------------------
-# GAIA runner (unchanged logic, uses gaia_agent)
+# GAIA runner (unchanged)
 # -------------------------
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    """
-    Fetches all questions, runs gaia_agent on them, submits all answers,
-    and returns status and results table.
-    """
     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
 
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Agent is ready (we use gaia_agent defined above)
-    try:
-        agent = gaia_agent
-    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"
 
-    # 2. Fetch Questions
-    print(f"Fetching questions from: {questions_url}")
+    # Fetch questions
     try:
         response = requests.get(questions_url, timeout=15)
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
-            print("Fetched questions list is empty.")
             return "Fetched questions list is empty or invalid format.", None
-        print(f"Fetched {len(questions_data)} questions.")
-    except requests.exceptions.RequestException as e:
-        print(f"Error fetching questions: {e}")
-        return f"Error fetching questions: {e}", None
     except Exception as e:
-        print(f"An unexpected error occurred fetching questions: {e}")
-        return f"An unexpected error occurred fetching questions: {e}", None
+        return f"Error fetching questions: {e}", None
 
-    # 3. Run agent on each question
+    # Run agent
     results_log = []
     answers_payload = []
-    print(f"Running agent on {len(questions_data)} questions...")
     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:
-            print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            submitted_answer = agent.run(question_text)
+            submitted_answer = gaia_agent.run(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:
-            print(f"Error running agent on task {task_id}: {e}")
             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
 
     if not answers_payload:
-        print("Agent did not produce any answers to submit.")
         return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
 
-    # 4. Prepare submission
     submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
-    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
-    print(status_update)
 
-    # 5. Submit
-    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+    # Submit
     try:
         response = requests.post(submit_url, json=submission_data, timeout=60)
         response.raise_for_status()
@@ -273,35 +192,11 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
             f"Message: {result_data.get('message', 'No message received.')}"
         )
-        print("Submission successful.")
         results_df = pd.DataFrame(results_log)
         return final_status, results_df
-    except requests.exceptions.HTTPError as e:
-        error_detail = f"Server responded with status {e.response.status_code}."
-        try:
-            error_json = e.response.json()
-            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
-        except Exception:
-            error_detail += f" Response: {e.response.text[:500]}"
-        status_message = f"Submission Failed: {error_detail}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
-    except requests.exceptions.Timeout:
-        status_message = "Submission Failed: The request timed out."
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
-    except requests.exceptions.RequestException as e:
-        status_message = f"Submission Failed: Network error - {e}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
     except Exception as e:
-        status_message = f"An unexpected error occurred during submission: {e}"
-        print(status_message)
         results_df = pd.DataFrame(results_log)
-        return status_message, results_df
+        return f"Submission failed: {e}", results_df
 
 # -------------------------
 # Gradio UI
@@ -309,15 +204,9 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 with gr.Blocks() as demo:
     gr.Markdown("# Minimal GAIA Agent Runner")
     gr.Markdown(
-        """
-        Instructions:
-        1. Log in to your Hugging Face account with the button below.
-        2. Click 'Run Evaluation & Submit All Answers' to fetch questions, run the agent, submit answers and get the score.
-        """
+        "Log in to Hugging Face, click 'Run Evaluation & Submit All Answers' to fetch questions, run the agent, and submit answers."
     )
-
     gr.LoginButton()
-
     run_button = gr.Button("Run Evaluation & Submit All Answers")
     status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
@@ -325,20 +214,4 @@ with gr.Blocks() as demo:
     run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
 
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " App Starting " + "-"*30)
-    space_host_startup = os.getenv("SPACE_HOST")
-    space_id_startup = os.getenv("SPACE_ID")
-    if space_host_startup:
-        print(f"✅ SPACE_HOST found: {space_host_startup}")
-        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
-    else:
-        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
-    if space_id_startup:
-        print(f"✅ SPACE_ID found: {space_id_startup}")
-        print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
-    else:
-        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
-    print("-"*(60 + len(" App Starting ")) + "\n")
-
-    print("Launching Gradio Interface for Basic Agent Evaluation...")
     demo.launch(debug=True, share=False)