webscout 8.2.5__tar.gz → 8.2.6__tar.gz

{webscout-8.2.5/webscout.egg-info → webscout-8.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webscout
-Version: 8.2.5
+Version: 8.2.6
 Summary: Search for anything using Google, DuckDuckGo, phind.com, Contains AI models, can transcribe yt videos, temporary email and phone number generation, has TTS support, webai (terminal gpt and open interpreter) and offline LLMs and more
 Author: OEvortex
 Author-email: helpingai5@gmail.com

webscout-8.2.6/webscout/AIauto.py

@@ -0,0 +1,233 @@
+"""
+This module provides the AUTO provider, which automatically selects and uses
+an available LLM provider from the webscout library that doesn't require
+API keys or cookies.
+"""
+
+from webscout.AIbase import Provider
+from webscout.exceptions import AllProvidersFailure
+from typing import Union, Any, Dict, Generator
+import importlib
+import pkgutil
+import random
+import inspect
+
+def load_providers():
+    """
+    Dynamically loads all Provider classes from the webscout.Provider package.
+
+    Identifies providers that require special authentication parameters like
+    'api_key', 'cookie_file', or 'cookie_path'.
+
+    Returns:
+        tuple: A tuple containing:
+            - provider_map (dict): A dictionary mapping uppercase provider names to their classes.
+            - api_key_providers (set): A set of uppercase provider names requiring special authentication.
+    """
+    provider_map = {}
+    api_key_providers = set()
+    cookie_providers = set()
+    provider_package = importlib.import_module("webscout.Provider")
+    
+    for _, module_name, _ in pkgutil.iter_modules(provider_package.__path__):
+        try:
+            module = importlib.import_module(f"webscout.Provider.{module_name}")
+            for attr_name in dir(module):
+                attr = getattr(module, attr_name)
+                if isinstance(attr, type) and issubclass(attr, Provider) and attr != Provider:
+                    provider_map[attr_name.upper()] = attr
+                    # Check if the provider needs special parameters
+                    sig = inspect.signature(attr.__init__).parameters
+                    if 'api_key' in sig:
+                        api_key_providers.add(attr_name.upper())
+                    if 'cookie_file' in sig or 'cookie_path' in sig:
+                        cookie_providers.add(attr_name.upper())
+        except Exception:
+            pass
+    return provider_map, api_key_providers.union(cookie_providers)
+
+provider_map, api_key_providers = load_providers()
+
+class AUTO(Provider):
+    """
+    An automatic provider that cycles through available free providers
+    until one successfully processes the request. Excludes providers
+    requiring API keys or cookies by default.
+    """
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        exclude: list[str] = [],
+        print_provider_info: bool = False,
+    ):
+        """
+        Initializes the AUTO provider.
+
+        Args:
+            is_conversation (bool): Flag for conversational mode. Defaults to True.
+            max_tokens (int): Maximum tokens for the response. Defaults to 600.
+            timeout (int): Request timeout in seconds. Defaults to 30.
+            intro (str, optional): Introductory prompt. Defaults to None.
+            filepath (str, optional): Path for conversation history. Defaults to None.
+            update_file (bool): Whether to update the history file. Defaults to True.
+            proxies (dict): Proxies for requests. Defaults to {}.
+            history_offset (int): History character offset limit. Defaults to 10250.
+            act (str, optional): Awesome prompt key. Defaults to None.
+            exclude (list[str]): List of provider names (uppercase) to exclude. Defaults to [].
+            print_provider_info (bool): Whether to print the name of the successful provider. Defaults to False.
+        """
+        self.provider = None  # type: Provider
+        self.provider_name = None  # type: str
+        self.is_conversation: bool = is_conversation
+        self.max_tokens: int = max_tokens
+        self.timeout: int = timeout
+        self.intro: str = intro
+        self.filepath: str = filepath
+        self.update_file: bool = update_file
+        self.proxies: dict = proxies
+        self.history_offset: int = history_offset
+        self.act: str = act
+        self.exclude: list[str] = [e.upper() for e in exclude]
+        self.print_provider_info: bool = print_provider_info
+
+
+    @property
+    def last_response(self) -> dict[str, Any]:
+        """
+        Returns the last response dictionary from the successful provider.
+        """
+        return self.provider.last_response if self.provider else {}
+
+    @property
+    def conversation(self) -> object:
+        """
+        Returns the conversation object from the successful provider.
+        """
+        return self.provider.conversation if self.provider else None
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Union[Dict, Generator]:
+        """
+        Sends the prompt to providers, trying each available free provider
+        in a random order until one succeeds.
+
+        Args:
+            prompt (str): The user's prompt.
+            stream (bool): Whether to stream the response. Defaults to False.
+            raw (bool): Whether to return the raw response format. Defaults to False.
+            optimizer (str, optional): Name of the optimizer to use. Defaults to None.
+            conversationally (bool): Whether to apply optimizer conversationally. Defaults to False.
+
+        Returns:
+            Union[Dict, Generator]: The response dictionary or generator from the successful provider.
+        """
+        ask_kwargs = {
+            "prompt": prompt,
+            "stream": stream,
+            "raw": raw,
+            "optimizer": optimizer,
+            "conversationally": conversationally,
+        }
+
+        # Filter out API key required providers and excluded providers
+        available_providers = [
+            (name, cls) for name, cls in provider_map.items()
+            if name not in api_key_providers and name not in self.exclude
+        ]
+
+        # Shuffle the list of available providers
+        random.shuffle(available_providers)
+
+        # Try webscout-based providers
+        for provider_name, provider_class in available_providers:
+            try:
+                self.provider_name = f"webscout-{provider_name}"
+                
+                self.provider = provider_class(
+                    is_conversation=self.is_conversation,
+                    max_tokens=self.max_tokens,
+                    timeout=self.timeout,
+                    intro=self.intro,
+                    filepath=self.filepath,
+                    update_file=self.update_file,
+                    proxies=self.proxies,
+                    history_offset=self.history_offset,
+                    act=self.act,
+                )
+                response = self.provider.ask(**ask_kwargs)
+                # Print provider info if enabled
+                if self.print_provider_info:
+                    print(f"\033[1;34m{self.provider_name}\033[0m\n")
+                return response
+            except Exception:
+                continue
+
+        # If we get here, all providers failed
+        raise AllProvidersFailure("All providers failed to process the request")
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Union[str, Generator[str, None, None]]: 
+        """
+        Provides a simplified chat interface, returning the message string(s).
+
+        Args:
+            prompt (str): The user's prompt.
+            stream (bool): Whether to stream the response. Defaults to False.
+            optimizer (str, optional): Name of the optimizer to use. Defaults to None.
+            conversationally (bool): Whether to apply optimizer conversationally. Defaults to False.
+
+        Returns:
+            Union[str, Generator[str, None, None]]: The response string or a generator yielding
+                                                     response chunks.
+        """
+        # run_new_test is not used in the current implementation, but we keep it for API compatibility
+        response = self.ask(
+            prompt,
+            stream,
+            optimizer=optimizer,
+            conversationally=conversationally,
+        )
+        
+        if stream:
+            for chunk in response:
+                yield self.get_message(chunk)
+        else:
+            return self.get_message(response)
+
+    def get_message(self, response: dict) -> str:
+        """
+        Extracts the message text from the provider's response dictionary.
+
+        Args:
+            response (dict): The response dictionary from the ask method.
+
+        Returns:
+            str: The extracted message string.
+        """
+        assert self.provider is not None, "Chat with AI first"
+        return self.provider.get_message(response)
+    
+if __name__ == "__main__":
+    auto = AUTO(print_provider_info=True)
+    response = auto.chat("Hello, how are you?", stream=True)
+    for chunk in response:
+        print(chunk, end="", flush=True)

webscout-8.2.6/webscout/AIutel.py

@@ -0,0 +1,240 @@
+import json
+import platform
+import subprocess
+from typing import Union, Optional, Dict, Any, Iterable, Generator, List, Callable, Literal, Tuple
+import io
+from collections import deque
+import codecs
+
+# Expanded encoding types
+EncodingType = Literal['utf-8', 'utf-16', 'utf-32', 'ascii', 'latin1', 'cp1252', 'iso-8859-1', 
+                        'iso-8859-2', 'windows-1250', 'windows-1251', 'windows-1252', 'gbk', 'big5',
+                        'shift_jis', 'euc-jp', 'euc-kr']
+
+def _process_chunk(
+    chunk: str,
+    intro_value: str,
+    to_json: bool,
+    skip_markers: List[str],
+    strip_chars: Optional[str],
+    yield_raw_on_error: bool,
+) -> Union[str, Dict[str, Any], None]:
+    """Internal helper to sanitize and potentially parse a single chunk."""
+    if not isinstance(chunk, str):
+        return None
+
+    sanitized_chunk = chunk
+
+    # Check if chunk starts with intro_value + skip_marker combination
+    if intro_value and skip_markers:
+        for marker in skip_markers:
+            combined_marker = f"{intro_value}{marker}"
+            if sanitized_chunk.startswith(combined_marker):
+                return None
+
+    if intro_value and sanitized_chunk.startswith(intro_value):
+        sanitized_chunk = sanitized_chunk[len(intro_value):]
+
+    if strip_chars is not None:
+        sanitized_chunk = sanitized_chunk.strip(strip_chars)
+    else:
+        sanitized_chunk = sanitized_chunk.lstrip()
+
+    # Check both standalone skip_markers and stripped version
+    if not sanitized_chunk or any(
+        marker in sanitized_chunk or sanitized_chunk == marker
+        for marker in skip_markers
+    ):
+        return None
+
+    if to_json:
+        try:
+            return json.loads(sanitized_chunk)
+        except (json.JSONDecodeError, Exception) as e:
+            return sanitized_chunk if yield_raw_on_error else None
+    
+    return sanitized_chunk
+
+def _decode_byte_stream(
+    byte_iterator: Iterable[bytes], 
+    encoding: EncodingType = 'utf-8',
+    errors: str = 'replace'
+) -> Generator[str, None, None]:
+    """
+    Realtime byte stream decoder with flexible encoding support.
+    
+    Args:
+        byte_iterator: Iterator yielding bytes
+        encoding: Character encoding to use
+        errors: How to handle encoding errors ('strict', 'ignore', 'replace')
+    """
+    # Initialize decoder with the specified encoding
+    try:
+        decoder = codecs.getincrementaldecoder(encoding)(errors=errors)
+    except LookupError:
+        # Fallback to utf-8 if the encoding is not supported
+        decoder = codecs.getincrementaldecoder('utf-8')(errors=errors)
+    
+    # Process byte stream in realtime
+    for chunk_bytes in byte_iterator:
+        if not chunk_bytes:
+            continue
+
+        try:
+            # Decode chunk with specified encoding
+            text = decoder.decode(chunk_bytes, final=False)
+            if text:
+                yield text
+        except UnicodeDecodeError:
+            yield f"[Encoding Error: Could not decode bytes with {encoding}]\n"
+    
+    # Final flush
+    try:
+        final_text = decoder.decode(b'', final=True)
+        if final_text:
+            yield final_text
+    except UnicodeDecodeError:
+        yield f"[Encoding Error: Could not decode final bytes with {encoding}]\n"
+def sanitize_stream(
+    data: Union[str, bytes, Iterable[str], Iterable[bytes]],
+    intro_value: str = "data:",
+    to_json: bool = True,
+    skip_markers: Optional[List[str]] = None,
+    strip_chars: Optional[str] = None,
+    start_marker: Optional[str] = None,
+    end_marker: Optional[str] = None,
+    content_extractor: Optional[Callable[[Union[str, Dict[str, Any]]], Optional[Any]]] = None,
+    yield_raw_on_error: bool = True,
+    encoding: EncodingType = 'utf-8',
+    encoding_errors: str = 'replace',
+    chunk_size: Optional[int] = None,
+) -> Generator[Any, None, None]:
+    """
+    Realtime stream processor that handles string/byte streams with minimal latency.
+    
+    Features:
+    - Direct realtime processing of byte streams
+    - Optimized string handling and JSON parsing
+    - Robust error handling and validation
+    - Flexible encoding support
+    - Drop-in replacement for response.iter_content/iter_lines
+    
+    Args:
+        data: Input data (string, string iterator, or bytes iterator)
+        intro_value: Prefix to remove from each chunk
+        to_json: Whether to parse chunks as JSON
+        skip_markers: Markers to skip
+        strip_chars: Characters to strip
+        start_marker: Processing start marker
+        end_marker: Processing end marker
+        content_extractor: Function to extract content
+        yield_raw_on_error: Yield raw content on JSON errors
+        encoding: Character encoding for byte streams ('utf-8', 'latin1', etc.)
+        encoding_errors: How to handle encoding errors ('strict', 'ignore', 'replace')
+        chunk_size: Chunk size for byte streams (None for default)
+    
+    Yields:
+        Processed chunks (string or dictionary)
+    
+    Example:
+        >>> # Process response content
+        >>> for chunk in sanitize_stream(response.iter_content()):
+        ...     process_chunk(chunk)
+        
+        >>> # Process a stream with specific encoding
+        >>> for text in sanitize_stream(byte_stream, encoding='latin1', to_json=False):
+        ...     process_text(text)
+    """
+    effective_skip_markers = skip_markers or []
+    processing_active = start_marker is None
+
+    if isinstance(data, (str, bytes)):
+        # Optimized single string/bytes processing
+        processed_item = None
+        if isinstance(data, bytes):
+            data = data.decode(encoding, errors=encoding_errors)
+        if to_json:
+            try:
+                processed_item = json.loads(data)
+            except json.JSONDecodeError:
+                pass
+
+        if processed_item is None:
+            if not processing_active and data == start_marker:
+                processing_active = True
+            elif processing_active and end_marker is not None and data == end_marker:
+                processing_active = False
+
+            if processing_active:
+                processed_item = _process_chunk(
+                    data, intro_value, to_json, effective_skip_markers, 
+                    strip_chars, yield_raw_on_error
+                )
+
+        if processed_item is not None:
+            if content_extractor:
+                try:
+                    final_content = content_extractor(processed_item)
+                    if final_content is not None:
+                        yield final_content
+                except Exception:
+                    pass
+            else:
+                yield processed_item
+
+    elif hasattr(data, '__iter__') or hasattr(data, 'iter_content'):
+        # Efficient stream processing
+        try:
+            if hasattr(data, 'iter_content'):
+                data = data.iter_content(chunk_size=chunk_size)
+            first_item = next(iter(data))
+        except StopIteration:
+            return
+
+        from itertools import chain
+        stream = chain([first_item], data)
+
+        # Choose processing path based on type
+        if isinstance(first_item, bytes):
+            line_iterator = _decode_byte_stream(
+                stream, 
+                encoding=encoding,
+                errors=encoding_errors
+            )
+        elif isinstance(first_item, str):
+            line_iterator = stream
+        else:
+            raise TypeError(f"Stream must yield strings or bytes, not {type(first_item).__name__}")
+
+        # Process stream efficiently
+        for line in line_iterator:
+            if not processing_active and start_marker is not None and line == start_marker:
+                processing_active = True
+                continue
+            if processing_active and end_marker is not None and line == end_marker:
+                processing_active = False
+                continue
+            
+            if processing_active:
+                processed = _process_chunk(
+                    line, intro_value, to_json, effective_skip_markers,
+                    strip_chars, yield_raw_on_error
+                )
+                
+                if processed is not None:
+                    if content_extractor:
+                        try:
+                            final_content = content_extractor(processed)
+                            if final_content is not None:
+                                yield final_content
+                        except Exception:
+                            pass
+                    else:
+                        yield processed
+    else:
+        raise TypeError(f"Input must be a string or an iterable, not {type(data).__name__}")
+
+from .conversation import Conversation
+from .optimizers import Optimizers
+from .Extra.autocoder import AutoCoder
+from .prompt_manager import AwesomePrompts

{webscout-8.2.5 → webscout-8.2.6}/webscout/Extra/autocoder/autocoder.py

@@ -7,19 +7,16 @@ import queue
 import tempfile
 import threading
 import subprocess
+from typing import Optional, Generator, List, Tuple, Dict, Any, NamedTuple
 from rich.panel import Panel
 from rich.syntax import Syntax
-from rich.console import Console, Group
+from rich.console import Console
 from rich.markdown import Markdown
 from rich.table import Table
 from rich.theme import Theme
 from rich.live import Live
-from rich.rule import Rule
 from rich.box import ROUNDED
-from typing import Optional, Generator, List, Tuple, Dict, Any
-from webscout.AIutel import run_system_command
 from .autocoder_utiles import get_intro_prompt
-
 # Initialize LitLogger with custom format and colors 
 default_path = tempfile.mkdtemp(prefix="webscout_autocoder")
 
@@ -34,6 +31,70 @@ CUSTOM_THEME = Theme({
 })
 
 console = Console(theme=CUSTOM_THEME)
+class CommandResult(NamedTuple):
+    """Result of a system command execution."""
+    success: bool
+    stdout: str
+    stderr: str
+    
+def run_system_command(
+    command: str,
+    exit_on_error: bool = False,
+    stdout_error: bool = False,
+    help: Optional[str] = None
+) -> Tuple[bool, CommandResult]:
+    """Execute a system command and return the result.
+    
+    Args:
+        command (str): Command to execute
+        exit_on_error (bool): Whether to exit on error. Defaults to False.
+        stdout_error (bool): Whether to include stdout in error messages. Defaults to False.
+        help (str, optional): Help message for errors. Defaults to None.
+        
+    Returns:
+        Tuple[bool, CommandResult]: Success status and command result containing stdout/stderr
+    """
+    try:
+        # Execute command and capture output
+        process = subprocess.Popen(
+            command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            shell=True,
+            text=True
+        )
+        
+        # Get stdout and stderr
+        stdout, stderr = process.communicate()
+        success = process.returncode == 0
+        
+        # Create result object
+        result = CommandResult(
+            success=success,
+            stdout=stdout.strip() if stdout else "",
+            stderr=stderr.strip() if stderr else ""
+        )
+        
+        # Handle errors if needed
+        if not success and exit_on_error:
+            error_msg = stderr if stderr else stdout if stdout_error else "Command failed"
+            if help:
+                error_msg += f"\n{help}"
+            sys.exit(error_msg)
+            
+        return success, result
+        
+    except Exception as e:
+        # Handle execution errors
+        error_msg = str(e)
+        if help:
+            error_msg += f"\n{help}"
+            
+        if exit_on_error:
+            sys.exit(error_msg)
+            
+        return False, CommandResult(success=False, stdout="", stderr=error_msg)
+
 
 class AutoCoder:
     """Generate and auto-execute Python scripts in the CLI with advanced error handling and retry logic.

{webscout-8.2.5 → webscout-8.2.6}/webscout/Provider/AISEARCH/scira_search.py

@@ -70,7 +70,8 @@ class Scira(AISearch):
 
     AVAILABLE_MODELS = {
         "scira-default": "Grok3-mini", # thinking model
-        "scira-grok-3": "Grok3", 
+        "scira-grok-3": "Grok3",
+        "scira-anthropic": "Sonnet 3.7 thinking",
         "scira-vision" : "Grok2-Vision", # vision model
         "scira-4.1-mini": "GPT4.1-mini",
         "scira-qwq": "QWQ-32B",

{webscout-8.2.5 → webscout-8.2.6}/webscout/Provider/GizAI.py

@@ -264,12 +264,12 @@ class GizAI(Provider):
         )
         return self.get_message(response_data)
     
-    def get_message(self, response: dict) -> str:
+    def get_message(self, response: Union[dict, str]) -> str:
         """
         Extracts the message from the API response.
         
         Args:
-            response (dict): The API response.
+            response (Union[dict, str]): The API response.
             
         Returns:
             str: The message content.
@@ -279,5 +279,7 @@ class GizAI(Provider):
             >>> response = ai.ask("Tell me a joke!")
             >>> message = ai.get_message(response)
         """
-        assert isinstance(response, dict), "Response should be of dict data-type only"
-        return response.get("text", "")
+        if isinstance(response, str):
+            return response
+        assert isinstance(response, dict), "Response should be either dict or str"
+        return response.get("text", "")