webscout 8.1__py3-none-any.whl → 8.2__py3-none-any.whl

webscout/Provider/toolbaz.py

@@ -0,0 +1,320 @@
+import re
+import requests
+import uuid
+import base64
+import json
+import random
+import string
+import time
+from datetime import datetime
+from typing import Any, Dict, Optional, Generator, Union, List
+
+from webscout.AIutel import Optimizers
+from webscout.AIutel import Conversation
+from webscout.AIutel import AwesomePrompts
+from webscout.AIbase import Provider, AsyncProvider
+from webscout import exceptions
+
+class Toolbaz(Provider):
+    """
+    A class to interact with the Toolbaz API. Supports streaming responses.
+    """
+
+    AVAILABLE_MODELS = [
+        "gemini-2.0-flash-thinking",
+        "gemini-2.0-flash",
+        "gemini-1.5-flash",
+        "gpt-4o-latest",
+        "gpt-4o-mini",
+        "gpt-4o",
+        "deepseek-r1",
+        "Llama-3.3-70B",
+        "Llama-3.1-405B",
+        "Llama-3.1-70B",
+        "Qwen2.5-72B",
+        "Qwen2-72B",
+        "grok-2-1212",
+        "grok-beta",
+        "toolbaz_v3.5_pro",
+        "toolbaz_v3",
+        "mixtral_8x22b",
+        "L3-70B-Euryale-v2.1",
+        "midnight-rose",
+        "unity",
+        "unfiltered_x"
+    ]
+
+    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,
+        model: str = "gemini-2.0-flash",
+        system_prompt: str = "You are a helpful AI assistant."
+    ):
+        """
+        Initializes the Toolbaz API with given parameters.
+        """
+        if model not in self.AVAILABLE_MODELS:
+            raise ValueError(f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}")
+
+        self.session = requests.Session()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.timeout = timeout
+        self.last_response = {}
+        self.system_prompt = system_prompt
+        self.model = model
+        self.proxies = proxies
+
+        # Set up headers
+        self.session.headers.update({
+            "user-agent": "Mozilla/5.0 (Linux; Android 10)",
+            "accept": "*/*",
+            "accept-language": "en-US",
+            "cache-control": "no-cache",
+            "connection": "keep-alive",
+            "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
+            "origin": "https://toolbaz.com",
+            "pragma": "no-cache",
+            "referer": "https://toolbaz.com/",
+            "sec-fetch-mode": "cors"
+        })
+
+        # Initialize conversation history
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+
+    def random_string(self, length):
+        return ''.join(random.choices(string.ascii_letters + string.digits, k=length))
+
+    def generate_token(self):
+        payload = {
+            "bR6wF": {
+                "nV5kP": "Mozilla/5.0 (Linux; Android 10)",
+                "lQ9jX": "en-US",
+                "sD2zR": "431x958",
+                "tY4hL": time.tzname[0] if time.tzname else "UTC",
+                "pL8mC": "Linux armv81",
+                "cQ3vD": datetime.now().year,
+                "hK7jN": datetime.now().hour
+            },
+            "uT4bX": {
+                "mM9wZ": [],
+                "kP8jY": []
+            },
+            "tuTcS": int(time.time()),
+            "tDfxy": None,
+            "RtyJt": str(uuid.uuid4())
+        }
+        return "d8TW0v" + base64.b64encode(json.dumps(payload).encode()).decode()
+
+    def get_auth(self):
+        try:
+            session_id = self.random_string(36)
+            token = self.generate_token()
+            data = {
+                "session_id": session_id,
+                "token": token
+            }
+            resp = self.session.post("https://data.toolbaz.com/token.php", data=data)
+            resp.raise_for_status()
+            result = resp.json()
+            if result.get("success"):
+                return {"token": result["token"], "session_id": session_id}
+            return None
+        except Exception:
+            return None
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,  # Kept for compatibility with other providers
+        optimizer: Optional[str] = None,
+        conversationally: bool = False,
+    ) -> Union[Dict[str, Any], Generator]:
+        """Sends a prompt to the Toolbaz API and returns the response."""
+        if optimizer and optimizer not in self.__available_optimizers:
+            raise exceptions.FailedToGenerateResponseError(f"Optimizer is not one of {self.__available_optimizers}")
+
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            conversation_prompt = getattr(Optimizers, optimizer)(
+                conversation_prompt if conversationally else prompt
+            )
+
+        auth = self.get_auth()
+        if not auth:
+            raise exceptions.ProviderConnectionError("Failed to authenticate with Toolbaz API")
+
+        data = {
+            "text": conversation_prompt,
+            "capcha": auth["token"],
+            "model": self.model,
+            "session_id": auth["session_id"]
+        }
+
+        def for_stream():
+            try:
+                resp = self.session.post(
+                    "https://data.toolbaz.com/writing.php",
+                    data=data,
+                    stream=True,
+                    proxies=self.proxies,
+                    timeout=self.timeout
+                )
+                resp.raise_for_status()
+
+                buffer = ""
+                tag_start = "[model:"
+                streaming_text = ""
+
+                for chunk in resp.iter_content(chunk_size=1):
+                    if chunk:
+                        text = chunk.decode(errors="ignore")
+                        buffer += text
+                        # Remove all complete [model: ...] tags in buffer
+                        while True:
+                            match = re.search(r"\[model:.*?\]", buffer)
+                            if not match:
+                                break
+                            buffer = buffer[:match.start()] + buffer[match.end():]
+                        # Only yield up to the last possible start of a tag
+                        last_tag = buffer.rfind(tag_start)
+                        if last_tag == -1 or last_tag + len(tag_start) > len(buffer):
+                            if buffer:
+                                streaming_text += buffer
+                                yield {"text": buffer}
+                                buffer = ""
+                        else:
+                            if buffer[:last_tag]:
+                                streaming_text += buffer[:last_tag]
+                                yield {"text": buffer[:last_tag]}
+                            buffer = buffer[last_tag:]
+
+                # Remove any remaining [model: ...] tag in the buffer
+                buffer = re.sub(r"\[model:.*?\]", "", buffer)
+                if buffer:
+                    streaming_text += buffer
+                    yield {"text": buffer}
+
+                self.last_response = {"text": streaming_text}
+                self.conversation.update_chat_history(prompt, streaming_text)
+
+            except requests.exceptions.RequestException as e:
+                raise exceptions.ProviderConnectionError(f"Network error: {str(e)}") from e
+            except Exception as e:
+                raise exceptions.ProviderConnectionError(f"Unexpected error: {str(e)}") from e
+
+        def for_non_stream():
+            try:
+                resp = self.session.post(
+                    "https://data.toolbaz.com/writing.php",
+                    data=data,
+                    proxies=self.proxies,
+                    timeout=self.timeout
+                )
+                resp.raise_for_status()
+
+                text = resp.text
+                # Remove [model: ...] tags
+                text = re.sub(r"\[model:.*?\]", "", text)
+
+                self.last_response = {"text": text}
+                self.conversation.update_chat_history(prompt, text)
+
+                return self.last_response
+
+            except requests.exceptions.RequestException as e:
+                raise exceptions.FailedToGenerateResponseError(f"Network error: {str(e)}") from e
+            except Exception as e:
+                raise exceptions.FailedToGenerateResponseError(f"Unexpected error: {str(e)}") from e
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: Optional[str] = None,
+        conversationally: bool = False,
+    ) -> Union[str, Generator[str, None, None]]:
+        """Generates a response from the Toolbaz API."""
+        def for_stream():
+            for response in self.ask(
+                prompt,
+                stream=True,
+                optimizer=optimizer,
+                conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    stream=False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: Dict[str, Any]) -> str:
+        """Extract the message from the response.
+
+        Args:
+            response: Response dictionary
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response.get("text", "")
+
+# Example usage
+if __name__ == "__main__":
+    # Test the provider with different models
+    for model in Toolbaz.AVAILABLE_MODELS:
+        try:
+            test_ai = Toolbaz(model=model, timeout=60)
+            response = test_ai.chat("Say 'Hello' in one word", stream=True)
+            response_text = ""
+            for chunk in response:
+                response_text += chunk
+                print(f"\r{model:<50} {'Testing...':<10}", end="", flush=True)
+
+            if response_text and len(response_text.strip()) > 0:
+                status = "✓"
+                # Truncate response if too long
+                display_text = response_text.strip()[:50] + "..." if len(response_text.strip()) > 50 else response_text.strip()
+            else:
+                status = "✗"
+                display_text = "Empty or invalid response"
+            print(f"\r{model:<50} {status:<10} {display_text}")
+        except Exception as e:
+            print(f"\r{model:<50} {'✗':<10} {str(e)}")

webscout/Provider/uncovr.py

@@ -20,14 +20,14 @@ class UncovrAI(Provider):
         "gpt-4o-mini",
         "gemini-2-flash",
         "gemini-2-flash-lite",
-        "groq-llama-3-1-8b"
+        "groq-llama-3-1-8b",
+        "o3-mini",
+        "deepseek-r1-distill-qwen-32b",
         # The following models are not available in the free plan:
-        # "o3-mini",
         # "claude-3-7-sonnet",
         # "gpt-4o",
         # "claude-3-5-sonnet-v2",
         # "deepseek-r1-distill-llama-70b",
-        # "deepseek-r1-distill-qwen-32b",
         # "gemini-2-flash-lite-preview",
         # "qwen-qwq-32b"
     ]

webscout/conversation.py

@@ -281,11 +281,11 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
             if not os.path.exists(self.file):
                 with open(self.file, "w", encoding="utf-8") as fh:
                     fh.write(self.intro + "\n")
-            
+
             # Append new history
             with open(self.file, "a", encoding="utf-8") as fh:
                 fh.write(new_history)
-        
+
         self.chat_history += new_history
         # logger.info(f"Chat history updated with prompt: {prompt}")
 
@@ -317,21 +317,21 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
             "tool": tool_name,
             "result": tool_result
         }
-        
+
         if self.file and self.update_file:
             # Create file if it doesn't exist
             if not os.path.exists(self.file):
                 with open(self.file, "w", encoding="utf-8") as fh:
                     fh.write(self.intro + "\n")
-            
+
             # Append new history
             with open(self.file, "a", encoding="utf-8") as fh:
                 fh.write(new_history)
-        
+
         self.chat_history += new_history
 
     def add_message(self, role: str, content: str) -> None:
-        """Add a new message to the chat - simple and clean! 
+        """Add a new message to the chat - simple and clean!
 
         This method:
         - Validates the message role
@@ -379,10 +379,10 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
 
     def _parse_function_call(self, response: str) -> FunctionCallData:
         """Parse a function call from the LLM's response.
-        
+
         Args:
             response (str): The LLM's response containing a function call
-            
+
         Returns:
             FunctionCallData: Parsed function call data or error
         """
@@ -399,13 +399,13 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
                 end_tag = "</tool_call>"
                 start_idx = response.find(start_tag)
                 end_idx = response.rfind(end_tag)
-                
+
                 if start_idx == -1 or end_idx == -1 or end_idx <= start_idx:
                     raise ValueError("No valid <tool_call> JSON structure found in the response.")
-                
+
                 # Extract JSON content - for the format without brackets
                 json_str: str = response[start_idx + len(start_tag):end_idx].strip()
-                
+
                 # Try to parse the JSON directly
                 try:
                     parsed_response: Any = json.loads(json_str)
@@ -425,7 +425,7 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
                 # Extract JSON content - for the format with brackets
                 json_str: str = response[start_idx + len(start_tag):end_idx].strip()
                 parsed_response: Any = json.loads(json_str)
-                
+
                 if isinstance(parsed_response, list):
                     return {"tool_calls": parsed_response}
                 elif isinstance(parsed_response, dict):
@@ -439,10 +439,10 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
 
     def execute_function(self, function_call_data: FunctionCallData) -> str:
         """Execute a function call and return the result.
-        
+
         Args:
             function_call_data (FunctionCallData): The function call data
-            
+
         Returns:
             str: Result of the function execution
         """
@@ -450,7 +450,7 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
 
         if not tool_calls or not isinstance(tool_calls, list):
             return "Invalid tool_calls format."
-        
+
         results: List[str] = []
         for tool_call in tool_calls:
             function_name: str = tool_call.get("name")
@@ -465,19 +465,19 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
             results.append(f"Executed {function_name} with arguments {arguments}")
 
         return "; ".join(results)
-        
+
     def _convert_fns_to_tools(self, fns: Optional[List[Fn]]) -> List[ToolDefinition]:
         """Convert functions to tool definitions for the LLM.
-        
+
         Args:
             fns (Optional[List[Fn]]): List of function definitions
-            
+
         Returns:
             List[ToolDefinition]: List of tool definitions
         """
         if not fns:
             return []
-        
+
         tools: List[ToolDefinition] = []
         for fn in fns:
             tool: ToolDefinition = {
@@ -499,55 +499,55 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
             }
             tools.append(tool)
         return tools
-        
+
     def get_tools_description(self) -> str:
         """Get a formatted string of available tools for the intro prompt.
-        
+
         Returns:
             str: Formatted tools description
         """
         if not self.tools:
             return ""
-            
+
         tools_desc = []
         for fn in self.tools:
             params_desc = ", ".join([f"{name}: {typ}" for name, typ in fn.parameters.items()])
             tools_desc.append(f"- {fn.name}: {fn.description} (Parameters: {params_desc})")
-            
+
         return "\n".join(tools_desc)
 
     def handle_tool_response(self, response: str) -> Dict[str, Any]:
         """Process a response that might contain a tool call.
-        
+
         This method:
         - Checks if the response contains a tool call
         - Parses and executes the tool call if present
         - Returns the appropriate result
-        
+
         Args:
             response (str): The LLM's response
-            
+
         Returns:
             Dict[str, Any]: Result containing 'is_tool_call', 'result', and 'original_response'
         """
         # Check if response contains a tool call
         if "<tool_call>" in response:
             function_call_data = self._parse_function_call(response)
-            
+
             if "error" in function_call_data:
                 return {
-                    "is_tool_call": True, 
+                    "is_tool_call": True,
                     "success": False,
                     "result": function_call_data["error"],
                     "original_response": response
                 }
-                
+
             # Execute the function call
             result = self.execute_function(function_call_data)
-            
+
             # Add the result to chat history as a tool message
             self.add_message("tool", result)
-            
+
             return {
                 "is_tool_call": True,
                 "success": True,
@@ -555,7 +555,7 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
                 "tool_calls": function_call_data.get("tool_calls", []),
                 "original_response": response
             }
-        
+
         return {
             "is_tool_call": False,
             "result": response,

webscout/version.py

@@ -1,2 +1,2 @@
-__version__ = "8.1"
+__version__ = "8.2"
 __prog__ = "webscout"

{webscout-8.1.dist-info → webscout-8.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: webscout
-Version: 8.1
+Version: 8.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
@@ -8,10 +8,17 @@ License: HelpingAI
 Project-URL: Source, https://github.com/OE-LUCIFER/Webscout
 Project-URL: Tracker, https://github.com/OE-LUCIFER/Webscout/issues
 Project-URL: YouTube, https://youtube.com/@OEvortex
+Keywords: search,ai,chatbot,llm,language-model,gpt,openai,gemini,claude,llama,search-engine,text-to-speech,tts,text-to-image,tti,weather,youtube,toolkit,utilities,web-search,duckduckgo,google,yep
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Science/Research
 Classifier: License :: Other/Proprietary License
+Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -21,6 +28,10 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Communications
+Classifier: Topic :: Utilities
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
@@ -55,6 +66,15 @@ Requires-Dist: pyreqwest-impersonate
 Requires-Dist: gradio-client
 Requires-Dist: psutil
 Requires-Dist: aiohttp
+Provides-Extra: local
+Requires-Dist: llama-cpp-python; extra == "local"
+Requires-Dist: fastapi; extra == "local"
+Requires-Dist: uvicorn; extra == "local"
+Requires-Dist: rich; extra == "local"
+Requires-Dist: typer; extra == "local"
+Requires-Dist: huggingface-hub; extra == "local"
+Requires-Dist: pydantic; extra == "local"
+Requires-Dist: requests; extra == "local"
 Provides-Extra: dev
 Requires-Dist: ruff>=0.1.6; extra == "dev"
 Requires-Dist: pytest>=7.4.2; extra == "dev"
@@ -82,9 +102,10 @@ Requires-Dist: pytest>=7.4.2; extra == "dev"
 </div>
 
 > [!IMPORTANT]
-> Webscout supports two types of compatibility:
+> Webscout supports three types of compatibility:
 > - **Native Compatibility:** Webscout's own native API for maximum flexibility
 > - **OpenAI Compatibility:** Use providers with OpenAI-compatible interfaces
+> - **Local LLM Compatibility:** Run local models with [Inferno](webscout/Local/README.md), an OpenAI-compatible server
 >
 > Choose the approach that best fits your needs! For OpenAI compatibility, check the [OpenAI Providers README](webscout/Provider/OPENAI/README.md).
 
@@ -108,9 +129,10 @@ Requires-Dist: pytest>=7.4.2; extra == "dev"
 
 ### Search & AI
 * **Comprehensive Search:** Leverage Google, DuckDuckGo, and Yep for diverse search results
-* **AI Powerhouse:** Access and interact with various AI models through two compatibility options:
+* **AI Powerhouse:** Access and interact with various AI models through three compatibility options:
   * **Native API:** Use Webscout's native interfaces for providers like OpenAI, Cohere, Gemini, and many more
   * **[OpenAI-Compatible Providers](webscout/Provider/OPENAI/README.md):** Seamlessly integrate with various AI providers using standardized OpenAI-compatible interfaces
+  * **[Local LLMs with Inferno](webscout/Local/README.md):** Run local models with an OpenAI-compatible server
 * **[AI Search](webscout/Provider/AISEARCH/README.md):** AI-powered search engines with advanced capabilities
 
 ### Media & Content Tools
@@ -126,6 +148,7 @@ Requires-Dist: pytest>=7.4.2; extra == "dev"
 * **[LitLogger](webscout/litlogger/Readme.md):** Simplified logging with customizable formats and color schemes
 * **[LitAgent](webscout/litagent/Readme.md):** Modern user agent generator that keeps your requests undetectable
 * **[Scout](webscout/scout/README.md):** Advanced web parsing and crawling library with intelligent HTML/XML parsing
+* **[Inferno](webscout/Local/README.md):** Run local LLMs with an OpenAI-compatible API and interactive CLI
 * **GGUF Conversion:** Convert and quantize Hugging Face models to GGUF format
 
 ### Privacy & Utilities
@@ -148,6 +171,8 @@ Webscout provides a powerful command-line interface for quick access to its feat
 python -m webscout --help
 ```
 
+### Web Search Commands
+
 | Command | Description |
 |---------|-------------|
 | `python -m webscout answers -k "query"` | Perform an answers search |
@@ -162,6 +187,32 @@ python -m webscout --help
 | `python -m webscout videos -k "query"` | Search for videos |
 | `python -m webscout weather -l "location"` | Get weather information |
 
+### Inferno LLM Commands
+
+Inferno provides commands for managing and using local LLMs:
+
+```bash
+python -m inferno --help
+```
+
+| Command | Description |
+|---------|-------------|
+| `python -m inferno pull <model>` | Download a model from Hugging Face |
+| `python -m inferno list` | List downloaded models |
+| `python -m inferno serve <model>` | Start a model server with OpenAI-compatible API |
+| `python -m inferno run <model>` | Chat with a model interactively |
+| `python -m inferno remove <model>` | Remove a downloaded model |
+| `python -m inferno version` | Show version information |
+
+> [!NOTE]
+> Hardware requirements for running models:
+> - Around 2 GB of RAM for 1B models
+> - Around 4 GB of RAM for 3B models
+> - At least 8 GB of RAM for 7B models
+> - 16 GB of RAM for 13B models
+> - 32 GB of RAM for 33B models
+> - GPU acceleration is recommended for better performance
+
 
 
 ## 🔍 Search Engines