webscout 8.3.4__py3-none-any.whl → 8.3.6__py3-none-any.whl

webscout/Bard.py

@@ -8,24 +8,30 @@ import os
 import random
 import re
 import string
+from datetime import datetime
 from enum import Enum
 from pathlib import Path
-from datetime import datetime
-from typing import Dict, List, Tuple, Union, Optional
+from typing import Dict, List, Optional, Tuple, Union
 
 # Use curl_cffi for requests
+# Import trio before curl_cffi to prevent eventlet socket monkey-patching conflicts
+# See: https://github.com/python-trio/trio/issues/3015
+try:
+    import trio  # noqa: F401
+except ImportError:
+    pass  # trio is optional, ignore if not available
 from curl_cffi import CurlError
 from curl_cffi.requests import AsyncSession
-# Import common request exceptions (curl_cffi often wraps these)
-from requests.exceptions import RequestException, Timeout, HTTPError
 
 # For image models using validation. Adjust based on organization internal pydantic.
 # Updated import for Pydantic V2
 from pydantic import BaseModel, field_validator
 
+# Import common request exceptions (curl_cffi often wraps these)
+from requests.exceptions import HTTPError, RequestException, Timeout
+
 # Rich is retained for logging within image methods.
 from rich.console import Console
-from rich.markdown import Markdown
 
 console = Console()
 
@@ -875,7 +881,7 @@ class Image(BaseModel):
         # Generate filename from URL if not provided
         if not filename:
             try:
-                from urllib.parse import urlparse, unquote
+                from urllib.parse import unquote, urlparse
                 parsed_url = urlparse(self.url)
                 base_filename = os.path.basename(unquote(parsed_url.path))
                 # Remove invalid characters for filenames

webscout/DWEBS.py

@@ -3,16 +3,25 @@ DWEBS - A Google search library with advanced features
 """
 import random
 from time import sleep
+
 from webscout.scout import Scout
-from curl_cffi.requests import Session
-from urllib.parse import unquote, urlencode
-from typing import List, Dict, Optional, Union, Iterator, Any
+
+# Import trio before curl_cffi to prevent eventlet socket monkey-patching conflicts
+# See: https://github.com/python-trio/trio/issues/3015
+try:
+    import trio  # noqa: F401
+except ImportError:
+    pass  # trio is optional, ignore if not available
 from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Dict, List, Optional
+from urllib.parse import unquote, urlencode
+
+from curl_cffi.requests import Session
 
 
 class SearchResult:
     """Class to represent a search result with metadata."""
-    
+
     def __init__(self, url: str, title: str, description: str):
         """
         Initialize a search result.
@@ -96,7 +105,7 @@ class GoogleSearch:
         ssl_mm_version = f"SSL-MM/{random.randint(1, 2)}.{random.randint(3, 5)}"
         openssl_version = f"OpenSSL/{random.randint(1, 3)}.{random.randint(0, 4)}.{random.randint(0, 9)}"
         return f"{lynx_version} {libwww_version} {ssl_mm_version} {openssl_version}"
-    
+
     def _make_request(self, term: str, results: int, start: int = 0, search_type: str = None) -> str:
         """
         Make a request to Google search.
@@ -116,11 +125,11 @@ class GoogleSearch:
             "hl": self.lang,
             "start": start,
         }
-        
+
         # Add search type if specified
         if search_type:
             params["tbm"] = search_type
-        
+
         try:
             # Use the curl_cffi session
             resp = self.session.get(
@@ -137,7 +146,7 @@ class GoogleSearch:
                  raise RuntimeError(f"Search request failed with status {e.response.status_code}: {str(e)}")
             else:
                  raise RuntimeError(f"Search request failed: {str(e)}")
-    
+
     def _extract_url(self, raw_link: str) -> Optional[str]:
         """
         Extract actual URL from Google redirect URL.
@@ -150,7 +159,7 @@ class GoogleSearch:
         """
         if not raw_link:
             return None
-            
+
         if raw_link.startswith("/url?"):
             try:
                 link = unquote(raw_link.split("&")[0].replace("/url?q=", ""))
@@ -159,9 +168,9 @@ class GoogleSearch:
                 return None
         elif raw_link.startswith("http"):
             return unquote(raw_link)
-        
+
         return None
-    
+
     def _is_valid_result(self, link: str, fetched_links: set, unique: bool) -> bool:
         """
         Check if search result is valid.
@@ -176,12 +185,12 @@ class GoogleSearch:
         """
         if any(x in link for x in ["google.", "/search?", "webcache."]):
             return False
-            
+
         if link in fetched_links and unique:
             return False
-            
+
         return True
-    
+
     def _parse_search_results(
         self,
         html: str,
@@ -204,11 +213,11 @@ class GoogleSearch:
         results = []
         soup = Scout(html, features="html.parser")
         result_blocks = soup.find_all("div", class_="ezO2md")
-        
+
         if not result_blocks:
             # Try alternative class patterns if the main one doesn't match
             result_blocks = soup.find_all("div", attrs={"class": lambda c: c and "g" in c.split()})
-        
+
         for result in result_blocks:
             # Find the link - looking for various potential Google result classes
             link_tag = result.find("a", class_=["fuLhoc", "ZWRArf"])
@@ -216,10 +225,10 @@ class GoogleSearch:
                 link_tag = result.find("a")
                 if not link_tag:
                     continue
-            
+
             raw_link = link_tag.get("href", "")
             link = self._extract_url(raw_link)
-            
+
             if not link:
                 continue
 
@@ -235,32 +244,32 @@ class GoogleSearch:
             description_tag = result.find("span", class_="FrIlee")
             if not description_tag:
                 description_tag = result.find(["div", "span"], class_=lambda c: c and any(x in c for x in ["snippet", "description", "VwiC3b"]))
-            
+
             description = description_tag.get_text(strip=True) if description_tag else ""
 
             # Create result object
             search_result = SearchResult(link, title, description)
-            
+
             # Add extra metadata if available
             citation = result.find("cite")
             if citation:
                 search_result.metadata["source"] = citation.get_text(strip=True)
-            
+
             timestamp = result.find("span", class_=lambda c: c and "ZE5qJf" in c)
             if timestamp:
                 search_result.metadata["date"] = timestamp.get_text(strip=True)
 
             fetched_links.add(link)
             results.append(search_result)
-            
+
             if len(results) >= num_results:
                 break
-                
+
         return results
-    
+
     def text(
-        self, 
-        keywords: str, 
+        self,
+        keywords: str,
         region: str = None,
         safesearch: str = "moderate",
         max_results: int = 10,
@@ -283,7 +292,7 @@ class GoogleSearch:
         """
         if not keywords:
             raise ValueError("Search keywords cannot be empty")
-            
+
         # Map safesearch values to Google's safe parameter
         safe_map = {
             "on": "active",
@@ -291,12 +300,12 @@ class GoogleSearch:
             "off": "off"
         }
         safe = safe_map.get(safesearch.lower(), "moderate")
-        
+
         # Keep track of unique results
         fetched_results = []
         fetched_links = set()
         start = start_num
-        
+
         while len(fetched_results) < max_results:
             # Add safe search parameter to the request
             # Note: This modifies the session params for this specific request type
@@ -307,33 +316,33 @@ class GoogleSearch:
 
             response_html = self._make_request(
                 term=term_with_safe, # Pass term with safe search
-                results=max_results - len(fetched_results), 
+                results=max_results - len(fetched_results),
                 start=start
             )
-            
+
             results = self._parse_search_results(
                 html=response_html,
                 num_results=max_results - len(fetched_results),
                 fetched_links=fetched_links,
                 unique=unique
             )
-            
+
             if not results:
                 break
-                
+
             fetched_results.extend(results)
-            
+
             if len(fetched_results) >= max_results:
                 break
-            
+
             start += 10 # Google typically uses increments of 10
             sleep(self.sleep_interval)
-        
+
         return fetched_results[:max_results]
-    
+
     def news(
-        self, 
-        keywords: str, 
+        self,
+        keywords: str,
         region: str = None,
         safesearch: str = "moderate",
         max_results: int = 10
@@ -352,7 +361,7 @@ class GoogleSearch:
         """
         if not keywords:
             raise ValueError("Search keywords cannot be empty")
-            
+
         # Map safesearch values to Google's safe parameter
         safe_map = {
             "on": "active",
@@ -360,7 +369,7 @@ class GoogleSearch:
             "off": "off"
         }
         safe = safe_map.get(safesearch.lower(), "moderate")
-        
+
         # Keep track of unique results
         fetched_links = set()
 
@@ -374,16 +383,16 @@ class GoogleSearch:
             results=max_results,
             search_type="nws"
         )
-        
+
         results = self._parse_search_results(
             html=response_html,
             num_results=max_results,
             fetched_links=fetched_links,
             unique=True # News results are generally unique per request
         )
-        
+
         return results[:max_results]
-    
+
     def suggestions(self, query: str, region: str = None) -> List[str]:
         """
         Get search suggestions for a query term.
@@ -397,26 +406,26 @@ class GoogleSearch:
         """
         if not query:
             raise ValueError("Search query cannot be empty")
-            
+
         try:
             params = {
                 "client": "firefox",
                 "q": query,
             }
-            
+
             # Add region if specified
             if region and region.lower() != "all":
                 params["gl"] = region
-            
+
             url = f"https://www.google.com/complete/search?{urlencode(params)}"
-            
+
             # Use a simpler header set for the suggestions API
             headers = {
                 "User-Agent": self._get_useragent(),
                 "Accept": "application/json, text/javascript, */*",
                 "Accept-Language": self.lang,
             }
-            
+
             # Use session.get but override headers for this specific request
             response = self.session.get(
                 url=url,
@@ -425,13 +434,13 @@ class GoogleSearch:
                 # timeout and verify are handled by session
             )
             response.raise_for_status()
-            
+
             # Response format is typically: ["original query", ["suggestion1", "suggestion2", ...]]
             data = response.json()
             if isinstance(data, list) and len(data) > 1 and isinstance(data[1], list):
                 return data[1]
             return []
-            
+
         except Exception as e:
             # Provide more specific error context if possible
             if hasattr(e, 'response') and e.response is not None:
@@ -454,7 +463,7 @@ def search(term, num_results=10, lang="en", proxy=None, advanced=False, sleep_in
         sleep_interval=sleep_interval,
         impersonate=impersonate # Pass impersonate
     )
-    
+
     # Map legacy safe values
     safe_search_map = {
         "active": "on",
@@ -471,7 +480,7 @@ def search(term, num_results=10, lang="en", proxy=None, advanced=False, sleep_in
         start_num=start_num,
         unique=unique
     )
-    
+
     # Convert to simple URLs if not advanced mode
     if not advanced:
         return [result.url for result in results]
@@ -485,7 +494,7 @@ if __name__ == "__main__":
         proxies=None,  # Optional: Use proxies
         verify=True    # Optional: SSL verification
     )
-    
+
     # Text Search
     print("TEXT SEARCH RESULTS:")
     text_results = google.text(
@@ -499,7 +508,7 @@ if __name__ == "__main__":
         print(f"URL: {result.url}")
         print(f"Description: {result.description}")
         print("---")
-        
+
     # News Search
     print("\nNEWS SEARCH RESULTS:")
     news_results = google.news(
@@ -513,8 +522,8 @@ if __name__ == "__main__":
         print(f"URL: {result.url}")
         print(f"Description: {result.description}")
         print("---")
-        
+
     # Search Suggestions
     print("\nSEARCH SUGGESTIONS:")
     suggestions = google.suggestions("how to")
-    print(suggestions)
+    print(suggestions)

webscout/Provider/AISEARCH/PERPLEXED_search.py

@@ -0,0 +1,214 @@
+import requests
+import json
+from typing import Any, Dict, Generator, Optional, Union
+
+from webscout.AIbase import AISearch, SearchResponse
+from webscout import exceptions
+from webscout.litagent import LitAgent
+from webscout.sanitize import sanitize_stream
+
+
+class PERPLEXED(AISearch):
+    """A class to interact with the PERPLEXED stream search API.
+    
+    PERPLEXED provides an AI-powered search interface that returns emotionally intelligent
+    responses based on web content. It supports both streaming and non-streaming responses.
+    
+    Basic Usage:
+        >>> from webscout import PERPLEXED
+        >>> ai = PERPLEXED()
+        >>> # Non-streaming example
+        >>> response = ai.search("What is Python?")
+        >>> print(response)
+        Python is a high-level programming language...
+        
+        >>> # Streaming example
+        >>> for chunk in ai.search("Tell me about AI", stream=True):
+        ...     print(chunk, end="", flush=True)
+        Artificial Intelligence is...
+        
+        >>> # Raw response format
+        >>> for chunk in ai.search("Hello", stream=True, raw=True):
+        ...     print(chunk)
+        {'text': 'Hello'}
+        {'text': ' there!'}
+    
+    Args:
+        timeout (int, optional): Request timeout in seconds. Defaults to 30.
+        proxies (dict, optional): Proxy configuration for requests. Defaults to None.
+    
+    Attributes:
+        api_endpoint (str): The PERPLEXED API endpoint URL.
+        stream_chunk_size (int): Size of chunks when streaming responses.
+        timeout (int): Request timeout in seconds.
+        headers (dict): HTTP headers used in requests.
+    """
+
+    def __init__(
+        self,
+        timeout: int = 30,
+        proxies: Optional[dict] = None,
+    ):
+        """Initialize the PERPLEXED API client.
+        
+        Args:
+            timeout (int, optional): Request timeout in seconds. Defaults to 30.
+            proxies (dict, optional): Proxy configuration for requests. Defaults to None.
+        
+        Example:
+            >>> ai = PERPLEXED(timeout=60)  # Longer timeout
+            >>> ai = PERPLEXED(proxies={'http': 'http://proxy.com:8080'})  # With proxy
+        """
+        self.session = requests.Session()
+        self.api_endpoint = "https://d21l5c617zttgr.cloudfront.net/stream_search"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.headers = {
+            "accept": "*/*",
+            "accept-encoding": "gzip, deflate, br, zstd",
+            "accept-language": "en-US,en;q=0.9,en-IN;q=0.8",
+            "content-type": "application/json",
+            "dnt": "1",
+            "origin": "https://d37ozmhmvu2kcg.cloudfront.net",
+            "referer": "https://d37ozmhmvu2kcg.cloudfront.net/",
+            "sec-ch-ua": '"Not)A;Brand";v="8", "Chromium";v="138", "Microsoft Edge";v="138"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "cross-site",
+            "sec-gpc": "1",
+            "user-agent": LitAgent().random()
+        }
+        self.session.headers.update(self.headers)
+        self.proxies = proxies
+
+    def search(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+    ) -> Union[SearchResponse, Generator[Union[Dict[str, str], SearchResponse], None, None]]:
+        """Search using the PERPLEXED API and get AI-generated responses.
+        
+        This method sends a search query to PERPLEXED and returns the AI-generated response.
+        It supports both streaming and non-streaming modes, as well as raw response format.
+        
+        Args:
+            prompt (str): The search query or prompt to send to the API.
+            stream (bool, optional): If True, yields response chunks as they arrive.
+                                   If False, returns complete response. Defaults to False.
+            raw (bool, optional): If True, returns raw response dictionaries with 'text' key.
+                                If False, returns SearchResponse objects that convert to text automatically.
+                                Defaults to False.
+        
+        Returns:
+            Union[SearchResponse, Generator[Union[Dict[str, str], SearchResponse], None, None]]: 
+                - If stream=False: Returns complete response as SearchResponse object
+                - If stream=True: Yields response chunks as either Dict or SearchResponse objects
+        
+        Raises:
+            APIConnectionError: If the API request fails
+        
+        Examples:
+            Basic search:
+            >>> ai = PERPLEXED()
+            >>> response = ai.search("What is Python?")
+            >>> print(response)
+            Python is a programming language...
+            
+            Streaming response:
+            >>> for chunk in ai.search("Tell me about AI", stream=True):
+            ...     print(chunk, end="")
+            Artificial Intelligence...
+            
+            Raw response format:
+            >>> for chunk in ai.search("Hello", stream=True, raw=True):
+            ...     print(chunk)
+            {'text': 'Hello'}
+            {'text': ' there!'}
+            
+            Error handling:
+            >>> try:
+            ...     response = ai.search("My question")
+            ... except exceptions.APIConnectionError as e:
+            ...     print(f"API error: {e}")
+        """
+        payload = {
+            "user_prompt": prompt
+        }
+
+        def extract_answer_content(data):
+            """Extract answer content from PERPLEXED response."""
+            if isinstance(data, dict):
+                # Check if this is the final answer - answer field exists and is not empty
+                if data.get("success") and "answer" in data and data["answer"]:
+                    return data["answer"]
+                # Check if this is a stage update with no answer yet
+                elif data.get("success") and data.get("stage"):
+                    return None  # Skip stage updates without answers
+            return None
+
+        def for_stream():
+            try:
+                with self.session.post(
+                    self.api_endpoint,
+                    json=payload,
+                    stream=True,
+                    timeout=self.timeout,
+                    proxies=self.proxies,
+                ) as response:
+                    if not response.ok:
+                        raise exceptions.APIConnectionError(
+                            f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                        )
+
+                    # Use sanitize_stream directly with response iterator
+                    processed_chunks = sanitize_stream(
+                        data=response.iter_lines(decode_unicode=True),  # Pass iterator directly
+                        intro_value="",  # No prefix to remove  
+                        to_json=True,    # Parse each chunk as JSON
+                        content_extractor=lambda chunk: SearchResponse(extract_answer_content(chunk)) if extract_answer_content(chunk) else None,
+                        yield_raw_on_error=False,  # Skip invalid JSON chunks
+                        line_delimiter="[/PERPLEXED-SEPARATOR]",  # Use PERPLEXED separator to split chunks
+                        skip_markers=[],  # No specific markers to skip
+                        raw=raw  # Let sanitize_stream handle raw mode automatically
+                    )
+                    
+                    # Yield results from sanitize_stream - it handles raw/non-raw automatically
+                    for processed_chunk in processed_chunks:
+                        if processed_chunk is not None:
+                            yield processed_chunk
+
+            except requests.exceptions.RequestException as e:
+                raise exceptions.APIConnectionError(f"Request failed: {e}")
+
+        def for_non_stream():
+            full_response = ""
+            for chunk in for_stream():
+                full_response += str(chunk)
+            
+            self.last_response = SearchResponse(full_response)
+            return self.last_response
+
+        if stream:
+            return for_stream()
+        else:
+            if raw:
+                # For raw non-streaming, we need to yield each chunk individually
+                return for_stream()
+            else:
+                # For regular non-streaming, accumulate and return complete response
+                return for_non_stream()
+
+
+if __name__ == "__main__":
+
+    ai = PERPLEXED()
+    
+    # Test with raw=False to see debug output
+    print("=== Testing with raw=True ===")
+    response = ai.search(input(">>> "), stream=True, raw=True)
+    for chunks in response:
+        print(chunks, end="", flush=True)

webscout/Provider/AISEARCH/__init__.py

@@ -1,10 +1,11 @@
-from .stellar_search import *
-from .felo_search import *
-from .DeepFind import *
-from .genspark_search import *
-from .monica_search import *
-from .webpilotai_search import *
-from .hika_search import *
-from .scira_search import *
-from .iask_search import *
-from .Perplexity import *
+from .stellar_search import *
+from .felo_search import *
+from .DeepFind import *
+from .genspark_search import *
+from .monica_search import *
+from .webpilotai_search import *
+from .hika_search import *
+from .scira_search import *
+from .iask_search import *
+from .Perplexity import *
+from .PERPLEXED_search import *

webscout/Provider/AISEARCH/felo_search.py

@@ -69,7 +69,7 @@ class Felo(AISearch):
             "accept-encoding": "gzip, deflate, br, zstd",
             "accept-language": "en-US,en;q=0.9,en-IN;q=0.8",
             "content-type": "application/json",
-            "cookie": "_clck=1gifk45%7C2%7Cfoa%7C0%7C1686; _clsk=1g5lv07%7C1723558310439%7C1%7C1%7Cu.clarity.ms%2Fcollect; _ga=GA1.1.877307181.1723558313; _ga_8SZPRV97HV=GS1.1.1723558313.1.1.1723558341.0.0.0; _ga_Q9Q1E734CC=GS1.1.1723558313.1.1.1723558341.0.0.0",
+            # "cookie": "_clck=1gifk45%7C2%7Cfoa%7C0%7C1686; _clsk=1g5lv07%7C1723558310439%7C1%7C1%7Cu.clarity.ms%2Fcollect; _ga=GA1.1.877307181.1723558313; _ga_8SZPRV97HV=GS1.1.1723558313.1.1.1723558341.0.0.0; _ga_Q9Q1E734CC=GS1.1.1723558313.1.1.1723558341.0.0.0",
             "dnt": "1",
             "origin": "https://felo.ai",
             "referer": "https://felo.ai/",
@@ -141,10 +141,14 @@ class Felo(AISearch):
             "lang": "",
             "agent_lang": "en",
             "search_options": {
-                "langcode": "en-US"
+                "langcode": "en-US",
+                "search_image": True,
+                "search_video": True,
             },
             "search_video": True,
-            "contexts_from": "google"
+            "model": "",
+            "contexts_from": "google",
+            "auto_routing": True,
         }
 
         def for_stream():

webscout/Provider/AISEARCH/scira_search.py

@@ -67,6 +67,8 @@ class Scira(AISearch):
         "scira-opus": "claude-4-opus-20250514",
         "scira-opus-pro": "claude-4-opus-20250514",
         "scira-llama-4": "meta-llama/llama-4-maverick-17b-128e-instruct",
+        "scira-kimi-k2": "kimi-k2-instruct",
+        "kimi-k2-instruct": "scira-kimi-k2",
     }
     def __init__(
         self,