Update app.py

app.py

@@ -9,8 +9,7 @@ from duckduckgo_search import DDGS
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-TIMEOUT_PER_QUESTION = 30
-DELAY_BETWEEN_QUESTIONS = 6  # Longer delay to avoid rate limits
+DELAY_BETWEEN_QUESTIONS = 8  # 8 seconds between questions to avoid rate limits
 
 # ============================================
 # GROQ CLIENT
@@ -23,32 +22,27 @@ def get_groq_client():
     return Groq(api_key=api_key)
 
 # ============================================
-# TOOL FUNCTIONS
+# TOOLS
 # ============================================
 
-def web_search(query: str, num_results: int = 3) -> str:
-    """Search the web"""
+def web_search(query: str) -> str:
     try:
         with DDGS() as ddgs:
-            results = list(ddgs.text(query, max_results=num_results))
+            results = list(ddgs.text(query, max_results=3))
         if not results:
-            return "No results found"
-        output = []
-        for r in results:
-            output.append(f"- {r.get('title', '')}: {r.get('body', '')}")
-        return "\n".join(output)
-    except Exception as e:
-        return f"Search error: {e}"
+            return "No results"
+        return "\n".join([f"- {r.get('title','')}: {r.get('body','')}" for r in results])
+    except:
+        return "Search failed"
 
 
 def get_task_file(task_id: str) -> dict:
-    """Get GAIA task file"""
     try:
         url = f"https://agents-course-unit4-scoring.hf.space/files/{task_id}"
         response = requests.get(url, timeout=15)
         
         if response.status_code == 404:
-            return {"has_file": False, "content": ""}
+            return {"has_file": False}
         
         content_type = response.headers.get('content-type', '').lower()
         disposition = response.headers.get('content-disposition', '')
@@ -57,138 +51,97 @@ def get_task_file(task_id: str) -> dict:
         if 'filename=' in disposition:
             filename = disposition.split('filename=')[-1].strip('"\'')
         
-        result = {"has_file": True, "filename": filename, "type": content_type}
-        
-        # Text/code files
+        # Text files
         if 'text' in content_type or filename.endswith(('.txt', '.py', '.md', '.csv', '.json')):
-            result["content"] = response.text[:6000]
-            return result
+            return {"has_file": True, "content": response.text[:5000]}
         
-        # Excel files
-        if 'spreadsheet' in content_type or 'excel' in content_type or filename.endswith(('.xlsx', '.xls')):
+        # Excel
+        if 'excel' in content_type or 'spreadsheet' in content_type or filename.endswith(('.xlsx', '.xls')):
             try:
                 from io import BytesIO
                 df = pd.read_excel(BytesIO(response.content))
-                result["content"] = f"Excel data:\n{df.to_string()}"
-                return result
+                return {"has_file": True, "content": df.to_string()}
             except:
-                result["content"] = "Excel file (cannot parse)"
-                return result
+                return {"has_file": True, "content": "[Excel file - parse failed]"}
         
-        # Images - can't process
+        # Image
         if 'image' in content_type:
-            result["content"] = "[IMAGE FILE - Cannot analyze]"
-            result["is_image"] = True
-            return result
-        
-        result["content"] = f"[Binary file: {content_type}]"
-        return result
+            return {"has_file": True, "content": "[IMAGE - cannot process]", "is_image": True}
         
-    except Exception as e:
-        return {"has_file": False, "content": ""}
+        return {"has_file": True, "content": f"[Binary: {content_type}]"}
+    except:
+        return {"has_file": False}
 
 
 def reverse_string(text: str) -> str:
     return text[::-1]
 
 
-def is_reversed_text(text: str) -> bool:
-    indicators = ['.rewsna', 'eht sa', 'tfel', 'drow eht']
-    return any(ind in text.lower() for ind in indicators)
+def is_reversed(text: str) -> bool:
+    return any(x in text.lower() for x in ['.rewsna', 'eht sa', 'tfel', 'drow eht'])
 
 
 # ============================================
-# AGENT CLASS
+# AGENT
 # ============================================
 
 class BasicAgent:
     def __init__(self):
         print("Initializing Groq agent...")
         self.client = get_groq_client()
-        print("✅ Agent ready!")
+        print("✅ Ready!")
     
-    def ask_llm(self, prompt: str) -> str:
-        """Ask Groq - using faster model with better rate limits"""
-        max_retries = 2
-        
-        for attempt in range(max_retries):
+    def ask(self, prompt: str) -> str:
+        for attempt in range(3):
             try:
-                # Use mixtral - good balance of speed and quality
                 response = self.client.chat.completions.create(
-                    model="mixtral-8x7b-32768",  # Better rate limits than llama-70b
+                    model="llama-3.1-8b-instant",  # Faster model with better rate limits
                     messages=[{"role": "user", "content": prompt}],
                     temperature=0,
-                    max_tokens=150,
-                    timeout=TIMEOUT_PER_QUESTION,
+                    max_tokens=100,
                 )
                 return response.choices[0].message.content.strip()
             except Exception as e:
                 if "rate" in str(e).lower() or "429" in str(e):
-                    wait = (attempt + 1) * 10
-                    print(f"    ⏳ Rate limited, waiting {wait}s...")
+                    wait = (attempt + 1) * 15
+                    print(f"    ⏳ Rate limit, waiting {wait}s...")
                     time.sleep(wait)
                 else:
                     return f"Error: {e}"
-        
         return "unknown"
     
-    def clean_answer(self, answer: str) -> str:
-        # Remove prefixes
-        for prefix in ["Answer:", "The answer is:", "Final answer:", "A:", "The answer is", "**"]:
-            if answer.lower().startswith(prefix.lower()):
-                answer = answer[len(prefix):].strip()
+    def __call__(self, question: str, task_id: str = None) -> str:
+        context = ""
+        
+        # Handle reversed text
+        if is_reversed(question):
+            question = reverse_string(question)
+        
+        # Get file if exists
+        if task_id:
+            file = get_task_file(task_id)
+            if file.get("has_file") and file.get("content"):
+                context = f"FILE: {file['content']}\n\n"
         
-        # Remove quotes and trailing punctuation
-        answer = answer.strip('"\'')
-        if answer.endswith('.') and len(answer.split()) <= 3:
-            answer = answer[:-1]
+        # Search if needed and no file
+        if not context:
+            keywords = ["who", "what", "when", "where", "how many", "album", "actor", "surname", "wikipedia"]
+            if any(k in question.lower() for k in keywords):
+                results = web_search(question[:80])
+                if results != "Search failed":
+                    context = f"INFO: {results}\n\n"
         
-        # Remove markdown
-        answer = answer.replace("**", "").strip()
+        prompt = f"{context}Q: {question}\n\nAnswer with ONLY the final answer, nothing else:"
+        
+        answer = self.ask(prompt)
+        
+        # Clean
+        for p in ["Answer:", "The answer is:", "A:", "Final answer:"]:
+            if answer.lower().startswith(p.lower()):
+                answer = answer[len(p):].strip()
+        answer = answer.strip('"\'.')
         
         return answer
-    
-    def __call__(self, question: str, task_id: str = None) -> str:
-        try:
-            context = ""
-            
-            # Check for reversed text
-            if is_reversed_text(question):
-                question = reverse_string(question)
-                context += f"[Decoded reversed text]\n"
-            
-            # Check for file
-            if task_id:
-                file_info = get_task_file(task_id)
-                if file_info.get("has_file") and file_info.get("content"):
-                    context += f"FILE:\n{file_info['content']}\n\n"
-            
-            # Web search for questions that need it
-            needs_search = any(kw in question.lower() for kw in [
-                "who ", "what ", "when ", "where ", "how many", "how much",
-                "album", "actor", "movie", "wikipedia", "surname", "athlete",
-                "pitcher", "country", "competition", "nominated"
-            ])
-            
-            # Don't search if we have file content
-            if context and "FILE:" in context:
-                needs_search = False
-            
-            if needs_search:
-                search_results = web_search(question[:100], 3)
-                if "No results" not in search_results:
-                    context += f"SEARCH RESULTS:\n{search_results}\n\n"
-            
-            prompt = f"""{context}Question: {question}
-
-Give ONLY the final answer. No explanation. Be precise."""
-
-            answer = self.ask_llm(prompt)
-            return self.clean_answer(answer)
-            
-        except Exception as e:
-            print(f"    Error: {e}")
-            return "unknown"
 
 
 # ============================================
@@ -202,71 +155,63 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     username = profile.username
     space_id = os.getenv("SPACE_ID")
     
-    print(f"\n{'='*50}")
-    print(f"User: {username}")
-    
     if not os.environ.get("GROQ_API_KEY"):
-        return "❌ Add GROQ_API_KEY to Space secrets!", None
-    
-    print("✅ GROQ_API_KEY found")
-    print(f"{'='*50}\n")
+        return "❌ Add GROQ_API_KEY to secrets!", None
+
+    print(f"\n{'='*40}\nUser: {username}\n{'='*40}")
 
     try:
         agent = BasicAgent()
     except Exception as e:
-        return f"❌ Agent init failed: {e}", None
+        return f"❌ Init failed: {e}", None
 
     try:
         questions = requests.get(f"{DEFAULT_API_URL}/questions", timeout=15).json()
         print(f"���� {len(questions)} questions\n")
     except Exception as e:
-        return f"❌ Failed to fetch questions: {e}", None
+        return f"❌ Fetch failed: {e}", None
 
     results = []
     answers = []
-    start_time = time.time()
+    start = time.time()
     
     for i, q in enumerate(questions):
         task_id = q.get("task_id")
         question = q.get("question", "")
         
-        print(f"[{i+1}/{len(questions)}] {question[:60]}...")
+        print(f"[{i+1}/{len(questions)}] {question[:50]}...")
         
-        try:
-            answer = agent(question, task_id)
-            print(f"    → {answer[:50]}")
-        except Exception as e:
-            answer = "unknown"
-            print(f"    ✗ {e}")
+        answer = agent(question, task_id)
+        print(f"    → {answer[:40]}")
         
         answers.append({"task_id": task_id, "submitted_answer": answer})
-        results.append({"#": i+1, "Question": question[:50]+"...", "Answer": answer[:60]})
+        results.append({"#": i+1, "Q": question[:40]+"...", "A": answer[:50]})
         
-        # Delay between questions
         if i < len(questions) - 1:
             time.sleep(DELAY_BETWEEN_QUESTIONS)
 
-    total_time = time.time() - start_time
-    print(f"\n⏱️ {total_time:.0f}s total")
+    total = time.time() - start
+    print(f"\n⏱️ {total:.0f}s")
 
-    # Submit
     try:
-        submission = {
-            "username": username,
-            "agent_code": f"https://huggingface.co/spaces/{space_id}/tree/main",
-            "answers": answers
-        }
-        result = requests.post(f"{DEFAULT_API_URL}/submit", json=submission, timeout=60).json()
+        result = requests.post(
+            f"{DEFAULT_API_URL}/submit",
+            json={
+                "username": username,
+                "agent_code": f"https://huggingface.co/spaces/{space_id}/tree/main",
+                "answers": answers
+            },
+            timeout=60
+        ).json()
         
         score = result.get('score', 0)
         correct = result.get('correct_count', 0)
-        total = result.get('total_attempted', 0)
+        total_q = result.get('total_attempted', 0)
         
-        status = f"✅ Done in {total_time:.0f}s\n\n🎯 Score: {score}% ({correct}/{total})\n\n"
+        status = f"✅ Done in {total:.0f}s\n\n🎯 {score}% ({correct}/{total_q})\n\n"
         status += "🎉 PASSED!" if score >= 30 else f"Need {30-score}% more"
         
         return status, pd.DataFrame(results)
-        
     except Exception as e:
         return f"❌ Submit failed: {e}", pd.DataFrame(results)
 
@@ -276,17 +221,16 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 # ============================================
 
 with gr.Blocks() as demo:
-    gr.Markdown("# 🎯 GAIA Agent - Unit 4")
-    gr.Markdown("**Groq + Mixtral 8x7B** (better rate limits)")
-
+    gr.Markdown("# 🎯 GAIA Agent")
+    gr.Markdown("Groq + Llama 3.1 8B (fast, good rate limits)")
+    
     gr.LoginButton()
     run_btn = gr.Button("🚀 Run", variant="primary", size="lg")
     status = gr.Textbox(label="Status", lines=5)
     table = gr.DataFrame(label="Results")
-
+    
     run_btn.click(run_and_submit_all, outputs=[status, table])
 
 if __name__ == "__main__":
-    print("🎯 GAIA Agent Starting...")
     print(f"GROQ_API_KEY: {'✅' if os.environ.get('GROQ_API_KEY') else '❌'}")
     demo.launch()