webscout 2025.10.14.1__py3-none-any.whl → 2025.10.15__py3-none-any.whl

webscout/__init__.py

@@ -1,6 +1,6 @@
 # webscout/__init__.py
 
-from .search import DuckDuckGoSearch, YepSearch
+from .search import DuckDuckGoSearch, YepSearch, BingSearch
 from .version import __version__
 from .Provider import *
 from .Provider.TTI import *

webscout/auth/routes.py

@@ -43,7 +43,6 @@ from .request_processing import (
 from .auth_system import get_auth_components
 from .simple_logger import request_logger
 from ..search import DuckDuckGoSearch, YepSearch
-from ..DWEBS import GoogleSearch
 from webscout.Bing_search import BingSearch
 
 # Setup logger
@@ -514,33 +513,20 @@ class Api:
         @self.app.get(
             "/search",
             tags=["Web search"],
-            description="Unified web search endpoint supporting Google, Yep, DuckDuckGo, and Bing with text, news, images, and suggestions search types."
+            description="Unified web search endpoint supporting Yep, DuckDuckGo, and Bing with text, news, images, and suggestions search types."
         )
         async def websearch(
             q: str = Query(..., description="Search query"),
-            engine: str = Query("google", description="Search engine: google, yep, duckduckgo, bing"),
+            engine: str = Query("duckduckgo", description="Search engine: yep, duckduckgo, bing"),
             max_results: int = Query(10, description="Maximum number of results"),
             region: str = Query("all", description="Region code (optional)"),
             safesearch: str = Query("moderate", description="Safe search: on, moderate, off"),
             type: str = Query("text", description="Search type: text, news, images, suggestions"),
         ):
             """Unified web search endpoint."""
-            github_footer = "If you believe this is a bug, please pull an issue at https://github.com/OEvortex/Webscout."
+            github_footer = "If you believe this is a bug, please pull an issue at https://github.com/pyscout/Webscout."
             try:
-                if engine == "google":
-                    gs = GoogleSearch()
-                    if type == "text":
-                        results = gs.text(keywords=q, region=region, safesearch=safesearch, max_results=max_results)
-                        return {"engine": "google", "type": "text", "results": [r.__dict__ for r in results]}
-                    elif type == "news":
-                        results = gs.news(keywords=q, region=region, safesearch=safesearch, max_results=max_results)
-                        return {"engine": "google", "type": "news", "results": [r.__dict__ for r in results]}
-                    elif type == "suggestions":
-                        results = gs.suggestions(q, region=region)
-                        return {"engine": "google", "type": "suggestions", "results": results}
-                    else:
-                        return {"error": "Google only supports text, news, and suggestions in this API.", "footer": github_footer}
-                elif engine == "yep":
+                if engine == "yep":
                     ys = YepSearch()
                     if type == "text":
                         results = ys.text(keywords=q, region=region, safesearch=safesearch, max_results=max_results)
@@ -554,12 +540,12 @@ class Api:
                     else:
                         return {"error": "Yep only supports text, images, and suggestions in this API.", "footer": github_footer}
                 elif engine == "duckduckgo":
-                    ws = WEBS()
+                    ddg = DuckDuckGoSearch()
                     if type == "text":
-                        results = ws.text(keywords=q, region=region, safesearch=safesearch, max_results=max_results)
+                        results = ddg.text(keywords=q, region=region, safesearch=safesearch, max_results=max_results)
                         return {"engine": "duckduckgo", "type": "text", "results": results}
                     elif type == "suggestions":
-                        results = ws.suggestions(keywords=q, region=region)
+                        results = ddg.suggestions(keywords=q, region=region)
                         return {"engine": "duckduckgo", "type": "suggestions", "results": results}
                     else:
                         return {"error": "DuckDuckGo only supports text and suggestions in this API.", "footer": github_footer}
@@ -580,7 +566,7 @@ class Api:
                     else:
                         return {"error": "Bing only supports text, news, images, and suggestions in this API.", "footer": github_footer}
                 else:
-                    return {"error": "Unknown engine. Use one of: google, yep, duckduckgo, bing.", "footer": github_footer}
+                    return {"error": "Unknown engine. Use one of: yep, duckduckgo, bing.", "footer": github_footer}
             except Exception as e:
                 # Special handling for rate limit errors
                 msg = str(e)

webscout/cli.py

@@ -1,7 +1,6 @@
 import sys
 from .swiftcli import CLI, option
 from .search import DuckDuckGoSearch, YepSearch  # Import search classes
-from .DWEBS import GoogleSearch  # Import GoogleSearch from DWEBS
 from .version import __version__
 
 # Alias for backward compatibility
@@ -262,152 +261,6 @@ def weather(location: str, language: str, proxy: str = None, timeout: int = 10):
         raise e
 
 @app.command()
-@option("--keywords", "-k", help="Search keywords", required=True)
-@option("--region", "-r", help="Region for search results (ISO country code)", default="all")
-@option("--safesearch", "-s", help="SafeSearch setting (on, moderate, off)", default="moderate")
-@option("--max-results", "-m", help="Maximum number of results", type=int, default=10)
-@option("--start-num", "-start", help="Starting position for pagination", type=int, default=0)
-@option("--unique", "-u", help="Filter duplicate results", type=bool, default=True)
-@option("--timeout", "-timeout", help="Timeout value for requests", type=int, default=10)
-@option("--proxy", "-p", help="Proxy URL to use for requests")
-@option("--impersonate", "-i", help="Browser to impersonate", default="chrome110")
-def google_text(
-    keywords: str,
-    region: str,
-    safesearch: str,
-    max_results: int,
-    start_num: int,
-    unique: bool,
-    timeout: int = 10,
-    proxy: str = None,
-    impersonate: str = "chrome110"
-):
-    """Perform a text search using Google Search."""
-    google = GoogleSearch(
-        timeout=timeout,
-        proxies={"https": proxy, "http": proxy} if proxy else None,
-        verify=True,
-        lang="en",
-        sleep_interval=0.0,
-        impersonate=impersonate
-    )
-    
-    try:
-        results = google.text(
-            keywords=keywords,
-            region=region,
-            safesearch=safesearch,
-            max_results=max_results,
-            start_num=start_num,
-            unique=unique
-        )
-        
-        # Convert SearchResult objects to dictionaries for printing
-        formatted_results = []
-        for result in results:
-            result_dict = {
-                "title": result.title,
-                "url": result.url,
-                "description": result.description,
-            }
-            # Add any metadata to the result dictionary
-            for k, v in result.metadata.items():
-                result_dict[k] = v
-                
-            formatted_results.append(result_dict)
-            
-        _print_data(formatted_results)
-    except Exception as e:
-        raise e
-
-@app.command()
-@option("--keywords", "-k", help="Search keywords", required=True)
-@option("--region", "-r", help="Region for search results (ISO country code)", default="all")
-@option("--safesearch", "-s", help="SafeSearch setting (on, moderate, off)", default="moderate")
-@option("--max-results", "-m", help="Maximum number of results", type=int, default=10)
-@option("--timeout", "-timeout", help="Timeout value for requests", type=int, default=10)
-@option("--proxy", "-p", help="Proxy URL to use for requests")
-@option("--impersonate", "-i", help="Browser to impersonate", default="chrome110")
-def google_news(
-    keywords: str,
-    region: str,
-    safesearch: str,
-    max_results: int,
-    timeout: int = 10,
-    proxy: str = None,
-    impersonate: str = "chrome110"
-):
-    """Perform a news search using Google Search."""
-    google = GoogleSearch(
-        timeout=timeout,
-        proxies={"https": proxy, "http": proxy} if proxy else None,
-        verify=True,
-        lang="en",
-        sleep_interval=0.0,
-        impersonate=impersonate
-    )
-    
-    try:
-        results = google.news(
-            keywords=keywords,
-            region=region,
-            safesearch=safesearch,
-            max_results=max_results
-        )
-        
-        # Convert SearchResult objects to dictionaries for printing
-        formatted_results = []
-        for result in results:
-            result_dict = {
-                "title": result.title,
-                "url": result.url,
-                "description": result.description,
-            }
-            # Add any metadata to the result dictionary
-            for k, v in result.metadata.items():
-                result_dict[k] = v
-                
-            formatted_results.append(result_dict)
-            
-        _print_data(formatted_results)
-    except Exception as e:
-        raise e
-
-@app.command()
-@option("--query", "-q", help="Search query", required=True)
-@option("--region", "-r", help="Region for suggestions (ISO country code)", default="all")
-@option("--timeout", "-timeout", help="Timeout value for requests", type=int, default=10)
-@option("--proxy", "-p", help="Proxy URL to use for requests")
-@option("--impersonate", "-i", help="Browser to impersonate", default="chrome110")
-def google_suggestions(
-    query: str,
-    region: str,
-    timeout: int = 10,
-    proxy: str = None,
-    impersonate: str = "chrome110"
-):
-    """Get search suggestions from Google Search."""
-    google = GoogleSearch(
-        timeout=timeout,
-        proxies={"https": proxy, "http": proxy} if proxy else None,
-        verify=True,
-        lang="en",
-        sleep_interval=0.0,
-        impersonate=impersonate
-    )
-    
-    try:
-        results = google.suggestions(query=query, region=region)
-        
-        # Format suggestions for printing
-        formatted_results = []
-        for i, suggestion in enumerate(results, 1):
-            formatted_results.append({"position": i, "suggestion": suggestion})
-            
-        _print_data(formatted_results)
-    except Exception as e:
-        raise e
-
 @app.command()
 @option("--keywords", "-k", help="Search keywords", required=True)
 @option("--region", "-r", help="Region for search results", default="all")

webscout/search/__init__.py

@@ -3,15 +3,14 @@
 from .base import BaseSearch, BaseSearchEngine
 from .duckduckgo_main import DuckDuckGoSearch
 from .yep_main import YepSearch
+from .bing_main import BingSearch
 
 # Import new search engines
-from .engines.bing import Bing
 from .engines.brave import Brave
 from .engines.mojeek import Mojeek
 from .engines.yahoo import Yahoo
 from .engines.yandex import Yandex
 from .engines.wikipedia import Wikipedia
-from .engines.bing_news import BingNews
 from .engines.yahoo_news import YahooNews
 
 # Import result models
@@ -31,15 +30,14 @@ __all__ = [
     # Main search interfaces
     "DuckDuckGoSearch",
     "YepSearch",
+    "BingSearch",
     
     # Individual engines
-    "Bing",
     "Brave",
     "Mojeek",
     "Yahoo",
     "Yandex",
     "Wikipedia",
-    "BingNews",
     "YahooNews",
     
     # Result models

webscout/search/bing_main.py

@@ -0,0 +1,42 @@
+"""Bing unified search interface."""
+
+from __future__ import annotations
+from typing import Dict, List, Optional
+from .base import BaseSearch
+from .engines.bing.text import BingTextSearch
+from .engines.bing.images import BingImagesSearch
+from .engines.bing.news import BingNewsSearch
+from .engines.bing.suggestions import BingSuggestionsSearch
+
+
+class BingSearch(BaseSearch):
+    """Unified Bing search interface."""
+
+    def text(self, keywords: str, region: str = "us", safesearch: str = "moderate", max_results: Optional[int] = None, unique: bool = True) -> List[Dict[str, str]]:
+        search = BingTextSearch()
+        return search.run(keywords, region, safesearch, max_results, unique=unique)
+
+    def images(self, keywords: str, region: str = "us", safesearch: str = "moderate", max_results: Optional[int] = None) -> List[Dict[str, str]]:
+        search = BingImagesSearch()
+        return search.run(keywords, region, safesearch, max_results)
+
+    def news(self, keywords: str, region: str = "us", safesearch: str = "moderate", max_results: Optional[int] = None) -> List[Dict[str, str]]:
+        search = BingNewsSearch()
+        return search.run(keywords, region, safesearch, max_results)
+
+    def suggestions(self, query: str, region: str = "en-US") -> List[Dict[str, str]]:
+        search = BingSuggestionsSearch()
+        result = search.run(query, region)
+        return [{'suggestion': s} for s in result]
+
+    def answers(self, keywords: str) -> List[Dict[str, str]]:
+        raise NotImplementedError("Answers not implemented for Bing")
+
+    def maps(self, *args, **kwargs) -> List[Dict[str, str]]:
+        raise NotImplementedError("Maps not implemented for Bing")
+
+    def translate(self, keywords: str, from_lang: Optional[str] = None, to_lang: str = "en") -> List[Dict[str, str]]:
+        raise NotImplementedError("Translate not implemented for Bing")
+
+    def videos(self, *args, **kwargs) -> List[Dict[str, str]]:
+        raise NotImplementedError("Videos not implemented for Bing")

webscout/search/engines/bing/__init__.py

@@ -0,0 +1 @@
+"""Bing search engines."""

webscout/search/engines/bing/base.py

@@ -0,0 +1,33 @@
+"""Base class for Bing search implementations."""
+
+from __future__ import annotations
+
+from ....litagent import LitAgent
+from curl_cffi.requests import Session
+
+
+class BingBase:
+    """Base class for Bing search engines."""
+
+    def __init__(
+        self,
+        timeout: int = 10,
+        proxies: dict[str, str] | None = None,
+        verify: bool = True,
+        lang: str = "en-US",
+        sleep_interval: float = 0.0,
+        impersonate: str = "chrome110",
+    ):
+        self.timeout = timeout
+        self.proxies = proxies
+        self.verify = verify
+        self.lang = lang
+        self.sleep_interval = sleep_interval
+        self.base_url = "https://www.bing.com"
+        self.session = Session(
+            proxies=proxies,
+            verify=verify,
+            timeout=timeout,
+            impersonate=impersonate,
+        )
+        self.session.headers.update(LitAgent().generate_fingerprint())

webscout/search/engines/bing/images.py

@@ -0,0 +1,105 @@
+"""Bing images search."""
+
+from __future__ import annotations
+
+from typing import Dict, List
+from urllib.parse import urlencode
+from bs4 import BeautifulSoup
+from time import sleep
+
+from .base import BingBase
+
+
+class BingImagesSearch(BingBase):
+    def run(self, *args, **kwargs) -> List[Dict[str, str]]:
+        keywords = args[0] if args else kwargs.get("keywords")
+        region = args[1] if len(args) > 1 else kwargs.get("region", "us")
+        safesearch = args[2] if len(args) > 2 else kwargs.get("safesearch", "moderate")
+        max_results = args[3] if len(args) > 3 else kwargs.get("max_results", 10)
+
+        if not keywords:
+            raise ValueError("Keywords are mandatory")
+
+        safe_map = {
+            "on": "Strict",
+            "moderate": "Moderate",
+            "off": "Off"
+        }
+        safe = safe_map.get(safesearch.lower(), "Moderate")
+
+        # Bing images URL
+        url = f"{self.base_url}/images/async"
+        params = {
+            'q': keywords,
+            'first': '1',
+            'count': '35',  # Fetch more to get max_results
+            'cw': '1177',
+            'ch': '759',
+            'tsc': 'ImageHoverTitle',
+            'layout': 'RowBased_Landscape',
+            't': '0',
+            'IG': '',
+            'SFX': '0',
+            'iid': 'images.1'
+        }
+
+        results = []
+        first = 1
+        sfx = 0
+
+        while len(results) < max_results:
+            params['first'] = str(first)
+            params['SFX'] = str(sfx)
+            full_url = f"{url}?{urlencode(params)}"
+
+            try:
+                response = self.session.get(full_url, timeout=self.timeout)
+                response.raise_for_status()
+                html = response.text
+            except Exception as e:
+                raise Exception(f"Failed to fetch images: {str(e)}")
+
+            soup = BeautifulSoup(html, 'html.parser')
+            img_tags = soup.select('a.iusc img')
+
+            for img in img_tags:
+                if len(results) >= max_results:
+                    break
+
+                title = img.get('alt', '')
+                src = img.get('src', '')
+                m_attr = img.parent.get('m', '') if img.parent else ''
+
+                # Parse m attribute for full image URL
+                image_url = src
+                thumbnail = src
+                if m_attr:
+                    try:
+                        import json
+                        m_data = json.loads(m_attr)
+                        image_url = m_data.get('murl', src)
+                        thumbnail = m_data.get('turl', src)
+                    except:
+                        pass
+
+                source = ''
+                if img.parent and img.parent.parent:
+                    source_tag = img.parent.parent.select_one('.iusc .lnk')
+                    if source_tag:
+                        source = source_tag.get_text(strip=True)
+
+                results.append({
+                    'title': title,
+                    'image': image_url,
+                    'thumbnail': thumbnail,
+                    'url': image_url,  # For compatibility
+                    'source': source
+                })
+
+            first += 35
+            sfx += 1
+
+            if self.sleep_interval:
+                sleep(self.sleep_interval)
+
+        return results[:max_results]

webscout/search/engines/bing/news.py

@@ -0,0 +1,89 @@
+"""Bing news search."""
+
+from __future__ import annotations
+
+from typing import Dict, List
+from urllib.parse import urlencode
+from bs4 import BeautifulSoup
+from time import sleep
+
+from .base import BingBase
+
+
+class BingNewsSearch(BingBase):
+    def run(self, *args, **kwargs) -> List[Dict[str, str]]:
+        keywords = args[0] if args else kwargs.get("keywords")
+        region = args[1] if len(args) > 1 else kwargs.get("region", "us")
+        safesearch = args[2] if len(args) > 2 else kwargs.get("safesearch", "moderate")
+        max_results = args[3] if len(args) > 3 else kwargs.get("max_results", 10)
+
+        if not keywords:
+            raise ValueError("Keywords are mandatory")
+
+        safe_map = {
+            "on": "Strict",
+            "moderate": "Moderate",
+            "off": "Off"
+        }
+        safe = safe_map.get(safesearch.lower(), "Moderate")
+
+        # Bing news URL
+        url = f"{self.base_url}/news/infinitescrollajax"
+        params = {
+            'q': keywords,
+            'InfiniteScroll': '1',
+            'first': '1',
+            'SFX': '0',
+            'cc': region.lower(),
+            'setlang': self.lang.split('-')[0]
+        }
+
+        results = []
+        first = 1
+        sfx = 0
+
+        while len(results) < max_results:
+            params['first'] = str(first)
+            params['SFX'] = str(sfx)
+            full_url = f"{url}?{urlencode(params)}"
+
+            try:
+                response = self.session.get(full_url, timeout=self.timeout)
+                response.raise_for_status()
+                data = response.json()
+            except Exception as e:
+                raise Exception(f"Failed to fetch news: {str(e)}")
+
+            html = data.get('html', '')
+            if not html:
+                break
+
+            soup = BeautifulSoup(html, 'html.parser')
+            news_items = soup.select('div.newsitem')
+
+            for item in news_items:
+                if len(results) >= max_results:
+                    break
+
+                title = item.select_one('a.title')
+                snippet = item.select_one('div.snippet')
+                source = item.select_one('div.source')
+                date = item.select_one('span.date')
+
+                if title:
+                    news_result = {
+                        'title': title.get_text(strip=True),
+                        'url': title.get('href', ''),
+                        'body': snippet.get_text(strip=True) if snippet else '',
+                        'source': source.get_text(strip=True) if source else '',
+                        'date': date.get_text(strip=True) if date else ''
+                    }
+                    results.append(news_result)
+
+            first += 10
+            sfx += 1
+
+            if self.sleep_interval:
+                sleep(self.sleep_interval)
+
+        return results[:max_results]

webscout/search/engines/bing/suggestions.py

@@ -0,0 +1,34 @@
+"""Bing suggestions search."""
+
+from __future__ import annotations
+
+from typing import List
+from urllib.parse import urlencode
+
+from .base import BingBase
+
+
+class BingSuggestionsSearch(BingBase):
+    def run(self, *args, **kwargs) -> List[str]:
+        query = args[0] if args else kwargs.get("query")
+        region = args[1] if len(args) > 1 else kwargs.get("region", "en-US")
+
+        if not query:
+            raise ValueError("Query is mandatory")
+
+        params = {
+            "query": query,
+            "mkt": region
+        }
+        url = f"https://api.bing.com/osjson.aspx?{urlencode(params)}"
+
+        try:
+            response = self.session.get(url, timeout=self.timeout)
+            response.raise_for_status()
+            data = response.json()
+            # Bing suggestions API returns [query, [suggestions]]
+            if len(data) > 1 and isinstance(data[1], list):
+                return data[1]
+            return []
+        except Exception as e:
+            raise Exception(f"Failed to fetch suggestions: {str(e)}")