Update app.py

app.py

@@ -22,6 +22,12 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # --- Basic Agent Definition ---
 
+import requests
+from bs4 import BeautifulSoup
+import urllib.parse
+import re
+from typing import Optional
+
 class BasicAgent:
     def __init__(self):
         print("BasicAgent initialized.")
@@ -29,53 +35,93 @@ class BasicAgent:
             'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
             'Accept-Language': 'en-US,en;q=0.9'
         }
+        self.answer_patterns = {
+            'definition': r'(?:is|are|was|were) (?:an?|the)? (.+?)(?:\.|,)',
+            'quantity': r'(?:is|are|was|were) (?:about|approximately)? (\d+[\d,\.]*\s*\w+)',
+            'person': r'(?:by|named) (.+?)(?:\.|,)',
+            'date': r'(?:on|in) (.+? \d{4}|\d{1,2} [A-Za-z]+ \d{4})'
+        }
 
     def __call__(self, question: str) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
         
-        # Special handling for the dinosaur Featured Article question
-        if self._is_dinosaur_fa_question(question):
-            answer = self._get_dinosaur_fa_answer()
-        else:
-            answer = "I can only answer specific Wikipedia Featured Article questions currently."
+        # Try Wikipedia first for factual questions
+        if self._is_wikipedia_question(question):
+            answer = self._search_wikipedia(question)
+            if answer and answer != "No answer found":
+                return answer
         
-        print(f"Agent returning answer: {answer[:50]}...")  # Log first 50 chars of answer
+        # Fall back to Google search
+        answer = self._search_google(question)
+        print(f"Agent returning answer: {answer[:50]}...")
         return answer
 
-    def _is_dinosaur_fa_question(self, question: str) -> bool:
-        """Check if this is the specific dinosaur Featured Article question"""
+    def _is_wikipedia_question(self, question: str) -> bool:
+        """Check if question is suitable for Wikipedia"""
         question_lower = question.lower()
-        return ('featured article' in question_lower and 
-                'dinosaur' in question_lower and 
-                'november 2016' in question_lower)
+        return any(keyword in question_lower 
+                  for keyword in ['who', 'what', 'when', 'where', 'why', 'how', 'define'])
 
-    def _get_dinosaur_fa_answer(self) -> str:
-        """Get the accurate answer about the dinosaur Featured Article"""
+    def _search_wikipedia(self, question: str) -> str:
+        """Search Wikipedia directly for answers"""
         try:
-            # Get November 2016 FAC archive
-            url = "https://en.wikipedia.org/wiki/Wikipedia:Featured_article_candidates/November_2016"
-            response = requests.get(url, headers=self.headers, timeout=10)
-            response.raise_for_status()
+            # Extract main topic from question
+            topic = re.sub(r'(who|what|when|where|why|how|is|are|was|were|did|does|do)\s+', '', question, flags=re.IGNORECASE)
+            topic = re.sub(r'\?.*', '', topic).strip()
+            
+            url = f"https://en.wikipedia.org/wiki/{urllib.parse.quote(topic.replace(' ', '_'))}"
+            response = requests.get(url, headers=self.headers, timeout=5)
             
+            if response.status_code == 200:
+                soup = BeautifulSoup(response.text, 'html.parser')
+                first_paragraph = soup.select_one('div.mw-parser-output > p:not(.mw-empty-elt)')
+                
+                if first_paragraph:
+                    text = first_paragraph.get_text()
+                    # Try to extract most relevant sentence
+                    for pattern_type, pattern in self.answer_patterns.items():
+                        match = re.search(pattern, text, re.IGNORECASE)
+                        if match:
+                            return f"{match.group(1).strip()} (Source: Wikipedia)"
+                    
+                    return text.split('.')[0] + " (Source: Wikipedia)"
+            
+            return "No answer found"
+            
+        except Exception:
+            return "No answer found"
+
+    def _search_google(self, question: str) -> str:
+        """Search Google for answers"""
+        try:
+            url = f"https://www.google.com/search?q={urllib.parse.quote(question)}"
+            response = requests.get(url, headers=self.headers, timeout=5)
             soup = BeautifulSoup(response.text, 'html.parser')
             
-            # Find all FAC entries from that month
-            entries = soup.select('.featured_article_candidate')
+            # Check Google's answer boxes
+            for selector in ['.Z0LcW', '.LGOjhe', '.hgKElc', '.kno-rdesc span']:
+                element = soup.select_one(selector)
+                if element:
+                    return element.get_text() + " (Source: Google)"
             
-            for entry in entries:
-                title = entry.select_one('b a')
-                if title and 'dinosaur' in title.get('href', '').lower():
-                    nominator = entry.select_one('.nominator a')
-                    if nominator:
-                        article_title = title.get_text()
-                        return f"{nominator.get_text()} nominated {article_title}, the only dinosaur Featured Article promoted in November 2016."
+            # Try featured snippet
+            snippet = soup.select_one('.xpdopen .kno-rdesc span, .ifM9O')
+            if snippet:
+                return snippet.get_text() + " (Source: Google)"
             
-            return "No matching dinosaur Featured Article found for November 2016."
+            # Fallback to first result summary
+            first_result = soup.select_one('.tF2Cxc')
+            if first_result:
+                summary = first_result.select_one('.IsZvec, .VwiC3b')
+                if summary:
+                    return summary.get_text()[:150] + "... (Source: Google)"
             
-        except Exception as e:
-            return f"Error retrieving data: {str(e)}"
+            return "No concise answer found"
+            
+        except Exception:
+            return "Search failed"
 
-    
+   
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """