Update app.py

app.py

@@ -25,182 +25,35 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 class BasicAgent:
     def __init__(self):
         print("BasicAgent initialized.")
-    
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = self.process_request(question)
-        print(f"Agent returning answer: {fixed_answer[:100]}...")  # Truncate long output
-        return fixed_answer
-    
 
-class SearchAgent(BasicAgent):
-    def __init__(self):
-        super().__init__()
-        print("SearchAgent specialized initialization.")
-    
-    def process_request(self, query: str) -> str:
-        """Returns mock search results in JSON format"""
-        mock_results = [
-            {
-                "url": f"https://www.google.com/search?q={query.replace(' ', '+')}&result={i}",
-                "title": f"Example Result {i} for '{query[:15]}...'",
-                "snippet": f"This is a mock search result snippet about {query[:15]}... showing result number {i}.",
-                "relevance": i/3  # Score from 0.33 to 1.0
-            }
-            for i in range(1, 4)
-        ]
-        return json.dumps({
-            "query": query,
-            "results": mock_results,
-            "count": len(mock_results),
-            "status": "success"
-        })
+    def __call__(self, question: str) -> str:
+        print(f"Agent received question: {question[:50]}...")
+        answer = self.basic_search(question)
+        print(f"Answer: {answer}")
+        return answer
 
-class BrowserAgent(BasicAgent):
-    def __init__(self):
-        super().__init__()
-        self.current_page = None
-        self.history = []
-        self.session = requests.Session()
-        self.session.headers.update({'User-Agent': 'WebNavigator/1.0'})
-        print("BrowserAgent initialized with fresh session.")
-    
-    def process_request(self, url: str) -> str:
+    def basic_search(self, query):
         try:
-            response = self.session.get(url)
-            response.raise_for_status()
-            self.current_page = {
-                'url': url,
-                'content': response.text,
-                'timestamp': datetime.now()
-            }
-            self.history.append(self.current_page)
-            return json.dumps({
-                "status": "success",
-                "url": url,
-                "message": f"Successfully retrieved page: {url}"
-            })
-        except Exception as e:
-            return json.dumps({
-                "status": "error",
-                "url": url,
-                "message": f"Error visiting {url}: {str(e)}"
-            })
-
-class ContentExtractorAgent(BasicAgent):
-    def __init__(self):
-        super().__init__()
-        print("ContentExtractorAgent initialized.")
-    
-    def process_request(self, html: str) -> str:
-        soup = BeautifulSoup(html, 'html.parser')
-        
-        # Remove unwanted elements
-        for element in soup(['script', 'style', 'nav', 'footer']):
-            element.decompose()
-        
-        title = soup.title.string if soup.title else ""
-        main_content = soup.find('main') or soup.find('article') or soup.body
-        
-        extracted = {
-            'title': title,
-            'text': main_content.get_text(separator='\n', strip=True),
-            'links': [a['href'] for a in main_content.find_all('a', href=True)]
-        }
-        return json.dumps(extracted)
-
-class WebNavigator(BasicAgent):
-    def __init__(self):
-        super().__init__()
-        self.search_agent = SearchAgent()
-        self.browser_agent = BrowserAgent()
-        self.extractor_agent = ContentExtractorAgent()
-        self.search_history = []
-        print("WebNavigator fully initialized with all sub-agents.")
-    
-    def process_request(self, question: str) -> str:
-        # First try to interpret as a direct URL
-        if question.startswith(('http://', 'https://')):
-            return self.get_page_summary(question)
-        
-        # Otherwise treat as search query
-        return self.search_and_extract(question)
-    
-    def search_and_extract(self, query: str) -> str:
-        try:
-            search_results = json.loads(self.search_agent(query))
-            if search_results['status'] != 'success':
-                return json.dumps({"error": "Search failed", "details": search_results})
+            # Get search results from DuckDuckGo
+            results = ddg(query, max_results=3)
             
-            extracted_data = []
-            for result in search_results['results']:
-                visit_result = json.loads(self.browser_agent(result['url']))
+            # Format the results
+            if not results:
+                return "No results found"
                 
-                if visit_result['status'] == 'success':
-                    content = json.loads(self.extractor_agent(self.browser_agent.current_page['content']))
-                    extracted_data.append({
-                        'query': query,
-                        'url': result['url'],
-                        'content': content
-                    })
-            
-            self.search_history.append({
-                'query': query,
-                'timestamp': datetime.now().isoformat(),
-                'results': extracted_data
-            })
+            formatted_results = []
+            for i, result in enumerate(results, 1):
+                formatted_results.append(
+                    f"{i}. {result['title']}\n"
+                    f"   {result['link']}\n"
+                    f"   {result['body']}"
+                )
             
-            return json.dumps({
-                "status": "success",
-                "query": query,
-                "results": extracted_data
-            })
-        except Exception as e:
-            return json.dumps({
-                "status": "error",
-                "message": str(e)
-            })
-    
-    def get_page_summary(self, url: str) -> str:
-        try:
-            visit_result = json.loads(self.browser_agent(url))
-            if visit_result['status'] != 'success':
-                return json.dumps(visit_result)
+            return "\n\n".join(formatted_results)
             
-            content = json.loads(self.extractor_agent(self.browser_agent.current_page['content']))
-            return json.dumps({
-                "status": "success",
-                "url": url,
-                "title": content['title'],
-                "summary": ' '.join(content['text'].split()[:100]) + '...'
-            })
         except Exception as e:
-            return json.dumps({
-                "status": "error",
-                "message": str(e)
-            })
+            return f"Search error: {str(e)}"
 
-
-# After all your class definitions...
-
-if __name__ == "__main__":
-    import json
-    from datetime import datetime
-    import requests
-    from bs4 import BeautifulSoup
-    
-    # Initialize the navigator
-    navigator = WebNavigator()
-    
-    # Example 1: Perform a search
-    search_results = navigator("Python web scraping")
-    print("\nSearch results:")
-    print(search_results[:500] + "...")  # Print first 500 chars
-    
-    # Example 2: Visit a URL directly
-    url_result = navigator("https://example.com")
-    print("\nURL visit results:")
-    print(url_result)
     
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):