webscout 8.3.5__py3-none-any.whl → 8.3.7__py3-none-any.whl

webscout/AIutel.py

@@ -22,6 +22,7 @@ def timeIt(func: Callable):
         start_time = time.time()
         result = func(*args, **kwargs)
         end_time = time.time()
+        print()
         print(f"{GREEN_BOLD}- Execution time for '{func.__name__}' : {end_time - start_time:.6f} Seconds.  {RESET}\n")
         return result
 
@@ -30,6 +31,7 @@ def timeIt(func: Callable):
         start_time = time.time()
         result = await func(*args, **kwargs)
         end_time = time.time()
+        print()
         print(f"{GREEN_BOLD}- Execution time for '{func.__name__}' : {end_time - start_time:.6f} Seconds.  {RESET}\n")
         return result
 

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/{UNFINISHED → AISEARCH}/PERPLEXED_search.py

@@ -5,7 +5,7 @@ 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.AIutel import sanitize_stream
+from webscout.sanitize import sanitize_stream
 
 
 class PERPLEXED(AISearch):
@@ -141,27 +141,13 @@ class PERPLEXED(AISearch):
 
         def extract_answer_content(data):
             """Extract answer content from PERPLEXED response."""
-            print(f"[DEBUG] extract_answer_content received: {type(data)}")
             if isinstance(data, dict):
-                print(f"[DEBUG] Dict keys: {list(data.keys())}")
-                print(f"[DEBUG] success: {data.get('success')}")
-                print(f"[DEBUG] stage: {data.get('stage')}")
-                print(f"[DEBUG] answer present: {'answer' in data}")
-                answer_val = data.get('answer', 'NOT_FOUND')
-                print(f"[DEBUG] answer value: {repr(answer_val[:100] if isinstance(answer_val, str) and len(answer_val) > 100 else answer_val)}")
-                
                 # 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"]:
-                    print(f"[DEBUG] Returning answer content (length: {len(data['answer'])})")
                     return data["answer"]
                 # Check if this is a stage update with no answer yet
                 elif data.get("success") and data.get("stage"):
-                    print(f"[DEBUG] Skipping stage update: {data.get('stage')}")
                     return None  # Skip stage updates without answers
-                else:
-                    print(f"[DEBUG] No matching condition, returning None")
-            else:
-                print(f"[DEBUG] Data is not dict, returning None")
             return None
 
         def for_stream():
@@ -178,77 +164,51 @@ class PERPLEXED(AISearch):
                             f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
                         )
 
-                    # Process the streaming response manually
-                    full_response = ""
-                    for line in response.iter_lines(decode_unicode=True):
-                        if line:
-                            full_response += line
-
-                    # Split by the separator to get individual JSON chunks
-                    chunks = full_response.split("[/PERPLEXED-SEPARATOR]")
+                    # 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
+                    )
                     
-                    for chunk_text in chunks:
-                        if chunk_text.strip():
-                            try:
-                                # Parse the JSON chunk
-                                chunk_data = json.loads(chunk_text.strip())
-                                
-                                if raw:
-                                    # For raw mode, yield the entire JSON string
-                                    yield {"text": chunk_text.strip()}
-                                else:
-                                    # For non-raw mode, extract the answer if available
-                                    answer_content = extract_answer_content(chunk_data)
-                                    if answer_content:
-                                        yield SearchResponse(answer_content)
-                                        
-                            except json.JSONDecodeError:
-                                # Skip invalid JSON chunks
-                                continue
+                    # 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():
-            if raw:
-                # For raw mode, yield each chunk as it comes
-                for chunk in for_stream():
-                    yield chunk
-            else:
-                # For non-raw mode, accumulate all chunks and return final response
-                full_response = ""
-                for chunk in for_stream():
-                    full_response += str(chunk)
-                
-                if full_response:
-                    self.last_response = SearchResponse(full_response)
-                else:
-                    # Return empty response if no content was extracted
-                    self.last_response = SearchResponse("")
-                
-                return self.last_response
-        
+            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:
-            # For non-streaming mode, we need to consume the generator and return the result
-            result = for_non_stream()
-            # If result is a generator (which it shouldn't be), consume it
-            if hasattr(result, '__iter__') and not isinstance(result, (str, bytes)):
-                try:
-                    # This shouldn't happen with our current implementation, but just in case
-                    return list(result)[0] if list(result) else SearchResponse("")
-                except:
-                    return SearchResponse("")
-            return result
+            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__":
-    from rich import print
+
     ai = PERPLEXED()
     
     # Test with raw=False to see debug output
-    print("=== Testing with raw=False ===")
-    response = ai.search(input(">>> "), stream=False, raw=False)
-    print("Final response:", response)
-    print("Response type:", type(response))
+    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,11 +1,18 @@
-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 *
+# This file marks the directory as a Python package.
+
+import os
+import importlib
+from pathlib import Path
+
+# Get current directory
+current_dir = Path(__file__).parent
+
+# Auto-import all .py files (except __init__.py)
+for file_path in current_dir.glob("*.py"):
+    if file_path.name != "__init__.py":
+        module_name = file_path.stem
+        try:
+            module = importlib.import_module(f".{module_name}", package=__name__)
+            globals().update(vars(module))
+        except ImportError:
+            pass  # Skip files that can't be imported

webscout/Provider/AISEARCH/scira_search.py

@@ -56,6 +56,8 @@ class Scira(AISearch):
         "scira-o3": "o3",
         "scira-qwen-32b": "qwen/qwen3-32b",
         "scira-qwen-30b": "qwen3-30b-a3b",
+        "scira-qwen-4b": "qwen3-4b",
+        "scira-qwen-4b-thinking": "qwen3-4b-thinking",
         "scira-deepseek-v3": "deepseek-v3-0324",
         "scira-haiku": "claude-3-5-haiku-20241022",
         "scira-mistral": "mistral-small-latest",
@@ -66,7 +68,7 @@ class Scira(AISearch):
         "scira-anthropic-thinking": "claude-sonnet-4-20250514",
         "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-llama-4": "llama-4-maverick",
         "scira-kimi-k2": "kimi-k2-instruct",
         "kimi-k2-instruct": "scira-kimi-k2",
     }

webscout/Provider/Aitopia.py

@@ -1,6 +1,5 @@
 from curl_cffi import CurlError
 from curl_cffi.requests import Session
-import json
 import uuid
 import time
 import hashlib
@@ -9,7 +8,7 @@ from typing import Any, Dict, Optional, Generator, Union
 from webscout.AIutel import Optimizers
 from webscout.AIutel import Conversation, sanitize_stream # Import sanitize_stream
 from webscout.AIutel import AwesomePrompts
-from webscout.AIbase import Provider, AsyncProvider
+from webscout.AIbase import Provider
 from webscout import exceptions
 from webscout.litagent import LitAgent
 
@@ -17,7 +16,7 @@ class Aitopia(Provider):
     """
     A class to interact with the Aitopia API with LitAgent user-agent.
     """
-
+    required_auth = True
     AVAILABLE_MODELS = [
         "Claude 3 Haiku",
         "GPT-4o Mini",

webscout/Provider/Andi.py

@@ -3,14 +3,14 @@ import requests
 import json
 from webscout.AIutel import Optimizers
 from webscout.AIutel import Conversation
-from webscout.AIutel import AwesomePrompts, sanitize_stream
-from webscout.AIbase import  Provider, AsyncProvider
+from webscout.AIutel import AwesomePrompts
+from webscout.AIbase import  Provider
 from webscout import exceptions
-from typing import Union, Any, AsyncGenerator, Dict
 from webscout import WEBS
 from webscout.litagent import LitAgent
 
 class AndiSearch(Provider):
+    required_auth = False
     def __init__(
         self,
         is_conversation: bool = True,

webscout/Provider/ChatGPTClone.py

@@ -20,7 +20,7 @@ class ChatGPTClone(Provider):
     ChatGPTClone is a provider class for interacting with the ChatGPT Clone API.
     Supports streaming responses.
     """
-    
+    required_auth = False
     url = "https://chatgpt-clone-ten-nu.vercel.app"
     AVAILABLE_MODELS = ["gpt-4", "gpt-3.5-turbo"]
     SUPPORTED_IMPERSONATION = [