Update app.py

app.py

@@ -9,7 +9,7 @@ from duckduckgo_search import DDGS
 from transformers import pipeline
 from sklearn.metrics.pairwise import cosine_similarity
 import numpy as np
-import wikipedia
+from bs4 import BeautifulSoup
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
@@ -18,82 +18,86 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 class BasicAgent:
     def __init__(self):
         print("BasicAgent initialized.")
-        # Initialize the Whisper model for video transcription
+        # Initialize Whisper model for video transcription
         self.whisper_model = whisper.load_model("base")  # You can change the model to `large`, `medium`, etc.
         self.search_pipeline = pipeline("question-answering")
         self.nlp_model = pipeline("feature-extraction")  # For semantic similarity (using transformer model)
+        self.ner_pipeline = pipeline("ner", grouped_entities=True)
 
-    def score_search_results(self, question: str, search_results: list) -> str:
-        # Transform the question and results to embeddings (vector representations)
-        question_embedding = self.nlp_model(question)
-        question_embedding = np.mean(question_embedding[0], axis=0)
+    def extract_person_entities(self, text: str) -> list:
+        # Extract named entities (persons) from the text
+        entities = self.ner_pipeline(text[:1000])
+        return [e['word'] for e in entities if e['entity_group'] == 'PER']
+
+    def extract_wikipedia_nominator(self, search_results: list) -> str:
+        # Check if search result contains Wikipedia nomination info
+        for result in search_results:
+            if "Wikipedia:Featured_article_candidates" in result.get('href', ''):
+                try:
+                    response = requests.get(result['href'], timeout=10)
+                    soup = BeautifulSoup(response.text, 'html.parser')
+                    text = soup.get_text()
+                    for line in text.split("\n"):
+                        if "nominated by" in line.lower():
+                            persons = self.extract_person_entities(line)
+                            return f"Nominated by {persons[0]}" if persons else line.strip()
+                except Exception:
+                    continue
+        return None
 
+    def score_search_results(self, question: str, search_results: list) -> str:
+        # Calculate semantic similarity and score the search results
+        question_embedding = np.mean(self.nlp_model(question)[0], axis=0)
         best_score = -1
         best_answer = None
-
-        # Loop through search results and calculate similarity
         for result in search_results:
-            result_embedding = self.nlp_model(result['body'])
-            result_embedding = np.mean(result_embedding[0], axis=0)
-
-            # Calculate cosine similarity
-            similarity = cosine_similarity([question_embedding], [result_embedding])
-
-            # Check if this result is better
+            result_embedding = np.mean(self.nlp_model(result['body'])[0], axis=0)
+            similarity = cosine_similarity([question_embedding], [result_embedding])[0][0]
             if similarity > best_score:
                 best_score = similarity
                 best_answer = result['body']
-
-        return best_answer
+        return best_answer or "No high-confidence answer found."
 
     def search(self, question: str) -> str:
-         # Try Wikipedia first for reliable context
-        try:
-            wiki_titles = wikipedia.search(question)
-            if wiki_titles:
-                page = wikipedia.page(wiki_titles[0])
-                wiki_content = page.content[:4000]  # Truncate to 4000 chars for the QA model
-                result = self.search_pipeline(question=question, context=wiki_content)
-                return result["answer"]
-        except Exception as e:
-            print(f"Wikipedia lookup failed: {e}")
         try:
             with DDGS() as ddgs:
-                results = list(ddgs.text(question, max_results=3))  # Fetch top 3 results
-                if results:
-                    # Score all the results and return the best one
-                    return self.score_search_results(question, results)
-                else:
+                results = list(ddgs.text(question, max_results=5))  # Fetch top 5 results
+                if not results:
                     return "No relevant search results found."
+
+                # If the question relates to Wikipedia Featured Article nomination, check for nomination
+                if "featured article" in question.lower() and "wikipedia" in question.lower():
+                    nomination_info = self.extract_wikipedia_nominator(results)
+                    if nomination_info:
+                        return nomination_info
+
+                # Otherwise, return the best search result based on semantic similarity
+                return self.score_search_results(question, results)
         except Exception as e:
             return f"Search error: {e}"
 
     def call_whisper(self, video_path: str) -> str:
-        # Transcribe the video to text using Whisper model
+        # Transcribe video using Whisper
         video = moviepy.editor.VideoFileClip(video_path)
         audio_path = "temp_audio.wav"
         video.audio.write_audiofile(audio_path)
-        
-        # Transcribe audio to text
         result = self.whisper_model.transcribe(audio_path)
         return result["text"]
 
     def __call__(self, question: str, video_path: str = None) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-
-        # If a video path is provided, use Whisper to transcribe the video
         if video_path:
             transcription = self.call_whisper(video_path)
-            print(f"Transcribed video text: {transcription[:100]}...")  # Print first 100 characters
+            print(f"Transcribed video text: {transcription[:100]}...")
             return transcription
 
-        # If no video is provided, search the web for an answer
-        search_answer = self.search(question)
-        print(f"Agent returning search result: {search_answer[:100]}...")
+        answer = self.search(question)
+        print(f"Agent returning search result: {answer[:100]}...")
         time.sleep(2)
-        return search_answer
+        return answer
 
 
+# --- Run and Submit All ---
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,