Update app.py

app.py

@@ -3,14 +3,7 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
-import re
-import json
-import urllib.parse
-from bs4 import BeautifulSoup
-import numpy as np
-import sympy as sp
-from datetime import datetime, timedelta
-import dateutil.parser
+from agent import create_agent
 
 # (Keep Constants as is)
 # --- Constants ---
@@ -18,187 +11,10 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # --- GAIA Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class GaiaAgent:
-    def __init__(self):
-        print("GaiaAgent initialized.")
-        self.session = requests.Session()
-        self.session.headers.update({
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
-        })
-    
-    def search_web(self, query, max_results=3):
-        """Perform web search using DuckDuckGo instant answers or basic search"""
-        try:
-            # Try DuckDuckGo instant answer API first
-            ddg_url = f"https://api.duckduckgo.com/?q={urllib.parse.quote(query)}&format=json&no_html=1&skip_disambig=1"
-            response = self.session.get(ddg_url, timeout=10)
-            if response.status_code == 200:
-                data = response.json()
-                if data.get('AbstractText'):
-                    return data['AbstractText']
-                if data.get('Answer'):
-                    return data['Answer']
-            
-            # Fallback to basic web scraping (limited)
-            search_url = f"https://html.duckduckgo.com/html/?q={urllib.parse.quote(query)}"
-            response = self.session.get(search_url, timeout=10)
-            if response.status_code == 200:
-                soup = BeautifulSoup(response.text, 'html.parser')
-                results = soup.find_all('a', class_='result__snippet', limit=max_results)
-                if results:
-                    return " ".join([r.get_text().strip() for r in results])
-            
-            return f"Unable to search for: {query}"
-        except Exception as e:
-            return f"Search error: {str(e)}"
-    
-    def calculate_math(self, expression):
-        """Safely evaluate mathematical expressions"""
-        try:
-            # Clean the expression
-            expression = re.sub(r'[^0-9+\-*/().\s]', '', expression)
-            # Use sympy for safe evaluation
-            result = sp.sympify(expression).evalf()
-            return str(result)
-        except Exception as e:
-            return f"Math error: {str(e)}"
-    
-    def parse_date(self, date_string):
-        """Parse various date formats"""
-        try:
-            parsed_date = dateutil.parser.parse(date_string)
-            return parsed_date.strftime("%Y-%m-%d")
-        except Exception as e:
-            return f"Date parsing error: {str(e)}"
-    
-    def extract_numbers(self, text):
-        """Extract numbers from text"""
-        numbers = re.findall(r'-?\d+\.?\d*', text)
-        return [float(n) for n in numbers if n]
-    
-    def process_question(self, question):
-        """Process different types of questions with various strategies"""
-        question_lower = question.lower()
-        
-        # Mathematical questions
-        if any(word in question_lower for word in ['calculate', 'compute', 'math', '+', '-', '*', '/', 'equals', 'sum', 'product']):
-            numbers = self.extract_numbers(question)
-            if len(numbers) >= 2:
-                if 'sum' in question_lower or '+' in question:
-                    return str(sum(numbers))
-                elif 'product' in question_lower or '*' in question:
-                    result = 1
-                    for n in numbers:
-                        result *= n
-                    return str(result)
-                elif 'difference' in question_lower or '-' in question:
-                    return str(numbers[0] - numbers[1] if len(numbers) >= 2 else numbers[0])
-            
-            # Try to extract and evaluate mathematical expressions
-            math_pattern = r'[\d+\-*/().\s]+'
-            math_expr = re.search(math_pattern, question)
-            if math_expr:
-                return self.calculate_math(math_expr.group())
-        
-        # Date/time questions
-        if any(word in question_lower for word in ['date', 'time', 'year', 'month', 'day', 'when', 'ago', 'from now']):
-            # Try to extract dates
-            date_patterns = [
-                r'\d{4}-\d{2}-\d{2}',
-                r'\d{1,2}/\d{1,2}/\d{4}',
-                r'\d{1,2}-\d{1,2}-\d{4}'
-            ]
-            for pattern in date_patterns:
-                dates = re.findall(pattern, question)
-                if dates:
-                    return self.parse_date(dates[0])
-            
-            # If asking about current date/time
-            if 'today' in question_lower or 'now' in question_lower:
-                return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-        
-        # Questions that might need web search
-        if any(word in question_lower for word in ['who is', 'what is', 'where is', 'when did', 'how many', 'capital of', 'population of']):
-            search_result = self.search_web(question)
-            if search_result and "error" not in search_result.lower():
-                return search_result
-        
-        # Geography questions
-        if any(word in question_lower for word in ['country', 'city', 'capital', 'continent', 'ocean', 'river']):
-            search_result = self.search_web(question)
-            if search_result and "error" not in search_result.lower():
-                return search_result
-        
-        # Science/factual questions
-        if any(word in question_lower for word in ['element', 'chemical', 'planet', 'temperature', 'speed of light', 'gravity']):
-            search_result = self.search_web(question)
-            if search_result and "error" not in search_result.lower():
-                return search_result
-        
-        # General knowledge questions - try web search
-        search_result = self.search_web(question)
-        if search_result and "error" not in search_result.lower() and len(search_result) > 20:
-            return search_result
-        
-        # If no specific strategy worked, provide a thoughtful response
-        return self.general_reasoning(question)
-    
-    def general_reasoning(self, question):
-        """Apply general reasoning for questions that don't fit specific categories"""
-        question_lower = question.lower()
-        
-        # Yes/No questions
-        if question.endswith('?') and any(word in question_lower for word in ['is', 'are', 'can', 'does', 'do', 'will', 'would']):
-            # Simple heuristics for common yes/no patterns
-            if 'impossible' in question_lower or 'cannot' in question_lower:
-                return "No"
-            elif 'possible' in question_lower or 'can' in question_lower:
-                return "Yes"
-        
-        # Multiple choice detection
-        if re.search(r'\b[A-D]\)', question) or 'choose' in question_lower:
-            # Try to extract the most likely answer based on context
-            options = re.findall(r'[A-D]\)\s*([^A-D\n]+)', question)
-            if options:
-                return options[0].strip()  # Return first option as fallback
-        
-        # Number-based questions
-        numbers = self.extract_numbers(question)
-        if numbers:
-            if 'how many' in question_lower:
-                return str(int(max(numbers)))  # Return largest number found
-            elif 'which year' in question_lower or 'what year' in question_lower:
-                years = [n for n in numbers if 1900 <= n <= 2024]
-                if years:
-                    return str(int(years[0]))
-        
-        # Default fallback - try to give a reasonable answer
-        if 'what' in question_lower:
-            return "Information not available"
-        elif 'how' in question_lower:
-            return "Process not specified"
-        elif 'where' in question_lower:
-            return "Location not determined"
-        elif 'when' in question_lower:
-            return "Time not specified"
-        elif 'who' in question_lower:
-            return "Person not identified"
-        else:
-            return "Unable to determine answer"
-
-    def __call__(self, question: str) -> str:
-        print(f"GaiaAgent received question (first 100 chars): {question[:100]}...")
-        try:
-            answer = self.process_question(question)
-            print(f"GaiaAgent returning answer: {answer[:100]}...")
-            return answer
-        except Exception as e:
-            print(f"Error in GaiaAgent: {e}")
-            return f"Error processing question: {str(e)}"
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
-    Fetches all questions, runs the GaiaAgent on them, submits all answers,
+    Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
     """
     # --- Determine HF Space Runtime URL and Repo URL ---
@@ -217,7 +33,8 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = GaiaAgent()
+        agent = create_agent()
+        print("GAIA Agent initialized successfully.")
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
@@ -318,33 +135,71 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
 
 # --- Build Gradio Interface using Blocks ---
+def check_api_keys():
+    """Check if required API keys are available"""
+    openai_key = os.getenv("OPENAI_API_KEY")
+    tavily_key = os.getenv("TAVILY_API_KEY")
+    
+    status = []
+    if openai_key:
+        status.append("✅ OpenAI API Key: Found")
+    else:
+        status.append("❌ OpenAI API Key: Missing")
+    
+    if tavily_key:
+        status.append("✅ Tavily API Key: Found")
+    else:
+        status.append("❌ Tavily API Key: Missing")
+    
+    return "\n".join(status)
+
 with gr.Blocks() as demo:
-    gr.Markdown("# GAIA Agent Evaluation Runner")
+    gr.Markdown("# GAIA Dataset 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.
+        1. **Clone this space** to your own account
+        2. **Set up API Keys** in your Space Settings:
+           - Go to Settings → Repository secrets
+           - Add `OPENAI_API_KEY` with your OpenAI API key
+           - Add `TAVILY_API_KEY` with your Tavily API key
+           - Restart the space after adding secrets
+        3. **Log in** to your Hugging Face account using the button below
+        4. **Click 'Run Evaluation & Submit All Answers'** to process all questions
 
         ---
+        **⚠️ Important:**
+        - You need valid API keys for OpenAI and Tavily for the agent to work
+        - Never put API keys directly in your code - always use HF Space secrets
+        - Processing all questions may take several minutes
+        
         **Agent Capabilities:**
-        - Mathematical calculations and computations
-        - Web search for factual information
-        - Date and time processing
-        - General reasoning and pattern recognition
-        - Multi-step problem solving
-
-        **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 seperate action or even to answer the questions in async.
+        - 🧮 Advanced mathematical calculations
+        - 🌐 Web search for factual information  
+        - 📅 Date and time processing
+        - 🤔 Multi-step reasoning with LangGraph
+        
+        **Where to get API Keys:**
+        - 🔑 **OpenAI**: Get your API key at [platform.openai.com](https://platform.openai.com/api-keys)
+        - 🔍 **Tavily**: Sign up and get your API key at [tavily.com](https://tavily.com)
         """
     )
 
     gr.LoginButton()
+    
+    # API Key status check
+    api_status = gr.Textbox(
+        label="API Keys Status",
+        value=check_api_keys(),
+        interactive=False,
+        lines=3
+    )
+    
+    refresh_status_btn = gr.Button("🔄 Refresh API Status", size="sm")
+    refresh_status_btn.click(fn=check_api_keys, outputs=api_status)
 
-    run_button = gr.Button("Run Evaluation & Submit All Answers")
+    run_button = gr.Button("Run Evaluation & Submit All Answers", variant="primary")
 
     status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
     # Removed max_rows=10 from DataFrame constructor
@@ -376,5 +231,5 @@ if __name__ == "__main__":
 
     print("-"*(60 + len(" App Starting ")) + "\n")
 
-    print("Launching Gradio Interface for GAIA Agent Evaluation...")
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
     demo.launch(debug=True, share=False)