Update app.py

app.py

@@ -5,83 +5,42 @@ import pandas as pd
 import re
 from openai import OpenAI
 from duckduckgo_search import DDGS
-import wikipediaapi
-from pytube import YouTube
-import whisper
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 GAIA_SYSTEM_PROMPT = """
 You are an expert at solving GAIA benchmark questions. Follow these rules:
 1. Think step-by-step before answering
-2. Format answers EXACTLY as required:
-   - Numbers: Plain digits without commas/units
-   - Strings: Minimal words, no articles/abbreviations
-   - Lists: Comma-separated values without spaces
-   - Multiple choice: Single uppercase letter
-3. For calculations, show your work then box the final answer
-4. When uncertain, search online for verification
-5. ALWAYS end with: FINAL ANSWER: [Your Answer]
+2. Format answers EXACTLY as required
+3. Use web search when needed
+4. ALWAYS end with: FINAL ANSWER: [Your Answer]
 """
 
-class EnhancedGaiaAgent:
+class GaiaAgent:
     def __init__(self):
-        print("Initializing Enhanced GAIA Agent")
+        print("Initializing GAIA Agent")
         self.client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-        self.wiki = wikipediaapi.Wikipedia('en')
-        self.model = whisper.load_model("base")
-        
         self.answer_patterns = [
             r"FINAL ANSWER:\s*(.+)",
             r"Final Answer:\s*(.+)",
-            r"\[ANSWER\]:\s*(.+)",
             r"Answer:\s*(.+)"
         ]
 
-    def web_search(self, query: str, max_results: int = 3) -> str:
+    def web_search(self, query: str) -> str:
+        """Simple web search implementation"""
         try:
             with DDGS() as ddgs:
-                results = [r for r in ddgs.text(query, max_results=max_results)]
+                results = [r for r in ddgs.text(query, max_results=3)]
             return "\n".join([f"{i+1}. {res['title']}: {res['body']}" for i, res in enumerate(results)])
         except Exception as e:
             print(f"Search error: {str(e)}")
             return ""
 
-    def get_wikipedia(self, topic: str) -> str:
-        try:
-            page = self.wiki.page(topic)
-            return page.summary[:2000] if page.exists() else ""
-        except Exception:
-            return ""
-
-    def transcribe_audio(self, audio_path: str) -> str:
-        try:
-            result = self.model.transcribe(audio_path)
-            return result["text"]
-        except Exception as e:
-            print(f"Transcription error: {str(e)}")
-            return ""
-
-    def extract_youtube_info(self, url: str) -> str:
-        try:
-            yt = YouTube(url)
-            return f"Title: {yt.title}\nLength: {yt.length}s"
-        except Exception:
-            return ""
-
     def __call__(self, question: str) -> str:
+        """Handle question answering"""
         print(f"Processing: {question[:60]}...")
         
-        if "youtube.com/watch" in question.lower():
-            return self.handle_youtube_question(question)
-        if "mp3" in question.lower() or "audio" in question.lower():
-            return self.handle_audio_question(question)
-        if "wikipedia" in question.lower():
-            return self.handle_wikipedia_question(question)
-        
-        return self.handle_general_question(question)
-
-    def handle_general_question(self, question: str) -> str:
+        # Determine if we need web search
         needs_search = any(word in question.lower() for word in 
                          ["current", "recent", "today", "latest", "who is", "what is"])
         
@@ -107,82 +66,22 @@ class EnhancedGaiaAgent:
             print(f"GPT error: {str(e)}")
             return "Error: Could not generate answer"
 
-    def handle_youtube_question(self, question: str) -> str:
-        try:
-            url = re.search(r"(https?://[^\s]+)", question).group(1)
-            video_info = self.extract_youtube_info(url)
-            
-            messages = [
-                {"role": "system", "content": GAIA_SYSTEM_PROMPT},
-                {"role": "system", "content": f"Video Info:\n{video_info}"},
-                {"role": "user", "content": question}
-            ]
-            
-            response = self.client.chat.completions.create(
-                model="gpt-4-turbo",
-                messages=messages,
-                temperature=0.1
-            )
-            return self.extract_final_answer(response.choices[0].message.content)
-        except Exception as e:
-            print(f"YouTube processing error: {str(e)}")
-            return "Error: Could not process video"
-
-    def handle_audio_question(self, question: str) -> str:
-        try:
-            audio_path = "temp_audio.mp3"  # Assume file is saved here
-            transcript = self.transcribe_audio(audio_path)
-            
-            messages = [
-                {"role": "system", "content": GAIA_SYSTEM_PROMPT},
-                {"role": "system", "content": f"Transcript:\n{transcript}"},
-                {"role": "user", "content": question}
-            ]
-            
-            response = self.client.chat.completions.create(
-                model="gpt-4-turbo",
-                messages=messages,
-                temperature=0.1
-            )
-            return self.extract_final_answer(response.choices[0].message.content)
-        except Exception as e:
-            print(f"Audio processing error: {str(e)}")
-            return "Error: Could not process audio"
-
-    def handle_wikipedia_question(self, question: str) -> str:
-        try:
-            topic_match = re.search(r"about (.*?)(?:that|which)", question, re.IGNORECASE)
-            topic = topic_match.group(1) if topic_match else ""
-            wiki_content = self.get_wikipedia(topic)
-            
-            messages = [
-                {"role": "system", "content": GAIA_SYSTEM_PROMPT},
-                {"role": "system", "content": f"Wikipedia Context:\n{wiki_content}"},
-                {"role": "user", "content": question}
-            ]
-            
-            response = self.client.chat.completions.create(
-                model="gpt-4-turbo",
-                messages=messages,
-                temperature=0.1
-            )
-            return self.extract_final_answer(response.choices[0].message.content)
-        except Exception as e:
-            print(f"Wikipedia processing error: {str(e)}")
-            return "Error: Could not process Wikipedia query"
-
     def extract_final_answer(self, response: str) -> str:
+        """Extract the final answer from the response"""
         for pattern in self.answer_patterns:
             match = re.search(pattern, response, re.IGNORECASE)
             if match:
                 answer = match.group(1).strip()
-                return re.sub(r"[^a-zA-Z0-9,. ]", "", answer)[:200]
+                # Clean up the answer
+                answer = re.sub(r"[^a-zA-Z0-9,. ]", "", answer)
+                return answer[:200]  # Limit length
         
+        # Fallback: return the last line
         lines = response.strip().split('\n')
         return lines[-1].strip() if lines else "No answer found"
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    """Original submission function with agent replaced"""
+    """Handle the full submission process"""
     space_id = os.getenv("SPACE_ID")
 
     if profile:
@@ -197,27 +96,25 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     submit_url = f"{api_url}/submit"
 
     try:
-        agent = EnhancedGaiaAgent()  # Using our new agent
+        agent = GaiaAgent()
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
     
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-    print(agent_code)
 
     try:
         response = requests.get(questions_url, timeout=15)
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
-            return "Fetched questions list is empty or invalid format.", None
+            return "Fetched questions list is empty.", None
         print(f"Fetched {len(questions_data)} questions.")
     except Exception as e:
         return f"Error fetching questions: {e}", None
 
     results_log = []
     answers_payload = []
-    print(f"Running agent on {len(questions_data)} questions...")
     for item in questions_data:
         task_id = item.get("task_id")
         question_text = item.get("question")
@@ -231,11 +128,13 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
 
     if not answers_payload:
-        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+        return "Agent did not produce any answers.", pd.DataFrame(results_log)
 
-    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
-    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
-    print(status_update)
+    submission_data = {
+        "username": username.strip(),
+        "agent_code": agent_code,
+        "answers": answers_payload
+    }
 
     try:
         response = requests.post(submit_url, json=submission_data, timeout=60)
@@ -243,10 +142,8 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         result_data = response.json()
         final_status = (
             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.')}"
+            f"Score: {result_data.get('score', 'N/A')}% "
+            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)"
         )
         return final_status, pd.DataFrame(results_log)
     except Exception as e:
@@ -254,12 +151,12 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
 with gr.Blocks() as demo:
     gr.Markdown("# GAIA Benchmark Agent")
-    gr.Markdown("Optimized agent for GAIA benchmark certification")
+    gr.Markdown("Run the agent to answer GAIA benchmark questions")
     
     gr.LoginButton()
-    run_button = gr.Button("Run Evaluation & Submit All Answers")
-    status_output = gr.Textbox(label="Run Status", lines=5)
-    results_table = gr.DataFrame(label="Results", wrap=True)
+    run_button = gr.Button("Run Evaluation")
+    status_output = gr.Textbox(label="Status", lines=3)
+    results_table = gr.DataFrame(label="Results")
     
     run_button.click(
         fn=run_and_submit_all,
@@ -267,5 +164,5 @@ with gr.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " GAIA Agent Starting " + "-"*30)
-    demo.launch(debug=True, share=False)
+    print("Starting GAIA Agent...")
+    demo.launch()