Update app.py

app.py

@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+
 import os
 import ast
 import operator
@@ -9,12 +10,11 @@ import re
 import requests
 import pandas as pd
 import gradio as gr
-import yaml
 
-from smolagents import CodeAgent, HfApiModel, tool
+from smolagents import CodeAgent, TransformersModel, tool
 
 # -------------------------
-# Minimal tools (safe)
+# Minimal tools
 # -------------------------
 _allowed_ops = {
     ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul,
@@ -34,43 +34,25 @@ def _eval_node(node):
     raise ValueError("Unsupported expression")
 
 def safe_calc(expr: str):
-    # expr must already be validated (only allowed chars)
     tree = ast.parse(expr, mode='eval')
     return _eval_node(tree.body)
 
-
 @tool
 def calculator(expr: str) -> str:
     """
     Safely evaluate a mathematical expression.
 
     Args:
-        expr (str): Mathematical expression to evaluate, e.g. "2 + 2 * 3".
-                     Allowed characters: digits, spaces, parentheses, + - * / % ^ . 
+        expr: A string containing a math expression like "2 + 2 * 3".
 
     Returns:
-        str: JSON string {"expression": expr, "result": value} or {"error": "..."} on failure.
+        JSON string with {"expression": expr, "result": value} or {"error": "..."} on failure.
     """
     try:
-        if expr is None:
-            return json.dumps({"error": "No expression provided"})
-        # sanitize: remove newlines, tabs and leading/trailing whitespace
-        expr_clean = str(expr).replace('\n', ' ').replace('\r', ' ').replace('\t', ' ').strip()
-        # allow caret ^ as exponent -> convert to **
-        expr_clean = expr_clean.replace('^', '**')
-        # validate chars: only digits, operators, parentheses, dot and spaces
-        if not re.fullmatch(r"[0-9\.\s\+\-\*\/\%\(\)\*]+", expr_clean):
-            return json.dumps({"error": "Expression contains invalid characters or is not a simple math expression", "original": expr})
-        # extra safety: prevent huge exponentiation etc (limit length)
-        if len(expr_clean) > 200:
-            return json.dumps({"error": "Expression too long"})
-        # parse & evaluate safely
-        val = safe_calc(expr_clean)
-        return json.dumps({"expression": expr_clean, "result": float(val)})
-    except (SyntaxError, ValueError, IndentationError) as e:
-        return json.dumps({"error": f"Calc parse error: {str(e)}", "original": expr})
+        val = safe_calc(expr)
+        return json.dumps({"expression": expr, "result": float(val)})
     except Exception as e:
-        return json.dumps({"error": f"Calc error: {str(e)}", "original": expr})
+        return json.dumps({"error": f"Calc error: {e}"})
 
 
 @tool
@@ -79,19 +61,17 @@ def get_current_time_in_timezone(timezone: str) -> str:
     Get the current local time in a specified timezone.
 
     Args:
-        timezone (str): A valid timezone string (e.g., "Europe/Paris").
+        timezone: A valid timezone string (e.g., "Europe/Paris").
 
     Returns:
-        str: JSON string with {"timezone": timezone, "local_time": "..."} or {"error": "..."} on failure.
+        JSON string with {"timezone": timezone, "local_time": "..."} or {"error": "..."} on failure.
     """
     try:
-        if not timezone:
-            timezone = "UTC"
         tz = pytz.timezone(timezone)
         local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
         return json.dumps({"timezone": timezone, "local_time": local_time})
     except Exception as e:
-        return json.dumps({"error": f"Timezone error: {e}", "timezone": timezone})
+        return json.dumps({"error": f"Timezone error: {e}"})
 
 
 # -------------------------
@@ -99,27 +79,17 @@ def get_current_time_in_timezone(timezone: str) -> str:
 # -------------------------
 prompt_templates = None
 try:
+    import yaml
     with open("prompts.yaml", "r") as fh:
         prompt_templates = yaml.safe_load(fh)
 except Exception:
     prompt_templates = None
 
+
 # -------------------------
-# HfApiModel + CodeAgent
+# TransformersModel + CodeAgent minimal
 # -------------------------
-# IMPORTANT: set HF_API_TOKEN secret in your Space settings (or export locally)
-# HF will often provide token internally in Spaces; otherwise add secret HF_API_TOKEN.
-hf_token = os.getenv("HF_API_TOKEN")
-if hf_token:
-    print("HF_API_TOKEN found in environment.")
-else:
-    print("Warning: HF_API_TOKEN not set. HfApiModel may fail if token required by environment.")
-
-model = HfApiModel(
-    model_id='Qwen/Qwen2.5-Coder-32B-Instruct',
-    max_tokens=2048,
-    temperature=0.5
-)
+model = TransformersModel(model_id="HuggingFaceTB/SmolLM-135M-Instruct")
 
 code_agent = CodeAgent(
     model=model,
@@ -129,95 +99,104 @@ code_agent = CodeAgent(
     prompt_templates=prompt_templates
 )
 
+
 # -------------------------
-# GAIA Agent wrapper (fixed)
+# GAIA Agent wrapper
 # -------------------------
 class GaiaAgentMinimal:
     def __init__(self, code_agent):
         self.code_agent = code_agent
 
     def _is_calc(self, q: str) -> bool:
-        # strict heuristic: require an explicit operator or explicit math intent
-        if q is None:
+        """Return True only for explicit calculation requests, not 'how many' type questions."""
+        if not q:
             return False
         ql = q.lower()
-        # common trigger words indicating calculation
-        triggers = ["calculate", "compute", "what is", "how many", "evaluate"]
-        if any(tr in ql for tr in triggers) and re.search(r"\d", ql):
+        calc_triggers = ["calculate", "compute", "evaluate", "what is", "what's"]
+        if any(tr in ql for tr in calc_triggers) and re.search(r"\d", ql):
             return True
-        # or presence of arithmetic operators near digits
         if re.search(r"\d\s*[\+\-\*\/\%\^]\s*\d", q):
             return True
         return False
 
     def _is_time(self, q: str) -> bool:
-        if q is None:
-            return False
         ql = q.lower()
-        return any(tok in ql for tok in ["time", "heure", "quelle heure", "what time", "current time", "local time"])
+        return "time" in ql or "heure" in ql or "quelle heure" in ql or "what time" in ql
+
+    def _call_llm(self, q: str) -> str:
+        """Wrapper to call LLM and return result or proper error if token/API missing."""
+        try:
+            resp = self.code_agent.run(q)
+        except Exception as e:
+            msg = str(e)
+            if "api_key" in msg.lower() or "auth" in msg.lower():
+                return json.dumps({"error": "LLM error: missing HF API token. Set HF_API_TOKEN secret or login with HF."})
+            return json.dumps({"error": f"LLM runtime error: {msg}"})
+        if resp is None:
+            return json.dumps({"error": "LLM returned no output"})
+        if isinstance(resp, dict):
+            for key in ("final_answer", "answer", "result", "output"):
+                if key in resp:
+                    return str(resp[key])
+            return json.dumps(resp)
+        if isinstance(resp, (int, float)):
+            return str(resp)
+        s = str(resp).strip()
+        if s == "":
+            return json.dumps({"error": "LLM returned empty string"})
+        return s
 
     def run(self, question: str) -> str:
         try:
             q = question.strip() if question else ""
-            print(f"[gaia run] question preview: {q[:120]}")
 
-            # 1) Calculator: strict
+            # 1) Calculator
             if self._is_calc(q):
-                # try to extract the math subexpression (first match)
                 m = re.search(r'([0-9\.\s\+\-\*\/\^\%\(\)]+)', q)
-                expr = m.group(1) if m else q
+                expr = m.group(1).strip() if m else ""
+                if not expr or not re.search(r'[\+\-\*\/\%\^]', expr):
+                    return self._call_llm(q)
+                expr = expr.replace('^', '**').replace('\n', ' ').strip()
+                if not re.fullmatch(r"[0-9\.\s\+\-\*\/\%\(\)\*]+", expr):
+                    return json.dumps({"error": "Expression contains invalid characters or is not a simple math expression", "original": expr})
                 return calculator(expr)
 
-            # 2) Time queries
+            # 2) Time
             if self._is_time(q):
                 tz = "Europe/Paris" if "paris" in q.lower() or "france" in q.lower() else "UTC"
                 return get_current_time_in_timezone(tz)
 
-            # 3) LLM fallback via HfApiModel (wrapped)
-            try:
-                resp = self.code_agent.run(q)
-            except Exception as e:
-                # return structured error so GAIA runner sees it
-                return json.dumps({"error": f"LLM runtime error: {str(e)}"})
-
-            # Normalize responses: allow string, dict, number
-            if resp is None:
-                return json.dumps({"error": "LLM returned no output"})
-            if isinstance(resp, dict):
-                # prefer common keys
-                for key in ("final_answer", "answer", "result", "output"):
-                    if key in resp:
-                        return str(resp[key])
-                return json.dumps(resp)
-            # primitives (int/float) -> convert to string
-            if isinstance(resp, (int, float)):
-                return str(resp)
-            # otherwise assume string
-            s = str(resp).strip()
-            if s == "":
-                return json.dumps({"error": "LLM returned empty string"})
-            return s
+            # 3) fallback LLM
+            return self._call_llm(q)
+
         except Exception as e:
             return json.dumps({"error": f"Agent internal error: {str(e)}"})
 
-# instantiate agent
+
+# instantiate GAIA agent
 gaia_agent = GaiaAgentMinimal(code_agent)
 
+
 # -------------------------
-# GAIA runner (unchanged behavior)
+# GAIA runner
 # -------------------------
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     space_id = os.getenv("SPACE_ID")
-    if not profile:
+
+    if profile:
+        username = f"{profile.username}"
+    else:
         return "Please Login to Hugging Face with the button.", None
-    username = profile.username.strip()
 
-    questions_url = f"{DEFAULT_API_URL}/questions"
-    submit_url = f"{DEFAULT_API_URL}/submit"
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
+
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "unknown"
 
+    # Fetch questions
     try:
         response = requests.get(questions_url, timeout=15)
         response.raise_for_status()
@@ -227,6 +206,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     except Exception as e:
         return f"Error fetching questions: {e}", None
 
+    # Run agent
     results_log = []
     answers_payload = []
     for item in questions_data:
@@ -244,32 +224,42 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     if not answers_payload:
         return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
 
-    submission_data = {"username": username, "agent_code": agent_code, "answers": answers_payload}
+    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
+
+    # Submit
     try:
         response = requests.post(submit_url, json=submission_data, timeout=60)
         response.raise_for_status()
         result_data = response.json()
         final_status = (
-            f"Submission Successful!\nUser: {result_data.get('username')}\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.')}"
         )
-        return final_status, pd.DataFrame(results_log)
+        results_df = pd.DataFrame(results_log)
+        return final_status, results_df
     except Exception as e:
-        return f"Submission failed: {e}", pd.DataFrame(results_log)
+        results_df = pd.DataFrame(results_log)
+        return f"Submission failed: {e}", results_df
+
 
 # -------------------------
 # Gradio UI
 # -------------------------
 with gr.Blocks() as demo:
     gr.Markdown("# Minimal GAIA Agent Runner")
-    gr.Markdown("Log in to Hugging Face, click 'Run Evaluation & Submit All Answers' to fetch questions, run the agent, and submit answers.")
+    gr.Markdown(
+        "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)
+
     run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
 
+
 if __name__ == "__main__":
     demo.launch(debug=True, share=False)