Update main.py

main.py

@@ -10,12 +10,11 @@ from concurrent.futures import ThreadPoolExecutor
 from webscout.litagent import LitAgent
 from bs4 import BeautifulSoup
 import json
-import xml.etree.ElementTree as ET # Added for Google Suggestions XML parsing
 
 app = FastAPI(
-    title="Web Search API",
-    description="A FastAPI wrapper for Bing and Google search services.",
-    version="1.1.0",
+    title="Bing Search API",
+    description="A FastAPI wrapper for the BingSearch library with advanced features.",
+    version="1.0.0",
 )
 
 # --- BingSearch Library Code ---
@@ -65,14 +64,16 @@ class BingSearch:
             timeout=self.timeout,
             impersonate=impersonate
         )
+        # It's good practice to set a realistic User-Agent
         self.session.headers.update({
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/536.36"
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36"
         })
 
+    # FIX: Updated selectors to be more robust against Bing UI changes.
     def _selectors(self, element):
         selectors = {
-            'links': 'ol#b_results > li',
-            'next': 'a.sb_pagN'
+            'links': 'ol#b_results > li',  # More generic selector for any list item in results
+            'next': 'a.sb_pagN' # Selector for the "Next" page button
         }
         return selectors[element]
 
@@ -90,10 +91,6 @@ class BingSearch:
 
     def _get_url(self, tag):
         url = tag.get('href', '')
-        # FIX: Ensure relative URLs from Bing (like /news/search) become absolute
-        if url.startswith('/'):
-            return self._base_url + url
-        
         resp = url
         try:
             parsed_url = urlparse(url)
@@ -110,6 +107,7 @@ class BingSearch:
             print(f"Error decoding Base64 string: {e}")
         return resp
 
+    # FIX: The entire text parsing logic is updated to handle modern Bing HTML structure.
     def text(
         self,
         keywords: str,
@@ -138,9 +136,11 @@ class BingSearch:
             html = fetch_page(current_url)
             soup = BeautifulSoup(html, "html.parser")
             
+            # Use the more generic selector for result blocks
             result_blocks = soup.select(self._selectors('links'))
             
             for result in result_blocks:
+                # Find the title and link, which are usually in an <h2> tag
                 title_tag = result.find('h2')
                 if not title_tag:
                     continue
@@ -150,19 +150,24 @@ class BingSearch:
                     continue
                 
                 url_val = self._get_url(link_tag)
-                # FIX: Use separator=' ' to prevent text from being squashed together.
-                title = title_tag.get_text(strip=True, separator=' ')
+                title = title_tag.get_text(strip=True)
 
+                # Find the description, often in a div with class 'b_caption'
                 desc_container = result.find('div', class_='b_caption')
                 description = ''
                 if desc_container:
-                    # FIX: Use separator=' ' for descriptions as well.
-                    description = desc_container.get_text(strip=True, separator=' ')
+                    # Find the paragraph within the caption, or use the whole caption text
+                    desc_p = desc_container.find('p')
+                    if desc_p:
+                        description = desc_p.get_text(strip=True)
+                    else:
+                        description = desc_container.get_text(strip=True)
                 
+                # Fallback if no 'b_caption' is found
                 if not description:
                     p_tag = result.find('p')
                     if p_tag:
-                        description = p_tag.get_text(strip=True, separator=' ')
+                        description = p_tag.get_text(strip=True)
 
                 if url_val and title:
                     if unique and url_val in fetched_links:
@@ -177,6 +182,7 @@ class BingSearch:
             if len(fetched_results) >= max_results:
                 break
 
+            # Find the next page URL
             next_page_info = self._next_page(soup)
             current_url = next_page_info['url']
             if current_url:
@@ -184,6 +190,7 @@ class BingSearch:
 
         return fetched_results[:max_results]
 
+
     def suggestions(self, query: str, region: str = None) -> List[str]:
         if not query:
             raise ValueError("Search query cannot be empty")
@@ -200,7 +207,10 @@ class BingSearch:
                 return data[1]
             return []
         except Exception as e:
-            raise Exception(f"Bing suggestions failed: {str(e)}")
+            if hasattr(e, 'response') and e.response is not None:
+                raise Exception(f"Bing suggestions failed with status {e.response.status_code}: {str(e)}")
+            else:
+                raise Exception(f"Bing suggestions failed: {str(e)}")
 
     def images(
         self,
@@ -211,9 +221,18 @@ class BingSearch:
     ) -> List[BingImageResult]:
         if not keywords:
             raise ValueError("Search keywords cannot be empty")
-        safe_map = {"on": "Strict", "moderate": "Moderate", "off": "Off"}
+        safe_map = {
+            "on": "Strict",
+            "moderate": "Moderate",
+            "off": "Off"
+        }
         safe = safe_map.get(safesearch.lower(), "Moderate")
-        params = {"q": keywords, "count": max_results, "setlang": self.lang, "safeSearch": safe}
+        params = {
+            "q": keywords,
+            "count": max_results,
+            "setlang": self.lang,
+            "safeSearch": safe,
+        }
         if region:
             params["mkt"] = region
         url = f"{self._base_url}/images/search?{urlencode(params)}"
@@ -222,7 +241,10 @@ class BingSearch:
             resp.raise_for_status()
             html = resp.text
         except Exception as e:
-            raise Exception(f"Bing image search failed: {str(e)}")
+            if hasattr(e, 'response') and e.response is not None:
+                raise Exception(f"Bing image search failed with status {e.response.status_code}: {str(e)}")
+            else:
+                raise Exception(f"Bing image search failed: {str(e)}")
         soup = BeautifulSoup(html, "html.parser")
         results = []
         for item in soup.select("a.iusc"):
@@ -251,9 +273,17 @@ class BingSearch:
     ) -> List['BingNewsResult']:
         if not keywords:
             raise ValueError("Search keywords cannot be empty")
-        safe_map = {"on": "Strict", "moderate": "Moderate", "off": "Off"}
+        safe_map = {
+            "on": "Strict",
+            "moderate": "Moderate",
+            "off": "Off"
+        }
         safe = safe_map.get(safesearch.lower(), "Moderate")
-        params = {"q": keywords, "form": "QBNH", "safeSearch": safe}
+        params = {
+            "q": keywords,
+            "form": "QBNH",
+            "safeSearch": safe,
+        }
         if region:
             params["mkt"] = region
         url = f"{self._base_url}/news/search?{urlencode(params)}"
@@ -261,24 +291,27 @@ class BingSearch:
             resp = self.session.get(url)
             resp.raise_for_status()
         except Exception as e:
-            raise Exception(f"Bing news search failed: {str(e)}")
+            if hasattr(e, 'response') and e.response is not None:
+                raise Exception(f"Bing news search failed with status {e.response.status_code}: {str(e)}")
+            else:
+                raise Exception(f"Bing news search failed: {str(e)}")
         soup = BeautifulSoup(resp.text, "html.parser")
         results = []
         for item in soup.select("div.news-card, div.card, div.newsitem, div.card-content, div.t_s_main"):
             a_tag = item.find("a")
-            title = a_tag.get_text(strip=True, separator=' ') if a_tag else ''
+            title = a_tag.get_text(strip=True) if a_tag else ''
             url_val = a_tag['href'] if a_tag and a_tag.has_attr('href') else ''
             desc_tag = item.find("div", class_="snippet") or item.find("div", class_="news-card-snippet") or item.find("div", class_="snippetText")
-            description = desc_tag.get_text(strip=True, separator=' ') if desc_tag else ''
+            description = desc_tag.get_text(strip=True) if desc_tag else ''
             source_tag = item.find("div", class_="source")
-            source = source_tag.get_text(strip=True, separator=' ') if source_tag else ''
+            source = source_tag.get_text(strip=True) if source_tag else ''
             if url_val and title:
                 results.append(BingNewsResult(title=title, url=url_val, description=description, source=source))
                 if len(results) >= max_results:
                     break
         if not results:
             for item in soup.select("a.title"):
-                title = item.get_text(strip=True, separator=' ')
+                title = item.get_text(strip=True)
                 url_val = item['href'] if item.has_attr('href') else ''
                 description = ''
                 source = ''
@@ -288,107 +321,83 @@ class BingSearch:
                         break
         return results[:max_results]
 
-# --- NEW: Google Suggestions Class ---
-class GoogleSuggestions:
-    """Fetches search suggestions from Google's unofficial suggestions API."""
-    def __init__(self, timeout: int = 10, proxies: Optional[Dict[str, str]] = None):
-        self.session = Session(
-            proxies=proxies if proxies else {},
-            timeout=timeout,
-            impersonate="chrome110"
-        )
-        self.session.headers.update({
-            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36"
-        })
-
-    def get(self, query: str, lang: str = "en") -> List[str]:
-        if not query:
-            raise ValueError("Search query cannot be empty")
-            
-        params = {"q": query, "hl": lang, "output": "toolbar"}
-        url = f"https://clients1.google.com/complete/search?{urlencode(params)}"
-        
-        try:
-            response = self.session.get(url)
-            response.raise_for_status()
-            
-            suggestions = []
-            root = ET.fromstring(response.content)
-            for suggestion_node in root.findall('CompleteSuggestion/suggestion'):
-                data = suggestion_node.get('data')
-                if data:
-                    suggestions.append(data)
-            return suggestions
-        except Exception as e:
-            raise Exception(f"Google suggestions failed: {str(e)}")
-
-# --- FastAPI Endpoints ---
 
 bing = BingSearch()
-google = GoogleSuggestions()
 
-@app.get("/bing/search", response_model=List[BingSearchResult], tags=["Bing"])
-async def bing_text_search(
+@app.get("/search", response_model=List[BingSearchResult])
+async def text_search(
     query: str = Query(..., description="The search keywords."),
     region: Optional[str] = Query(None, description="The region for the search (e.g., 'us-US')."),
     safesearch: str = Query("moderate", description="Safe search level ('on', 'moderate', 'off')."),
     max_results: int = Query(10, description="Maximum number of results to return."),
 ):
-    """Perform a text search on Bing."""
+    """
+    Perform a text search on Bing.
+    """
     try:
-        return bing.text(keywords=query, region=region, safesearch=safesearch, max_results=max_results)
+        results = bing.text(
+            keywords=query,
+            region=region,
+            safesearch=safesearch,
+            max_results=max_results,
+        )
+        return results
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
-@app.get("/bing/suggestions", response_model=List[str], tags=["Bing"])
-async def bing_get_suggestions(
+@app.get("/suggestions", response_model=List[str])
+async def get_suggestions(
     query: str = Query(..., description="The search query for which to fetch suggestions."),
     region: Optional[str] = Query(None, description="The region for the suggestions (e.g., 'en-US')."),
 ):
-    """Fetches search suggestions for a given query from Bing."""
+    """
+    Fetches search suggestions for a given query.
+    """
     try:
-        return bing.suggestions(query=query, region=region)
+        suggestions = bing.suggestions(query=query, region=region)
+        return suggestions
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
-@app.get("/bing/images", response_model=List[BingImageResult], tags=["Bing"])
-async def bing_image_search(
+@app.get("/images", response_model=List[BingImageResult])
+async def image_search(
     query: str = Query(..., description="The search keywords for images."),
     region: Optional[str] = Query(None, description="The region for the image search (e.g., 'us-US')."),
     safesearch: str = Query("moderate", description="Safe search level ('on', 'moderate', 'off')."),
     max_results: int = Query(10, description="Maximum number of image results to return."),
 ):
-    """Perform an image search on Bing."""
+    """
+    Perform an image search on Bing.
+    """
     try:
-        return bing.images(keywords=query, region=region, safesearch=safesearch, max_results=max_results)
+        results = bing.images(
+            keywords=query,
+            region=region,
+            safesearch=safesearch,
+            max_results=max_results,
+        )
+        return results
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
-@app.get("/bing/news", response_model=List[BingNewsResult], tags=["Bing"])
-async def bing_news_search(
+@app.get("/news", response_model=List[BingNewsResult])
+async def news_search(
     query: str = Query(..., description="The search keywords for news."),
     region: Optional[str] = Query(None, description="The region for the news search (e.g., 'us-US')."),
     safesearch: str = Query("moderate", description="Safe search level ('on', 'moderate', 'off')."),
     max_results: int = Query(10, description="Maximum number of news results to return."),
-):
-    """Perform a news search on Bing."""
-    try:
-        return bing.news(keywords=query, region=region, safesearch=safesearch, max_results=max_results)
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-# --- NEW: Google Suggestions Endpoint ---
-@app.get("/google/suggestions", response_model=List[str], tags=["Google"])
-async def google_get_suggestions(
-    query: str = Query(..., description="The search query for which to fetch suggestions."),
-    lang: str = Query("en", description="The language for the suggestions (e.g., 'en', 'es')."),
 ):
     """
-    Fetches search suggestions for a given query from Google.
-    This replicates the functionality of the provided C++ code.
+    Perform a news search on Bing.
     """
     try:
-        return google.get(query=query, lang=lang)
+        results = bing.news(
+            keywords=query,
+            region=region,
+            safesearch=safesearch,
+            max_results=max_results,
+        )
+        return results
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))