Update app.py

app.py

@@ -1,222 +1,141 @@
 import os
-import re
-import json
-import requests
+
+import agent
+import gradio as gr
+import logic
 import pandas as pd
-from pathlib import Path
-from typing import Optional
 from dotenv import load_dotenv
-import inspect
-import gradio as gr
-
-from langgraph.prebuilt import create_react_agent
-from langchain_core.messages import HumanMessage
-from langchain_core.tools import tool
-from langchain_openai import ChatOpenAI
 
 load_dotenv()
 
-# ------------------ LLM ------------------
-class OpenRouterLLM(ChatOpenAI):
-    """Custom OpenRouter LLM wrapper for LangGraph"""
-    def __init__(self, model: str = "deepseek/deepseek-v3.1-terminus", **kwargs):
-        api_key = os.getenv("OPENROUTER_API_KEY")
-        if not api_key:
-            raise ValueError("OPENROUTER_API_KEY not set in environment variables.")
-        super().__init__(
-            model=model,
-            openai_api_key=api_key,
-            openai_api_base="https://openrouter.ai/api/v1",
-            **kwargs
-        )
-
-# ------------------ TOOLS ------------------
-
-SERPAPI_KEY = os.getenv("SERPAPI_KEY")
-
-@tool
-def search_web(query: str) -> str:
-    """Perform a reliable web search using SerpAPI."""
-    if not SERPAPI_KEY:
-        return "Error: SERPAPI_KEY not set."
-    search_url = "https://serpapi.com/search.json"
-    params = {"q": query, "api_key": SERPAPI_KEY, "num": 3}
-    try:
-        response = requests.get(search_url, params=params, timeout=10)
-        response.raise_for_status()
-        data = response.json()
-        results = []
-        for item in data.get("organic_results", []):
-            title = item.get("title", "")
-            snippet = item.get("snippet", "")
-            link = item.get("link", "")
-            results.append(f"{title}\n{snippet}\n{link}")
-        return "\n\n".join(results) if results else f"No results for '{query}'."
-    except Exception as e:
-        return f"Web search error: {str(e)}"
 
-@tool
-def search_wikipedia(query: str) -> str:
-    """Retrieve full Wikipedia article text."""
+def run_and_submit_all(
+    profile: gr.OAuthProfile | None,
+) -> tuple[str, pd.DataFrame | None]:
+    """Fetches all questions, runs the BasicAgent on them, submits all answers,
+    and displays the results.
+
+    Args:
+        profile: An optional gr.OAuthProfile object containing user information
+            if the user is logged in. If None, the user is not logged in.
+
+    Returns:
+        tuple[str, pd.DataFrame | None]: A tuple containing:
+            - A string representing the status of the run and submission process.
+              This could be a success message, an error message, or a message
+              indicating that no answers were produced.
+            - A pandas DataFrame containing the results log. This DataFrame will
+              be displayed in the Gradio interface. It can be None if an error
+              occurred before the agent was run.
+    """
+    # 0. Get user details
+    space_id = os.getenv("SPACE_ID")
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(agent_code)
+    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
+
+    # 1. Instantiate Agent
     try:
-        url = f"https://en.wikipedia.org/w/api.php"
-        params = {
-            "action": "query",
-            "format": "json",
-            "prop": "extracts",
-            "explaintext": True,
-            "titles": query
-        }
-        response = requests.get(url, params=params, timeout=10)
-        response.raise_for_status()
-        pages = response.json()["query"]["pages"]
-        text = next(iter(pages.values())).get("extract", "")
-        if not text:
-            return f"No Wikipedia content found for '{query}'."
-        return text[:2000]  # truncate if too long
+        gaia_agent = agent.GaiaAgent()
     except Exception as e:
-        return f"Wikipedia search error: {str(e)}"
+        print(f"Error instantiating agent: {e}")
+        return f"Error initializing agent: {e}", None
 
-@tool
-def execute_python(code: str) -> str:
-    """Execute Python code safely and return output."""
+    # 2. Fetch Questions
     try:
-        safe_globals = {
-            '__builtins__': {
-                'print': print, 'len': len, 'str': str, 'int': int, 'float': float,
-                'bool': bool, 'list': list, 'dict': dict, 'tuple': tuple, 'set': set,
-                'range': range, 'sum': sum, 'max': max, 'min': min, 'abs': abs,
-                'round': round, 'sorted': sorted, 'enumerate': enumerate, 'zip': zip,
-            },
-            'math': __import__('math'),
-            'json': __import__('json'),
-            'datetime': __import__('datetime'),
-            'random': __import__('random'),
-        }
-        import io, sys
-        old_stdout = sys.stdout
-        sys.stdout = mystdout = io.StringIO()
-        try:
-            exec(code, safe_globals)
-            output = mystdout.getvalue()
-        finally:
-            sys.stdout = old_stdout
-        return output if output else "Code executed successfully (no output)"
+        questions_data = logic.fetch_all_questions()
     except Exception as e:
-        return f"Python execution error: {str(e)}"
+        return str(e), None
+
+    # 3. Run the Agent
+    results_log, answers_payload = logic.run_agent(gaia_agent, questions_data)
+    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 & Submit Answers
+    submission_data = {
+        "username": username.strip(),
+        "agent_code": agent_code,
+        "answers": answers_payload,
+    }
+    print(
+        f"Agent finished. Submitting {len(answers_payload)} answers for user '"
+        f"{username}'..."
+    )
+    return logic.submit_answers(submission_data, results_log)
+
+
+# --- Build Gradio Interface using Blocks ---
+with gr.Blocks() as gaia_ui:
+    gr.Markdown("# Basic Agent Evaluation Runner")
+    gr.Markdown(
+        """
+        **Instructions:**
+
+        1.  Please clone this space, then modify the code to define your agent's 
+        logic, the tools, the necessary packages, etc ...
+        2.  Log in to your Hugging Face account using the button below. This uses 
+        your HF username for submission.
+        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your 
+        agent, submit answers, and see the score.
+
+        ---
+        **Disclaimers:**
+        Once clicking on the "submit button, it can take quite some time ( this is 
+        the time for the agent to go through all the questions).
+        This space provides a basic setup and is intentionally sub-optimal to 
+        encourage you to develop your own, more robust solution. For instance for the 
+        delay process of the submit button, a solution could be to cache the answers 
+        and submit in a separate action or even to answer the questions in async.
+        """
+    )
+
+    gr.LoginButton()
+
+    run_button = gr.Button("Run Evaluation & Submit All Answers")
+
+    status_output = gr.Textbox(
+        label="Run Status / Submission Result", lines=5, interactive=False
+    )
+    # Removed max_rows=10 from DataFrame constructor
+    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+
+    run_button.click(
+        fn=run_and_submit_all, inputs=None, outputs=[status_output, results_table]
+    )
 
-@tool
-def read_excel_file(file_path: str, sheet_name: Optional[str] = None) -> str:
-    """Read an Excel file and return contents."""
-    try:
-        file_path_obj = Path(file_path)
-        if not file_path_obj.exists():
-            return f"Error: File not found at {file_path}"
-        if sheet_name and sheet_name.isdigit():
-            sheet_name = int(sheet_name)
-        elif sheet_name is None:
-            sheet_name = 0
-        df = pd.read_excel(file_path, sheet_name=sheet_name)
-        if len(df) > 20:
-            result = f"Excel file with {len(df)} rows and {len(df.columns)} columns:\n\n"
-            result += "First 10 rows:\n" + df.head(10).to_string(index=False)
-            result += f"\n\n... ({len(df) - 20} rows omitted) ...\n\n"
-            result += "Last 10 rows:\n" + df.tail(10).to_string(index=False)
-        else:
-            result = f"Excel file with {len(df)} rows and {len(df.columns)} columns:\n\n"
-            result += df.to_string(index=False)
-        return result
-    except Exception as e:
-        return f"Error reading Excel file: {str(e)}"
-
-@tool
-def read_text_file(file_path: str) -> str:
-    """Read a text file and return contents."""
-    try:
-        file_path_obj = Path(file_path)
-        if not file_path_obj.exists():
-            return f"Error: File not found at {file_path}"
-        encodings = ['utf-8', 'utf-16', 'iso-8859-1', 'cp1252']
-        for encoding in encodings:
-            try:
-                with open(file_path_obj, 'r', encoding=encoding) as f:
-                    return f.read()
-            except UnicodeDecodeError:
-                continue
-        return "Error: Could not decode file with any standard encoding"
-    except Exception as e:
-        return f"Error reading file: {str(e)}"
-
-# ------------------ GAIA AGENT ------------------
-class GaiaAgent:
-    """LangGraph-based agent with DeepSeek and enhanced tools."""
-    def __init__(self):
-        print("Initializing GaiaAgent with LangGraph and OpenRouter DeepSeek...")
-        self.llm = OpenRouterLLM(
-            model="deepseek/deepseek-v3.1-terminus",
-            temperature=0.1,
-            max_tokens=2000
+if __name__ == "__main__":
+    print("\n" + "-" * 30 + " App Starting " + "-" * 30)
+    # Check for SPACE_HOST and SPACE_ID at startup for information
+    space_host_startup = os.getenv("SPACE_HOST")
+    space_id_startup = os.getenv("SPACE_ID")  # Get SPACE_ID at startup
+
+    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 repo URLs if SPACE_ID is found
+        print(f"✅ SPACE_ID found: {space_id_startup}")
+        print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
+        print(
+            f"   Repo Tree URL: https://huggingface.co/spaces/"
+            f"{space_id_startup}/tree/main"
+        )
+    else:
+        print(
+            "ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL "
+            "cannot be determined."
         )
-        self.tools = [search_web, search_wikipedia, execute_python, read_excel_file, read_text_file]
-        prompt_modifier = self._get_system_prompt()
-
-        # Detect correct kwarg for your LangGraph version
-        sig = inspect.signature(create_react_agent)
-        accepted = sig.parameters.keys()
-        kwargs = {}
-        if "messages_modifier" in accepted:
-            kwargs["messages_modifier"] = prompt_modifier
-        elif "state_modifier" in accepted:
-            kwargs["state_modifier"] = prompt_modifier
-        elif "prompt" in accepted:
-            kwargs["prompt"] = prompt_modifier
-
-        self.agent = create_react_agent(self.llm, self.tools, **kwargs)
-        print("GaiaAgent initialized successfully!")
-
-    def _get_system_prompt(self) -> str:
-        return """You are an advanced AI agent designed to answer complex questions using all available tools, including web search, Wikipedia, Python execution, Excel and text file reading."""
-
-    def __call__(self, task_id: str, question: str) -> str:
-        try:
-            print(f"Processing task {task_id}: {question[:100]}...")
-            # Combine context from tools for better answers
-            wiki_text = search_wikipedia(question)
-            web_text = search_web(question)
-            combined_input = f"{wiki_text}\n\n{web_text}\n\nQuestion: {question}"
-            messages = [HumanMessage(content=combined_input)]
-            result = self.agent.invoke({"messages": messages})
-            final_message = result["messages"][-1]
-            answer = final_message.content
-            return self._clean_answer(answer)
-        except Exception as e:
-            return f"Agent error: {e}"
-
-    def _clean_answer(self, answer: str) -> str:
-        answer = answer.strip()
-        if "final answer:" in answer.lower():
-            parts = re.split(r'final answer:', answer, flags=re.IGNORECASE)
-            if len(parts) > 1:
-                answer = parts[-1].strip()
-        prefixes = ["The answer is", "Answer:", "Result:", "Solution:",
-                    "Based on", "Therefore", "In conclusion", "So the answer is"]
-        for prefix in prefixes:
-            if answer.lower().startswith(prefix.lower()):
-                answer = answer[len(prefix):].strip()
-                if answer.startswith(':'):
-                    answer = answer[1:].strip()
-                break
-        if len(answer.split()) <= 3:
-            answer = answer.strip('"\'.')
-        return answer
-
-# ------------------ GRADIO INTERFACE ------------------
-agent = GaiaAgent()
-
-def run_agent(prompt: str) -> str:
-    return agent("gaia_task", prompt)
-
-demo = gr.Interface(fn=run_agent, inputs="text", outputs="text", title="GAIA Agent")
 
-if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    print("-" * (60 + len(" App Starting ")) + "\n")
+
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    gaia_ui.launch(debug=True, share=True)