update

app.py

@@ -3,25 +3,202 @@ 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
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Basic Agent Definition ---
+# --- GAIA Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class BasicAgent:
+class GaiaAgent:
     def __init__(self):
-        print("BasicAgent initialized.")
+        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"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
+        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 BasicAgent on them, submits all answers,
+    Fetches all questions, runs the GaiaAgent on them, submits all answers,
     and displays the results.
     """
     # --- Determine HF Space Runtime URL and Repo URL ---
@@ -40,7 +217,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = BasicAgent()
+        agent = GaiaAgent()
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
@@ -142,7 +319,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner")
+    gr.Markdown("# GAIA Agent Evaluation Runner")
     gr.Markdown(
         """
         **Instructions:**
@@ -152,6 +329,13 @@ with gr.Blocks() as demo:
         3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
 
         ---
+        **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.
@@ -192,5 +376,5 @@ if __name__ == "__main__":
 
     print("-"*(60 + len(" App Starting ")) + "\n")
 
-    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    print("Launching Gradio Interface for GAIA Agent Evaluation...")
     demo.launch(debug=True, share=False)