Update app.py

app.py

@@ -1,328 +1,117 @@
 import os
-import re
 import time
 import requests
 import gradio as gr
 import pandas as pd
 from groq import Groq
-from duckduckgo_search import DDGS
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-DELAY_BETWEEN_QUESTIONS = 15
 
 # ============================================
-# GROQ CLIENT
+# SIMPLE FAST AGENT
 # ============================================
 
-def get_groq_client():
-    api_key = os.environ.get("GROQ_API_KEY")
-    if not api_key:
-        raise ValueError("GROQ_API_KEY not set!")
-    return Groq(api_key=api_key)
-
-# ============================================
-# TOOLS
-# ============================================
-
-def web_search(query: str) -> str:
-    """Search with DuckDuckGo"""
-    try:
-        with DDGS() as ddgs:
-            results = list(ddgs.text(query, max_results=5))
-        if not results:
-            return ""
-        output = []
-        for r in results:
-            output.append(f"- {r.get('title','')}: {r.get('body','')}")
-        return "\n".join(output)
-    except Exception as e:
-        print(f"    Search error: {e}")
-        return ""
-
-
-def fetch_task_file(task_id: str) -> dict:
-    """Fetch file from GAIA API"""
-    if not task_id:
-        return {"has_file": False}
+class BasicAgent:
+    def __init__(self):
+        api_key = os.environ.get("GROQ_API_KEY")
+        if not api_key:
+            raise ValueError("GROQ_API_KEY not set!")
+        self.client = Groq(api_key=api_key)
+        print("✅ Agent ready")
     
-    try:
-        url = f"https://agents-course-unit4-scoring.hf.space/files/{task_id}"
-        print(f"    Fetching file: {url}")
-        
-        response = requests.get(url, timeout=30)
-        print(f"    Response status: {response.status_code}")
-        
-        if response.status_code == 404:
-            print(f"    No file for this task")
-            return {"has_file": False}
-        
-        if response.status_code != 200:
-            print(f"    Error status: {response.status_code}")
-            return {"has_file": False}
-        
-        content_type = response.headers.get('content-type', '').lower()
-        disposition = response.headers.get('content-disposition', '')
-        
-        # Extract filename
-        filename = "unknown"
-        if 'filename=' in disposition:
-            filename = disposition.split('filename=')[-1].strip('"\'').strip()
-        elif 'filename*=' in disposition:
-            filename = disposition.split('filename*=')[-1].strip('"\'').strip()
-        
-        print(f"    File: {filename}, Type: {content_type}")
-        
-        result = {"has_file": True, "filename": filename, "content_type": content_type}
-        
-        # Python files
-        if filename.endswith('.py') or 'python' in content_type:
-            result["content"] = response.text
-            result["file_type"] = "python"
-            print(f"    Python file, {len(response.text)} chars")
-            return result
-        
-        # Text files
-        if 'text' in content_type or filename.endswith(('.txt', '.md', '.csv', '.json')):
-            result["content"] = response.text
-            result["file_type"] = "text"
-            return result
-        
-        # Excel files
-        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"] = df.to_csv(index=False)
-                result["dataframe"] = df
-                result["file_type"] = "excel"
-                print(f"    Excel file, {len(df)} rows")
-                return result
-            except Exception as e:
-                print(f"    Excel parse error: {e}")
-                result["content"] = f"Excel file (error: {e})"
-                result["file_type"] = "excel"
-                return result
-        
-        # Images
-        if 'image' in content_type or filename.endswith(('.png', '.jpg', '.jpeg', '.gif')):
-            result["file_type"] = "image"
-            result["content"] = "[IMAGE - cannot process]"
-            return result
-        
-        # Audio/Video
-        if 'audio' in content_type or 'video' in content_type:
-            result["file_type"] = "media"
-            result["content"] = "[MEDIA - cannot process]"
-            return result
-        
-        # Try as text
+    def search(self, query: str) -> str:
+        """Quick web search"""
         try:
-            result["content"] = response.text[:8000]
-            result["file_type"] = "text"
-            return result
+            from duckduckgo_search import DDGS
+            with DDGS() as ddgs:
+                results = list(ddgs.text(query, max_results=3))
+            if results:
+                return "\n".join([f"- {r.get('title','')}: {r.get('body','')}" for r in results])
         except:
-            result["content"] = "[Binary file]"
-            result["file_type"] = "binary"
-            return result
-        
-    except Exception as e:
-        print(f"    File fetch error: {e}")
-        return {"has_file": False, "error": str(e)}
-
-
-def run_python_code(code: str) -> str:
-    """Execute Python code and return output"""
-    try:
-        import io
-        import sys
-        
-        old_stdout = sys.stdout
-        old_stderr = sys.stderr
-        sys.stdout = stdout_buffer = io.StringIO()
-        sys.stderr = stderr_buffer = io.StringIO()
-        
-        try:
-            exec(code, {"__builtins__": __builtins__})
-        except Exception as e:
-            sys.stdout = old_stdout
-            sys.stderr = old_stderr
-            return f"Execution error: {e}"
-        
-        sys.stdout = old_stdout
-        sys.stderr = old_stderr
-        
-        output = stdout_buffer.getvalue()
-        errors = stderr_buffer.getvalue()
-        
-        if output:
-            return output.strip()
-        if errors:
-            return f"Stderr: {errors.strip()}"
-        return "No output"
-        
-    except Exception as e:
-        return f"Error: {e}"
-
-
-def reverse_text(text: str) -> str:
-    return text[::-1]
-
-
-def is_reversed(text: str) -> bool:
-    """Check if text is reversed English"""
-    patterns = ['.rewsna', 'eht sa', 'tfel', 'drow eht', 'etisoppo', 'tahW', 'erehW']
-    return any(p in text for p in patterns)
-
-
-# ============================================
-# AGENT
-# ============================================
-
-class BasicAgent:
-    def __init__(self):
-        print("Initializing agent...")
-        self.client = get_groq_client()
-        print("✅ Agent ready!")
+            pass
+        return ""
     
     def ask(self, prompt: str) -> str:
-        """Ask LLM with retries"""
-        for attempt in range(3):
-            try:
-                response = self.client.chat.completions.create(
-                    model="llama-3.3-70b-versatile",
-                    messages=[{"role": "user", "content": prompt}],
-                    temperature=0.1,
-                    max_tokens=200,
-                )
-                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) * 20
-                    print(f"    Rate limit, waiting {wait}s...")
-                    time.sleep(wait)
-                else:
-                    print(f"    LLM error: {e}")
+        """Ask LLM - use 8B model for speed and rate limits"""
+        try:
+            response = self.client.chat.completions.create(
+                model="llama-3.1-8b-instant",  # Fast, high rate limit
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0,
+                max_tokens=50,  # Short answers only
+            )
+            return response.choices[0].message.content.strip()
+        except Exception as e:
+            if "rate" in str(e).lower():
+                time.sleep(5)
+                try:
+                    response = self.client.chat.completions.create(
+                        model="llama-3.1-8b-instant",
+                        messages=[{"role": "user", "content": prompt}],
+                        temperature=0,
+                        max_tokens=50,
+                    )
+                    return response.choices[0].message.content.strip()
+                except:
                     return ""
-        return ""
-    
-    def clean(self, answer: str) -> str:
-        """Clean answer for exact match"""
-        if not answer:
             return ""
-        
-        # Remove prefixes
-        for p in ["Answer:", "The answer is:", "The answer is", "A:", "Final answer:", "**"]:
-            if answer.lower().startswith(p.lower()):
-                answer = answer[len(p):].strip()
-        
-        # Clean formatting
-        answer = answer.replace("**", "").replace("```", "").strip()
-        answer = answer.strip('"\'')
-        
-        # Remove trailing punctuation for short answers
-        if answer.endswith('.') and len(answer.split()) <= 5:
-            answer = answer[:-1]
-        
-        return answer.strip()
     
     def __call__(self, question: str, task_id: str = None) -> str:
-        context_parts = []
-        
-        # === Handle reversed text ===
-        if is_reversed(question):
-            question = reverse_text(question)
-            print(f"    [Decoded reversed: {question[:50]}...]")
-        
-        # === Fetch file ===
-        file_info = fetch_task_file(task_id)
-        
-        if file_info.get("has_file"):
-            ftype = file_info.get("file_type", "")
-            content = file_info.get("content", "")
-            
-            if ftype == "python" and content:
-                print(f"    [Executing Python...]")
-                output = run_python_code(content)
-                print(f"    [Output: {output[:100]}]")
-                context_parts.append(f"Python code output:\n{output}")
-                
-            elif ftype == "excel":
-                context_parts.append(f"Excel data:\n{content[:4000]}")
-                
-            elif ftype == "text":
-                context_parts.append(f"File content:\n{content[:4000]}")
-                
-            elif ftype in ["image", "media"]:
-                context_parts.append("[This task has an image/media file that cannot be processed]")
-        
-        # === Web search ===
-        do_search = not file_info.get("has_file") or file_info.get("file_type") in ["image", "media"]
+        # Handle reversed text
+        if '.rewsna' in question or 'eht sa' in question or 'tfel' in question:
+            question = question[::-1]
         
-        if do_search:
-            results = web_search(question[:100])
-            if results:
-                context_parts.append(f"Web search:\n{results[:2500]}")
-                print(f"    [Search done]")
+        # Search for info
+        search_results = self.search(question[:80])
         
-        # === Ask LLM ===
-        context = "\n\n".join(context_parts)
+        # Build prompt
+        context = f"Info: {search_results[:1000]}\n\n" if search_results else ""
         
-        prompt = f"""Answer this question with ONLY the answer. No explanation.
-
-Rules:
-- Give just the answer (number, name, or short phrase)
-- No "The answer is" prefix
-- Be precise - exact match grading
-- If unsure, give your best guess
-
-{f"Context:{chr(10)}{context}" if context else ""}
+        prompt = f"""{context}Q: {question}
 
-Question: {question}
-
-Answer:"""
+Give only the final answer in 1-5 words. No explanation."""
         
         answer = self.ask(prompt)
-        answer = self.clean(answer)
         
-        # Don't return empty
-        if not answer or "unable" in answer.lower() or "cannot" in answer.lower():
-            # Try simpler prompt
-            simple = self.ask(f"Answer in 1-3 words: {question}")
-            answer = self.clean(simple) or "unknown"
+        # Clean answer
+        for prefix in ["Answer:", "The answer is", "A:", "Final answer:"]:
+            if answer.lower().startswith(prefix.lower()):
+                answer = answer[len(prefix):].strip()
         
-        return answer
-
+        answer = answer.strip('."\'')
+        
+        # Filter bad responses
+        if any(x in answer.lower() for x in ["i cannot", "i'm unable", "no code", "no image", "i don't"]):
+            answer = self.ask(f"Answer in 1-3 words only: {question}")
+            answer = answer.strip('."\'')
+        
+        return answer if answer else "unknown"
 
-# ============================================
-# MAIN
-# ============================================
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     if not profile:
-        return "Please log in first.", None
-
+        return "Please log in.", None
+    
     username = profile.username
     space_id = os.getenv("SPACE_ID")
     
     if not os.environ.get("GROQ_API_KEY"):
-        return "❌ Add GROQ_API_KEY to secrets!", None
-
-    print(f"\n{'='*50}")
-    print(f"User: {username}")
-    print(f"{'='*50}")
-
+        return "❌ Add GROQ_API_KEY!", None
+    
+    print(f"\n{'='*40}\nUser: {username}\n{'='*40}")
+    
     try:
         agent = BasicAgent()
     except Exception as e:
-        return f"❌ Init failed: {e}", None
-
+        return f"❌ {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"❌ Fetch failed: {e}", None
-
+        return f"❌ {e}", None
+    
     results = []
     answers = []
     start = time.time()
@@ -331,60 +120,42 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         task_id = q.get("task_id")
         question = q.get("question", "")
         
-        print(f"\n[{i+1}/{len(questions)}] Task: {task_id}")
-        print(f"Q: {question[:70]}...")
-        
+        print(f"[{i+1}] {question[:50]}...")
         answer = agent(question, task_id)
-        print(f"A: {answer}")
+        print(f"    → {answer}")
         
         answers.append({"task_id": task_id, "submitted_answer": answer})
-        results.append({"#": i+1, "Question": question[:50]+"...", "Answer": answer})
+        results.append({"#": i+1, "Q": question[:40]+"...", "A": answer})
         
-        if i < len(questions) - 1:
-            time.sleep(DELAY_BETWEEN_QUESTIONS)
-
+        time.sleep(2)  # Small delay
+    
     total = time.time() - start
-    print(f"\n⏱️ {total/60:.1f} min total")
-
+    print(f"\n⏱️ {total:.0f}s")
+    
     try:
         result = requests.post(
             f"{DEFAULT_API_URL}/submit",
-            json={
-                "username": username,
-                "agent_code": f"https://huggingface.co/spaces/{space_id}/tree/main",
-                "answers": answers
-            },
+            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_q = result.get('total_attempted', 0)
         
-        status = f"✅ Done in {total/60:.1f} min\n\n"
-        status += f"🎯 Score: {score}% ({correct}/{total_q})\n\n"
+        status = f"✅ Done in {total:.0f}s\n\n🎯 {score}% ({correct}/20)\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)
+        return f"❌ {e}", pd.DataFrame(results)
 
 
-# ============================================
-# UI
-# ============================================
-
 with gr.Blocks() as demo:
-    gr.Markdown("# 🎯 GAIA Agent - Unit 4")
-    gr.Markdown("**Llama 3.3 70B** via Groq | ~5 min runtime")
-    
+    gr.Markdown("# 🎯 GAIA Agent")
+    gr.Markdown("Fast mode - ~2 min")
     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])
+    gr.Button("🚀 Run", variant="primary").click(run_and_submit_all, outputs=[gr.Textbox(label="Status", lines=5), gr.DataFrame(label="Results")])
 
 if __name__ == "__main__":
-    print(f"GROQ_API_KEY: {'✅' if os.environ.get('GROQ_API_KEY') else '❌'}")
+    print(f"GROQ: {'✅' if os.environ.get('GROQ_API_KEY') else '❌'}")
     demo.launch()