rollback

app.py

@@ -3,220 +3,32 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
-import json
-import re
-from typing import Dict, Any, Optional
-import time
 
+# (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-class EnhancedAgent:
-    """
-    An enhanced AI agent that can handle various types of questions using web search,
-    mathematical reasoning, and structured problem-solving approaches.
-    """
-    
+# --- Basic Agent Definition ---
+# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+class BasicAgent:
     def __init__(self):
-        print("EnhancedAgent initialized.")
-        # You can add API keys or other initialization here
-        self.search_timeout = 10
-        self.max_retries = 3
-        
-    def search_web(self, query: str, max_results: int = 5) -> list:
-        """
-        Perform web search using a search API (you'll need to implement this with your preferred service)
-        For now, this is a placeholder - you should integrate with Google Custom Search, Bing, or similar
-        """
-        try:
-            # Placeholder for web search - replace with actual API call
-            # Example with requests to a search service:
-            # response = requests.get(f"https://your-search-api.com/search?q={query}")
-            # return response.json()['results']
-            
-            # For demonstration, returning empty results
-            print(f"Web search query: {query}")
-            return []
-        except Exception as e:
-            print(f"Web search error: {e}")
-            return []
-    
-    def extract_numbers(self, text: str) -> list:
-        """Extract numbers from text"""
-        return re.findall(r'-?\d+\.?\d*', text)
-    
-    def is_math_question(self, question: str) -> bool:
-        """Determine if question requires mathematical computation"""
-        math_keywords = ['calculate', 'compute', 'sum', 'multiply', 'divide', 'subtract', 
-                        'percentage', 'average', 'total', 'how many', 'how much']
-        return any(keyword in question.lower() for keyword in math_keywords)
-    
-    def is_factual_question(self, question: str) -> bool:
-        """Determine if question requires factual lookup"""
-        factual_keywords = ['who is', 'what is', 'when did', 'where is', 'which country',
-                           'capital of', 'president of', 'founded in', 'born in']
-        return any(keyword in question.lower() for keyword in factual_keywords)
-    
-    def solve_math_question(self, question: str) -> str:
-        """Handle mathematical questions"""
-        try:
-            # Extract numbers from the question
-            numbers = self.extract_numbers(question)
-            
-            # Simple mathematical operations based on keywords
-            if 'sum' in question.lower() or 'add' in question.lower():
-                if len(numbers) >= 2:
-                    result = sum(float(n) for n in numbers)
-                    return str(result)
-            
-            elif 'multiply' in question.lower() or 'product' in question.lower():
-                if len(numbers) >= 2:
-                    result = 1
-                    for n in numbers:
-                        result *= float(n)
-                    return str(result)
-            
-            elif 'subtract' in question.lower():
-                if len(numbers) >= 2:
-                    result = float(numbers[0]) - float(numbers[1])
-                    return str(result)
-            
-            elif 'divide' in question.lower():
-                if len(numbers) >= 2 and float(numbers[1]) != 0:
-                    result = float(numbers[0]) / float(numbers[1])
-                    return str(result)
-            
-            elif 'percentage' in question.lower() or '%' in question:
-                if len(numbers) >= 2:
-                    result = (float(numbers[0]) / float(numbers[1])) * 100
-                    return f"{result}%"
-            
-            # If no specific operation found, return the first number found
-            if numbers:
-                return numbers[0]
-                
-        except Exception as e:
-            print(f"Math solving error: {e}")
-        
-        return "Unable to solve mathematical question"
-    
-    def handle_factual_question(self, question: str) -> str:
-        """Handle factual questions that might need web search"""
-        # First try to answer with common knowledge
-        question_lower = question.lower()
-        
-        # Common factual answers (you can expand this)
-        if 'capital of france' in question_lower:
-            return "Paris"
-        elif 'capital of germany' in question_lower:
-            return "Berlin"
-        elif 'capital of japan' in question_lower:
-            return "Tokyo"
-        elif 'president of united states' in question_lower or 'us president' in question_lower:
-            return "Joe Biden"  # Update based on current information
-        
-        # If no direct match, try web search
-        search_results = self.search_web(question)
-        if search_results:
-            # Process search results to extract answer
-            # This is a simplified approach - in practice, you'd want more sophisticated extraction
-            for result in search_results[:3]:
-                if 'snippet' in result:
-                    return result['snippet'][:200]  # Return first snippet
-        
-        return "Information not available"
-    
-    def analyze_question_type(self, question: str) -> str:
-        """Analyze what type of question this is"""
-        if self.is_math_question(question):
-            return "mathematical"
-        elif self.is_factual_question(question):
-            return "factual"
-        elif any(word in question.lower() for word in ['file', 'document', 'image', 'data']):
-            return "file_based"
-        else:
-            return "general"
-    
+        print("BasicAgent initialized.")
     def __call__(self, question: str) -> str:
-        """
-        Main agent function that processes questions and returns answers
-        """
-        print(f"Agent received question (first 100 chars): {question[:100]}...")
-        
-        try:
-            # Clean the question
-            question = question.strip()
-            
-            # Analyze question type
-            question_type = self.analyze_question_type(question)
-            print(f"Question type identified: {question_type}")
-            
-            # Route to appropriate handler
-            if question_type == "mathematical":
-                answer = self.solve_math_question(question)
-            elif question_type == "factual":
-                answer = self.handle_factual_question(question)
-            elif question_type == "file_based":
-                # For file-based questions, we'd need to access the files via the API
-                # This would require additional implementation
-                answer = "File-based question processing not yet implemented"
-            else:
-                # General reasoning approach
-                answer = self.general_reasoning(question)
-            
-            print(f"Agent returning answer: {answer}")
-            return answer
-            
-        except Exception as e:
-            print(f"Error in agent processing: {e}")
-            return "Error processing question"
-    
-    def general_reasoning(self, question: str) -> str:
-        """Handle general questions with basic reasoning"""
-        try:
-            # Simple pattern matching for common question types
-            question_lower = question.lower()
-            
-            if 'yes' in question_lower and 'no' in question_lower:
-                # Yes/No question - make a reasonable guess
-                if any(word in question_lower for word in ['is', 'are', 'can', 'will', 'should']):
-                    return "Yes"
-                else:
-                    return "No"
-            
-            elif 'how many' in question_lower:
-                # Try to extract numbers from context
-                numbers = self.extract_numbers(question)
-                if numbers:
-                    return numbers[-1]  # Return the last number found
-                else:
-                    return "1"  # Default guess
-            
-            elif 'which' in question_lower or 'what' in question_lower:
-                # Try to find the most likely answer from the question context
-                words = question.split()
-                # Look for capitalized words (potential proper nouns)
-                proper_nouns = [word for word in words if word[0].isupper() and len(word) > 1]
-                if proper_nouns:
-                    return proper_nouns[0]
-            
-            # Default response for unhandled cases
-            return "Unable to determine answer"
-            
-        except Exception as e:
-            print(f"General reasoning error: {e}")
-            return "Error in reasoning"
+        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
 
-def run_and_submit_all(profile: gr.OAuthProfile | None):
+def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
-    Fetches all questions, runs the EnhancedAgent 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 ---
-    space_id = os.getenv("SPACE_ID")  # Get the SPACE_ID for sending link to the code
+    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
 
     if profile:
-        username = f"{profile.username}"
+        username= f"{profile.username}"
         print(f"User logged in: {username}")
     else:
         print("User not logged in.")
@@ -226,14 +38,13 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Instantiate Agent
+    # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = EnhancedAgent()  # Using our enhanced agent
+        agent = BasicAgent()
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
-    
-    # Agent code URL
+    # In the case of an app running as a hugging Face space, this link points toward your codebase ( usefull for others so please keep it public)
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
     print(agent_code)
 
@@ -244,16 +55,16 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         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("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 requests.exceptions.JSONDecodeError as e:
-        print(f"Error decoding JSON response from questions endpoint: {e}")
-        print(f"Response text: {response.text[:500]}")
-        return f"Error decoding server response for questions: {e}", None
+         print(f"Error decoding JSON response from questions endpoint: {e}")
+         print(f"Response text: {response.text[:500]}")
+         return f"Error decoding server response for 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
@@ -262,34 +73,19 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     results_log = []
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")
-    
-    for i, item in enumerate(questions_data):
+    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:
-            print(f"Processing question {i+1}/{len(questions_data)}: {task_id}")
             submitted_answer = agent(question_text)
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
-            results_log.append({
-                "Task ID": task_id, 
-                "Question": question_text[:100] + "..." if len(question_text) > 100 else question_text,
-                "Submitted Answer": submitted_answer
-            })
-            
-            # Small delay to avoid overwhelming the system
-            time.sleep(0.1)
-            
+            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[:100] + "..." if len(question_text) > 100 else question_text,
-                "Submitted Answer": f"AGENT ERROR: {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.")
@@ -346,24 +142,19 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Enhanced AI Agent Evaluation Runner")
+    gr.Markdown("# Basic Agent Evaluation Runner")
     gr.Markdown(
         """
         **Instructions:**
 
-        1. This enhanced agent can handle various types of questions including mathematical, factual, and general reasoning questions.
-        2. Log in to your Hugging Face account using the button below.
-        3. Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
-
-        **Agent Features:**
-        - Mathematical question solving
-        - Factual question handling with web search capability
-        - General reasoning for complex questions
-        - Question type classification
-        - Error handling and retry mechanisms
+        1.  Please clone this space, then modify the code to define your agent's logic within the `BasicAgent` class or outside if necessary.
+        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.
 
         ---
-        **Note:** This may take several minutes to process all questions.
+        **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.
         """
     )
 
@@ -372,6 +163,7 @@ with gr.Blocks() as demo:
     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(
@@ -380,10 +172,10 @@ with gr.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " Enhanced Agent App Starting " + "-"*30)
+    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")
+    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
 
     if space_host_startup:
         print(f"✅ SPACE_HOST found: {space_host_startup}")
@@ -391,14 +183,14 @@ if __name__ == "__main__":
     else:
         print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
 
-    if space_id_startup:
+    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/{space_id_startup}/tree/main")
     else:
         print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
 
-    print("-"*(60 + len(" Enhanced Agent App Starting ")) + "\n")
+    print("-"*(60 + len(" App Starting ")) + "\n")
 
-    print("Launching Gradio Interface for Enhanced Agent Evaluation...")
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
     demo.launch(debug=True, share=False)