webscout 8.2.1__tar.gz → 8.2.3__tar.gz

{webscout-8.2.1/webscout.egg-info → webscout-8.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: webscout
-Version: 8.2.1
+Version: 8.2.3
 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.3/webscout/AIbase.py

@@ -0,0 +1,260 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import AsyncGenerator, List, Union, Generator, Optional
+from typing_extensions import TypeAlias
+
+# Type aliases for better readability
+Response: TypeAlias = dict[str, Union[str, bool, None]]
+ImageData: TypeAlias = Union[bytes, str, Generator[bytes, None, None]]
+AsyncImageData: TypeAlias = Union[bytes, str, AsyncGenerator[bytes, None]]
+
+class AIProviderError(Exception):
+    pass
+
+class Provider(ABC):
+
+    @abstractmethod
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: Optional[str] = None,
+        conversationally: bool = False,
+    ) -> Response:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: Optional[str] = None,
+        conversationally: bool = False,
+    ) -> str:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    def get_message(self, response: Response) -> str:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+class AsyncProvider(ABC):
+
+    @abstractmethod
+    async def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: Optional[str] = None,
+        conversationally: bool = False,
+    ) -> Response:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    async def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: Optional[str] = None,
+        conversationally: bool = False,
+    ) -> str:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    async def get_message(self, response: Response) -> str:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+class TTSProvider(ABC):
+
+    @abstractmethod
+    def tts(self, text: str, voice: str = None, verbose: bool = False) -> str:
+        """Convert text to speech and save to a temporary file.
+
+        Args:
+            text (str): The text to convert to speech
+            voice (str, optional): The voice to use. Defaults to provider's default voice.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+
+        Returns:
+            str: Path to the generated audio file
+        """
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    def save_audio(self, audio_file: str, destination: str = None, verbose: bool = False) -> str:
+        """Save audio to a specific destination.
+
+        Args:
+            audio_file (str): Path to the source audio file
+            destination (str, optional): Destination path. Defaults to current directory with timestamp.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+
+        Returns:
+            str: Path to the saved audio file
+        """
+        import shutil
+        import os
+        from pathlib import Path
+        import time
+
+        source_path = Path(audio_file)
+
+        if not source_path.exists():
+            raise FileNotFoundError(f"Audio file not found: {audio_file}")
+
+        if destination is None:
+            # Create a default destination with timestamp in current directory
+            timestamp = int(time.time())
+            destination = os.path.join(os.getcwd(), f"tts_audio_{timestamp}{source_path.suffix}")
+
+        # Ensure the destination directory exists
+        os.makedirs(os.path.dirname(os.path.abspath(destination)), exist_ok=True)
+
+        # Copy the file
+        shutil.copy2(source_path, destination)
+
+        if verbose:
+            print(f"[debug] Audio saved to {destination}")
+
+        return destination
+
+    def stream_audio(self, text: str, voice: str = None, chunk_size: int = 1024, verbose: bool = False) -> Generator[bytes, None, None]:
+        """Stream audio in chunks.
+
+        Args:
+            text (str): The text to convert to speech
+            voice (str, optional): The voice to use. Defaults to provider's default voice.
+            chunk_size (int, optional): Size of audio chunks to yield. Defaults to 1024.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+
+        Yields:
+            Generator[bytes, None, None]: Audio data chunks
+        """
+        # Generate the audio file
+        audio_file = self.tts(text, voice=voice, verbose=verbose)
+
+        # Stream the file in chunks
+        with open(audio_file, 'rb') as f:
+            while chunk := f.read(chunk_size):
+                yield chunk
+
+class AsyncTTSProvider(ABC):
+
+    @abstractmethod
+    async def tts(self, text: str, voice: str = None, verbose: bool = False) -> str:
+        """Convert text to speech and save to a temporary file asynchronously.
+
+        Args:
+            text (str): The text to convert to speech
+            voice (str, optional): The voice to use. Defaults to provider's default voice.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+
+        Returns:
+            str: Path to the generated audio file
+        """
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    async def save_audio(self, audio_file: str, destination: str = None, verbose: bool = False) -> str:
+        """Save audio to a specific destination asynchronously.
+
+        Args:
+            audio_file (str): Path to the source audio file
+            destination (str, optional): Destination path. Defaults to current directory with timestamp.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+
+        Returns:
+            str: Path to the saved audio file
+        """
+        import shutil
+        import os
+        from pathlib import Path
+        import time
+        import asyncio
+
+        source_path = Path(audio_file)
+
+        if not source_path.exists():
+            raise FileNotFoundError(f"Audio file not found: {audio_file}")
+
+        if destination is None:
+            # Create a default destination with timestamp in current directory
+            timestamp = int(time.time())
+            destination = os.path.join(os.getcwd(), f"tts_audio_{timestamp}{source_path.suffix}")
+
+        # Ensure the destination directory exists
+        os.makedirs(os.path.dirname(os.path.abspath(destination)), exist_ok=True)
+
+        # Copy the file using asyncio to avoid blocking
+        await asyncio.to_thread(shutil.copy2, source_path, destination)
+
+        if verbose:
+            print(f"[debug] Audio saved to {destination}")
+
+        return destination
+
+    async def stream_audio(self, text: str, voice: str = None, chunk_size: int = 1024, verbose: bool = False) -> AsyncGenerator[bytes, None]:
+        """Stream audio in chunks asynchronously.
+
+        Args:
+            text (str): The text to convert to speech
+            voice (str, optional): The voice to use. Defaults to provider's default voice.
+            chunk_size (int, optional): Size of audio chunks to yield. Defaults to 1024.
+            verbose (bool, optional): Whether to print debug information. Defaults to False.
+
+        Yields:
+            AsyncGenerator[bytes, None]: Audio data chunks
+        """
+        import aiofiles
+
+        # Generate the audio file
+        audio_file = await self.tts(text, voice=voice, verbose=verbose)
+
+        # Stream the file in chunks
+        async with aiofiles.open(audio_file, 'rb') as f:
+            while chunk := await f.read(chunk_size):
+                yield chunk
+
+class ImageProvider(ABC):
+
+    @abstractmethod
+    def generate(self, prompt: str, amount: int = 1) -> List[bytes]:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    def save(
+        self,
+        response: List[bytes],
+        name: Optional[str] = None,
+        dir: Optional[Union[str, Path]] = None
+    ) -> List[str]:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+class AsyncImageProvider(ABC):
+
+    @abstractmethod
+    async def generate(
+        self,
+        prompt: str,
+        amount: int = 1
+    ) -> Union[AsyncGenerator[bytes, None], List[bytes]]:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    async def save(
+        self,
+        response: Union[AsyncGenerator[bytes, None], List[bytes]],
+        name: Optional[str] = None,
+        dir: Optional[Union[str, Path]] = None
+    ) -> List[str]:
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+class AISearch(ABC):
+
+    @abstractmethod
+    def search(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+    ) -> Response:
+        raise NotImplementedError("Method needs to be implemented in subclass")

{webscout-8.2.1 → webscout-8.2.3}/webscout/Bard.py

@@ -76,6 +76,11 @@ class Model(Enum):
         {"x-goog-ext-525001261-jspb": '[null,null,null,null,"203e6bb81620bcfe"]'},
         True,
     )
+    G_2_5_FLASH = (
+        "gemini-2.5-flash",
+        {"x-goog-ext-525001261-jspb": '[1,null,null,null,"35609594dbe934d8"]'},
+        False,
+    )
 
     def __init__(self, name, header, advanced_only):
         self.model_name = name

{webscout-8.2.1 → webscout-8.2.3}/webscout/Extra/tempmail/__init__.py

@@ -12,6 +12,7 @@ from .base import (
 )
 from .mail_tm import MailTM, MailTMAsync
 from .temp_mail_io import TempMailIO, TempMailIOAsync
+from .emailnator import EmailnatorProvider
 
 __all__ = [
     'TempMailProvider',
@@ -20,6 +21,7 @@ __all__ = [
     'MailTMAsync',
     'TempMailIO',
     'TempMailIOAsync',
+    'EmailnatorProvider',
     'get_random_email',
     'get_disposable_email',
     'get_provider'

{webscout-8.2.1 → webscout-8.2.3}/webscout/Extra/tempmail/base.py

@@ -99,7 +99,7 @@ def get_provider(provider_name: str = "mailtm", async_provider: bool = False) ->
     Get a temporary email provider instance
 
     Args:
-        provider_name: Name of the provider to use ("mailtm" or "tempmailio")
+        provider_name: Name of the provider to use ("mailtm", "tempmailio", or "emailnator")
         async_provider: Whether to return an async provider
 
     Returns:
@@ -109,6 +109,8 @@ def get_provider(provider_name: str = "mailtm", async_provider: bool = False) ->
         if provider_name.lower() == "tempmailio":
             from .temp_mail_io import TempMailIOAsync
             return TempMailIOAsync()
+        elif provider_name.lower() == "emailnator":
+            raise NotImplementedError("Emailnator async provider not implemented.")
         else:
             from .mail_tm import MailTMAsync
             return MailTMAsync()
@@ -116,6 +118,9 @@ def get_provider(provider_name: str = "mailtm", async_provider: bool = False) ->
         if provider_name.lower() == "tempmailio":
             from .temp_mail_io import TempMailIO
             return TempMailIO()
+        elif provider_name.lower() == "emailnator":
+            from .emailnator import EmailnatorProvider
+            return EmailnatorProvider()
         else:
             from .mail_tm import MailTM
             return MailTM()

webscout-8.2.3/webscout/Extra/tempmail/emailnator.py

@@ -0,0 +1,84 @@
+"""
+Emailnator Provider Implementation
+Synchronous provider for Emailnator.com
+"""
+
+from typing import List, Dict
+from time import sleep
+from requests import Session
+from webscout.litagent import LitAgent
+from .base import TempMailProvider
+from json import loads
+from re import findall
+
+class EmailnatorProvider(TempMailProvider):
+    def __init__(self):
+        self.client = Session()
+        self.client.get("https://www.emailnator.com/", timeout=6)
+        self.cookies = self.client.cookies.get_dict()
+        self.user_agent = LitAgent()
+        self.client.headers = {
+            "authority": "www.emailnator.com",
+            "origin": "https://www.emailnator.com",
+            "referer": "https://www.emailnator.com/",
+            "user-agent": self.user_agent.random(),
+            "x-xsrf-token": self.client.cookies.get("XSRF-TOKEN")[:-3] + "=",
+        }
+        self.email = None
+        self._messages = []
+        self._account_deleted = False
+
+    def create_account(self) -> bool:
+        response = self.client.post(
+            "https://www.emailnator.com/generate-email",
+            json={"email": ["plusGmail", "dotGmail"]},
+        )
+        self.email = loads(response.text)["email"][0]
+        return bool(self.email)
+
+    def get_messages(self) -> List[Dict]:
+        # Wait for at least one message
+        for _ in range(30):  # Wait up to 60 seconds
+            sleep(2)
+            mail_token = self.client.post(
+                "https://www.emailnator.com/message-list", json={"email": self.email}
+            )
+            mail_token = loads(mail_token.text)["messageData"]
+            if len(mail_token) > 1:
+                break
+        else:
+            return []
+        # Get message details
+        messages = []
+        for msg in mail_token[1:]:
+            msg_id = msg["messageID"]
+            mail_context = self.client.post(
+                "https://www.emailnator.com/message-list",
+                json={"email": self.email, "messageID": msg_id},
+            )
+            # The response is HTML, so we just store it as body
+            messages.append({
+                "msg_id": msg_id,
+                "from": msg.get("from", ""),
+                "subject": msg.get("subject", ""),
+                "body": mail_context.text,
+            })
+        self._messages = messages
+        return messages
+
+    def check_new_messages(self) -> List[Dict]:
+        current = self.get_messages()
+        if not self._messages:
+            return current
+        # Return only new messages
+        old_ids = {m["msg_id"] for m in self._messages}
+        new_msgs = [m for m in current if m["msg_id"] not in old_ids]
+        return new_msgs
+
+    def delete_account(self) -> bool:
+        # Emailnator does not support explicit account deletion, so just mark as deleted
+        self._account_deleted = True
+        return True
+
+    def get_account_info(self) -> Dict:
+        return {"email": self.email, "deleted": self._account_deleted}

webscout-8.2.3/webscout/Local/__init__.py

@@ -0,0 +1,12 @@
+"""
+Webscout.Local - A llama-cpp-python based LLM serving tool with Ollama-compatible API
+"""
+from webscout.version import __version__
+
+# Import main components for easier access
+from .llm import LLMInterface
+from .model_manager import ModelManager
+from .server import start_server
+
+# Define what's available when using `from webscout.Local import *`
+__all__ = ["LLMInterface", "ModelManager", "start_server"]

{webscout-8.2.1 → webscout-8.2.3}/webscout/Local/cli.py

@@ -17,6 +17,16 @@ console: Console = Console()
 
 model_manager: ModelManager = ModelManager()
 
+# RAM requirements for different model sizes
+RAM_REQUIREMENTS = {
+    "1B": "2 GB",
+    "3B": "4 GB",
+    "7B": "8 GB",
+    "13B": "16 GB",
+    "33B": "32 GB",
+    "70B": "64 GB",
+}
+
 @app.command("serve")
 def run_model(
     model_string: str = typer.Argument(..., help="Model to run (format: 'name', 'repo_id' or 'repo_id:filename')"),
@@ -55,6 +65,16 @@ def run_model(
                 console.print(f"[bold red]Error downloading model: {str(e)}[/bold red]")
                 return
 
+    # Check RAM requirements
+    ram_requirement = "Unknown"
+    for size, ram in RAM_REQUIREMENTS.items():
+        if size in model_name:
+            ram_requirement = ram
+            break
+
+    if ram_requirement != "Unknown":
+        console.print(f"[yellow]This model requires approximately {ram_requirement} of RAM[/yellow]")
+
     # Try to load the model to verify it works
     try:
         llm = LLMInterface(model_name)
@@ -96,12 +116,42 @@ def list_models() -> None:
     table.add_column("Name", style="cyan")
     table.add_column("Repository", style="green")
     table.add_column("Filename", style="blue")
+    table.add_column("Size", style="magenta")
+    table.add_column("Downloaded", style="yellow")
 
     for model in models:
+        # Get file size in human-readable format
+        file_path = model.get("path")
+        file_size = "Unknown"
+        if file_path:
+            try:
+                import os
+                size_bytes = os.path.getsize(file_path)
+                # Convert to human-readable format
+                for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
+                    if size_bytes < 1024.0 or unit == 'TB':
+                        file_size = f"{size_bytes:.2f} {unit}"
+                        break
+                    size_bytes /= 1024.0
+            except Exception:
+                pass
+
+        # Format downloaded date
+        downloaded_at = model.get("downloaded_at", "Unknown")
+        if downloaded_at != "Unknown":
+            try:
+                import datetime
+                dt = datetime.datetime.fromisoformat(downloaded_at)
+                downloaded_at = dt.strftime("%Y-%m-%d %H:%M")
+            except Exception:
+                pass
+
         table.add_row(
             model["name"],
             model.get("repo_id", "Unknown"),
             model.get("filename", "Unknown"),
+            file_size,
+            downloaded_at,
         )
 
     console.print(table)
@@ -181,6 +231,16 @@ def chat(
                 console.print(f"[bold red]Error downloading model: {str(e)}[/bold red]")
                 return
 
+    # Check RAM requirements
+    ram_requirement = "Unknown"
+    for size, ram in RAM_REQUIREMENTS.items():
+        if size in model_name:
+            ram_requirement = ram
+            break
+
+    if ram_requirement != "Unknown":
+        console.print(f"[yellow]This model requires approximately {ram_requirement} of RAM[/yellow]")
+
     # Load the model
     try:
         llm = LLMInterface(model_name)
@@ -325,6 +385,124 @@ def chat(
         # Add extra spacing after the response
         console.print("")
 
+@app.command("copy")
+def copy_model(
+    source: str = typer.Argument(..., help="Name of the source model"),
+    destination: str = typer.Argument(..., help="Name for the destination model"),
+) -> None:
+    """
+    Copy a model to a new name.
+    """
+    try:
+        if model_manager.copy_model(source, destination):
+            console.print(f"[bold green]Model {source} copied to {destination} successfully[/bold green]")
+        else:
+            console.print(f"[bold red]Failed to copy model {source} to {destination}[/bold red]")
+    except Exception as e:
+        console.print(f"[bold red]Error copying model: {str(e)}[/bold red]")
+
+@app.command("show")
+def show_model(
+    model_name: str = typer.Argument(..., help="Name of the model to show information for"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed information"),
+) -> None:
+    """
+    Show detailed information about a model.
+    """
+    model_info = model_manager.get_model_info(model_name)
+
+    if not model_info:
+        console.print(f"[yellow]Model {model_name} not found.[/yellow]")
+        return
+
+    # Create a table for basic information
+    table = Table(title=f"Model Information: {model_name}")
+    table.add_column("Property", style="cyan")
+    table.add_column("Value", style="green")
+
+    # Add basic properties
+    table.add_row("Name", model_info["name"])
+    table.add_row("Repository", model_info.get("repo_id", "Unknown"))
+    table.add_row("Filename", model_info.get("filename", "Unknown"))
+
+    # Get file size in human-readable format
+    file_path = model_info.get("path")
+    if file_path:
+        try:
+            import os
+            size_bytes = os.path.getsize(file_path)
+            # Convert to human-readable format
+            for unit in ['B', 'KB', 'MB', 'GB', 'TB']:
+                if size_bytes < 1024.0 or unit == 'TB':
+                    file_size = f"{size_bytes:.2f} {unit}"
+                    break
+                size_bytes /= 1024.0
+            table.add_row("Size", file_size)
+        except Exception:
+            table.add_row("Size", "Unknown")
+
+    # Format downloaded date
+    downloaded_at = model_info.get("downloaded_at", "Unknown")
+    if downloaded_at != "Unknown":
+        try:
+            import datetime
+            dt = datetime.datetime.fromisoformat(downloaded_at)
+            downloaded_at = dt.strftime("%Y-%m-%d %H:%M")
+        except Exception:
+            pass
+    table.add_row("Downloaded", downloaded_at)
+
+    # Add copied information if available
+    if "copied_from" in model_info:
+        table.add_row("Copied From", model_info["copied_from"])
+        copied_at = model_info.get("copied_at", "Unknown")
+        if copied_at != "Unknown":
+            try:
+                import datetime
+                dt = datetime.datetime.fromisoformat(copied_at)
+                copied_at = dt.strftime("%Y-%m-%d %H:%M")
+            except Exception:
+                pass
+        table.add_row("Copied At", copied_at)
+
+    # Estimate RAM requirements based on model name
+    ram_requirement = "Unknown"
+    for size, ram in RAM_REQUIREMENTS.items():
+        if size in model_name:
+            ram_requirement = ram
+            break
+    table.add_row("Estimated RAM", ram_requirement)
+
+    # Print the table
+    console.print(table)
+
+    # If verbose, show all properties
+    if verbose:
+        console.print("\n[bold]Detailed Information:[/bold]")
+        for key, value in model_info.items():
+            if key not in ["name", "repo_id", "filename", "path", "downloaded_at", "copied_from", "copied_at"]:
+                console.print(f"[cyan]{key}:[/cyan] {value}")
+
+@app.command("ps")
+def list_running_models() -> None:
+    """
+    List running models.
+    """
+    from .server import loaded_models
+
+    if not loaded_models:
+        console.print("[yellow]No models currently running.[/yellow]")
+        return
+
+    table = Table(title="Running Models")
+    table.add_column("Name", style="cyan")
+    table.add_column("Status", style="green")
+
+    for name in loaded_models.keys():
+        table.add_row(name, "Running")
+
+    console.print(table)
+
 @app.command("version")
 def version() -> None:
     """