webscout 8.2__tar.gz → 8.2.2__tar.gz

{webscout-8.2/webscout.egg-info → webscout-8.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: webscout
-Version: 8.2
+Version: 8.2.2
 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 → webscout-8.2.2}/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 → webscout-8.2.2}/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 → webscout-8.2.2}/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.2/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.2/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 → webscout-8.2.2}/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:
     """

{webscout-8.2 → webscout-8.2.2}/webscout/Local/llm.py

@@ -37,29 +37,75 @@ class LLMInterface:
             raise ValueError(f"Model {model_name} not found. Please download it first.")
         self.llm = None
 
-    def load_model(self, n_gpu_layers: Optional[int] = None, n_ctx: Optional[int] = None, verbose: bool = False) -> None:
+    def load_model(
+        self,
+        n_gpu_layers: Optional[int] = None,
+        n_ctx: Optional[int] = None,
+        verbose: bool = False,
+        n_threads: Optional[int] = None,
+        n_batch: Optional[int] = None,
+        use_mlock: bool = False,
+        use_mmap: bool = True,
+        rope_freq_base: Optional[float] = None,
+        rope_freq_scale: Optional[float] = None,
+        low_vram: bool = False,
+    ) -> None:
         """
         Load the model into memory.
         Args:
             n_gpu_layers (Optional[int]): Number of layers to offload to GPU (-1 for all).
             n_ctx (Optional[int]): Context size.
             verbose (bool): Whether to show verbose output.
+            n_threads (Optional[int]): Number of threads to use.
+            n_batch (Optional[int]): Batch size for prompt processing.
+            use_mlock (bool): Whether to use mlock to keep model in memory.
+            use_mmap (bool): Whether to use memory mapping for the model.
+            rope_freq_base (Optional[float]): RoPE base frequency.
+            rope_freq_scale (Optional[float]): RoPE frequency scaling factor.
+            low_vram (bool): Whether to optimize for low VRAM usage.
         Raises:
             ValueError: If model loading fails.
         """
+        # If model is already loaded, check if we need to reload with different parameters
+        if self.llm is not None:
+            if n_ctx is not None and hasattr(self.llm, 'n_ctx') and self.llm.n_ctx != n_ctx:
+                # Need to reload with new context size
+                self.llm = None
+            else:
+                # Model already loaded with compatible parameters
+                return
+
         if n_gpu_layers is None:
             n_gpu_layers = config.get("default_gpu_layers", -1)
         if n_ctx is None:
             n_ctx = config.get("default_context_length", 4096)
+
+        # Determine number of threads if not specified
+        if n_threads is None:
+            import multiprocessing
+            n_threads = max(1, multiprocessing.cpu_count() // 2)
+
         console.print(f"[bold blue]Loading model {self.model_name}...[/bold blue]")
         try:
             self.llm = Llama(
                 model_path=self.model_path,
                 n_gpu_layers=n_gpu_layers,
                 n_ctx=n_ctx,
-                verbose=verbose
+                verbose=verbose,
+                n_threads=n_threads,
+                n_batch=n_batch or 512,
+                use_mlock=use_mlock,
+                use_mmap=use_mmap,
+                rope_freq_base=rope_freq_base,
+                rope_freq_scale=rope_freq_scale,
+                low_vram=low_vram,
             )
+
             console.print(f"[bold green]Model {self.model_name} loaded successfully[/bold green]")
+            if verbose:
+                console.print(f"[dim]Using {n_threads} threads, context size: {n_ctx}[/dim]")
+                if n_gpu_layers and n_gpu_layers > 0:
+                    console.print(f"[dim]GPU acceleration: {n_gpu_layers} layers offloaded to GPU[/dim]")
         except Exception as e:
             raise ValueError(f"Failed to load model from file: {self.model_path}\n{str(e)}")
 
@@ -71,6 +117,13 @@ class LLMInterface:
         top_p: float = 0.95,
         stream: bool = False,
         stop: Optional[List[str]] = None,
+        suffix: Optional[str] = None,
+        images: Optional[List[str]] = None,
+        system: Optional[str] = None,
+        template: Optional[str] = None,
+        context: Optional[List[int]] = None,
+        raw: bool = False,
+        format: Optional[Union[str, Dict[str, Any]]] = None,
     ) -> Union[Dict[str, Any], Generator[Dict[str, Any], None, None]]:
         """
         Create a completion for the given prompt.
@@ -107,12 +160,14 @@ class LLMInterface:
 
     def create_chat_completion(
         self,
-        messages: List[Dict[str, str]],
+        messages: List[Dict[str, Any]],
         max_tokens: int = 256,
         temperature: float = 0.7,
         top_p: float = 0.95,
         stream: bool = False,
         stop: Optional[List[str]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        format: Optional[Union[str, Dict[str, Any]]] = None,
     ) -> Union[Dict[str, Any], Generator[Dict[str, Any], None, None]]:
         """
         Create a chat completion for the given messages.
@@ -156,22 +211,26 @@ class LLMInterface:
 
     def stream_chat_completion(
         self,
-        messages: List[Dict[str, str]],
+        messages: List[Dict[str, Any]],
         callback: Callable[[str], None],
         max_tokens: int = 256,
         temperature: float = 0.7,
         top_p: float = 0.95,
         stop: Optional[List[str]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+        format: Optional[Union[str, Dict[str, Any]]] = None,
     ) -> None:
         """
         Stream a chat completion with a callback for each token.
         Args:
-            messages (List[Dict[str, str]]): List of chat messages.
+            messages (List[Dict[str, Any]]): List of chat messages.
             callback (Callable[[str], None]): Function to call with each token.
             max_tokens (int): Maximum number of tokens to generate.
             temperature (float): Sampling temperature.
             top_p (float): Top-p sampling.
             stop (Optional[List[str]]): List of strings to stop generation when encountered.
+            tools (Optional[List[Dict[str, Any]]]): List of tools for function calling.
+            format (Optional[Union[str, Dict[str, Any]]]): Format for structured output.
         """
         stream = self.create_chat_completion(
             messages=messages,
@@ -186,3 +245,43 @@ class LLMInterface:
                 if "delta" in chunk["choices"][0] and "content" in chunk["choices"][0]["delta"]:
                     content = chunk["choices"][0]["delta"]["content"]
                     callback(content)
+
+    def create_embeddings(
+        self,
+        input: Union[str, List[str]],
+        truncate: bool = True,
+    ) -> Dict[str, Any]:
+        """
+        Generate embeddings for the given input.
+        Args:
+            input (Union[str, List[str]]): Text or list of texts to generate embeddings for.
+            truncate (bool): Whether to truncate the input to fit within context length.
+        Returns:
+            Dict[str, Any]: Embeddings response.
+        """
+        if self.llm is None:
+            self.load_model()
+
+        # Convert input to list if it's a string
+        if isinstance(input, str):
+            input_texts = [input]
+        else:
+            input_texts = input
+
+        # Generate embeddings for each input text
+        embeddings = []
+        for text in input_texts:
+            # Use llama-cpp-python's embedding method
+            embedding = self.llm.embed(text)
+            embeddings.append(embedding)
+
+        # Create response
+        response = {
+            "model": self.model_name,
+            "embeddings": embeddings,
+            "total_duration": 0,  # Could be improved with actual timing
+            "load_duration": 0,   # Could be improved with actual timing
+            "prompt_eval_count": len(input_texts)
+        }
+
+        return response

{webscout-8.2 → webscout-8.2.2}/webscout/Local/model_manager.py

@@ -203,3 +203,51 @@ class ModelManager:
                     return model_info.get("path")
             return None
         return info["path"]
+
+    def copy_model(self, source_model: str, destination_model: str) -> bool:
+        """
+        Copy a model to a new name.
+        Args:
+            source_model (str): Name of the source model.
+            destination_model (str): Name for the destination model.
+        Returns:
+            bool: True if copied successfully, False otherwise.
+        """
+        # Get source model info
+        source_info = self.get_model_info(source_model)
+        if not source_info or "path" not in source_info:
+            console.print(f"[bold red]Source model {source_model} not found[/bold red]")
+            return False
+
+        # Create destination directory
+        dest_dir = config.get_model_path(destination_model)
+        dest_dir.mkdir(exist_ok=True, parents=True)
+
+        # Copy the model file
+        source_path = Path(source_info["path"])
+        dest_path = dest_dir / source_path.name
+
+        try:
+            console.print(f"[bold blue]Copying model from {source_path} to {dest_path}...[/bold blue]")
+            shutil.copy2(source_path, dest_path)
+
+            # Create info file for the destination model
+            dest_info = source_info.copy()
+            dest_info["name"] = destination_model
+            dest_info["path"] = str(dest_path)
+            dest_info["copied_from"] = source_model
+            dest_info["copied_at"] = datetime.datetime.now().isoformat()
+
+            with open(dest_dir / "info.json", "w") as f:
+                json.dump(dest_info, f, indent=2)
+
+            console.print(f"[bold green]Model copied successfully to {dest_path}[/bold green]")
+            return True
+        except Exception as e:
+            console.print(f"[bold red]Error copying model: {str(e)}[/bold red]")
+            # Clean up if there was an error
+            if dest_path.exists():
+                dest_path.unlink()
+            if dest_dir.exists():
+                shutil.rmtree(dest_dir)
+            return False