webscout 3.0b0__tar.gz → 3.1__tar.gz

{webscout-3.0b0 → webscout-3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: webscout
-Version: 3.0b0
+Version: 3.1
 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
 Author: OEvortex
 Author-email: helpingai5@gmail.com
@@ -142,6 +142,8 @@ Search for anything using Google, DuckDuckGo, phind.com, Contains AI models, can
     - [16. `BasedGPT` - chat with GPT](#16-basedgpt---chat-with-gpt)
     - [`LLM`](#llm)
     - [`Local-LLM` webscout can now run GGUF models](#local-llm-webscout-can-now-run-gguf-models)
+    - [`Function-calling-local-llm`](#function-calling-local-llm)
+    - [`Local-rawdog`](#local-rawdog)
     - [`LLM` with internet](#llm-with-internet)
     - [LLM with deepwebs](#llm-with-deepwebs)
   - [`Webai` - terminal gpt and a open interpeter](#webai---terminal-gpt-and-a-open-interpeter)
@@ -1244,6 +1246,7 @@ while True:
     print("AI: ", response)
 ```
 ### `Local-LLM` webscout can now run GGUF models
+Local LLM's some functions are taken from easy-llama
 ```python
 from webscout.Local.utils import download_model
 from webscout.Local.model import Model
@@ -1262,6 +1265,165 @@ thread = Thread(model, formats.phi3)
 
 # 4. Start interacting with the model
 thread.interact()
+```
+### `Function-calling-local-llm`
+```python
+from webscout.Local import Model, Thread, formats
+from webscout import DeepWEBS
+from webscout.Local.utils import download_model
+from webscout.Local.model import Model
+from webscout.Local.thread import Thread
+from webscout.Local import formats
+from webscout.Local.samplers import SamplerSettings
+def deepwebs_search(query, max_results=5):
+    """Performs a web search using DeepWEBS and returns results as JSON."""
+    deepwebs = DeepWEBS()
+    search_config = DeepWEBS.DeepSearch(
+        queries=[query],
+        max_results=max_results,
+        extract_webpage=False,
+        safe=False,
+        types=["web"],
+        overwrite_query_html=True,
+        overwrite_webpage_html=True,
+    )
+    search_results = deepwebs.queries_to_search_results(search_config)
+    formatted_results = []
+    for result in search_results[0]:  # Assuming only one query
+        formatted_results.append(f"Title: {result['title']}\nURL: {result['url']}\n")
+    return "\n".join(formatted_results)
+
+# Load your model
+repo_id = "OEvortex/HelpingAI-9B" 
+filename = "helpingai-9b.Q4_0.gguf"
+model_path = download_model(repo_id, filename, token='')
+
+# 2. Load the model 
+model = Model(model_path, n_gpu_layers=10)
+
+# Create a Thread
+system_prompt = "You are a helpful AI assistant. Respond to user queries concisely. If a user asks for information that requires a web search, use the `deepwebs_search` tool. Do not call the tool if it is not necessary."
+sampler = SamplerSettings(temp=0.7, top_p=0.9)  # Adjust these values as needed
+# 4. Create a custom chatml format with your system prompt
+custom_chatml = formats.chatml.copy()
+custom_chatml['system_content'] = system_prompt
+thread = Thread(model, custom_chatml, sampler=sampler)
+# Add the deepwebs_search tool
+thread.add_tool({
+    "type": "function",
+    "function": {
+        "name": "deepwebs_search",
+        "description": "Performs a web search using DeepWEBS and returns the title and URLs of the results.",
+        "execute": deepwebs_search,
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "The query to search on the web",
+                },
+                "max_results": {
+                    "type": "integer",
+                    "description": "Maximum number of search results (default: 5)",
+                },
+            },
+            "required": ["query"],
+        },
+    },
+})
+
+# Start interacting with the model
+while True:
+    user_input = input("You: ")
+    response = thread.send(user_input)
+    print("Bot: ", response) 
+```
+### `Local-rawdog`
+```python
+import webscout.Local as ws
+from webscout.Local.rawdog import RawDog
+from webscout.Local.samplers import DefaultSampling
+from webscout.Local.formats import chatml, AdvancedFormat
+from webscout.Local.utils import download_model
+import datetime
+import sys
+import os
+
+repo_id = "YorkieOH10/granite-8b-code-instruct-Q8_0-GGUF" 
+filename = "granite-8b-code-instruct.Q8_0.gguf"
+model_path = download_model(repo_id, filename, token='')
+
+# Load the model using the downloaded path
+model = ws.Model(model_path, n_gpu_layers=10)
+
+rawdog = RawDog()
+
+# Create an AdvancedFormat and modify the system content
+# Use a lambda to generate the prompt dynamically:
+chat_format = AdvancedFormat(chatml)
+#  **Pre-format the intro_prompt string:**
+system_content = f"""
+You are a command-line coding assistant called Rawdog that generates and auto-executes Python scripts.
+
+A typical interaction goes like this:
+1. The user gives you a natural language PROMPT.
+2. You:
+    i. Determine what needs to be done
+    ii. Write a short Python SCRIPT to do it
+    iii. Communicate back to the user by printing to the console in that SCRIPT
+3. The compiler extracts the script and then runs it using exec(). If there will be an exception raised,
+ it will be send back to you starting with "PREVIOUS SCRIPT EXCEPTION:".
+4. In case of exception, regenerate error free script.
+
+If you need to review script outputs before completing the task, you can print the word "CONTINUE" at the end of your SCRIPT.
+This can be useful for summarizing documents or technical readouts, reading instructions before
+deciding what to do, or other tasks that require multi-step reasoning.
+A typical 'CONTINUE' interaction looks like this:
+1. The user gives you a natural language PROMPT.
+2. You:
+    i. Determine what needs to be done
+    ii. Determine that you need to see the output of some subprocess call to complete the task
+    iii. Write a short Python SCRIPT to print that and then print the word "CONTINUE"
+3. The compiler
+    i. Checks and runs your SCRIPT
+    ii. Captures the output and appends it to the conversation as "LAST SCRIPT OUTPUT:"
+    iii. Finds the word "CONTINUE" and sends control back to you
+4. You again:
+    i. Look at the original PROMPT + the "LAST SCRIPT OUTPUT:" to determine what needs to be done
+    ii. Write a short Python SCRIPT to do it
+    iii. Communicate back to the user by printing to the console in that SCRIPT
+5. The compiler...
+
+Please follow these conventions carefully:
+- Decline any tasks that seem dangerous, irreversible, or that you don't understand.
+- Always review the full conversation prior to answering and maintain continuity.
+- If asked for information, just print the information clearly and concisely.
+- If asked to do something, print a concise summary of what you've done as confirmation.
+- If asked a question, respond in a friendly, conversational way. Use programmatically-generated and natural language responses as appropriate.
+- If you need clarification, return a SCRIPT that prints your question. In the next interaction, continue based on the user's response.
+- Assume the user would like something concise. For example rather than printing a massive table, filter or summarize it to what's likely of interest.
+- Actively clean up any temporary processes or files you use.
+- When looking through files, use git as available to skip files, and skip hidden files (.env, .git, etc) by default.
+- You can plot anything with matplotlib.
+- ALWAYS Return your SCRIPT inside of a single pair of ``` delimiters. Only the console output of the first such SCRIPT is visible to the user, so make sure that it's complete and don't bother returning anything else.
+"""
+chat_format.override('system_content', lambda: system_content)
+
+thread = ws.Thread(model, format=chat_format, sampler=DefaultSampling)
+
+while True:
+    prompt = input(">: ")
+    if prompt.lower() == "q":
+        break
+
+    response = thread.send(prompt)
+
+    # Process the response using RawDog
+    script_output = rawdog.main(response)
+
+    if script_output:
+        print(script_output)
+
 ```
 ### `LLM` with internet
 ```python
@@ -1427,41 +1589,316 @@ if __name__ == "__main__":
 ## `Webai` - terminal gpt and a open interpeter
 
 ```python
-from webscout.webai import Main
+import time
+import uuid
+from typing import Dict, Any, Optional, AsyncGenerator
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.style import Style
+import webscout
+import webscout.AIutel
+import g4f
+from webscout.g4f import *
+from webscout.async_providers import mapper as async_provider_map
 
-def use_rawdog_with_webai(prompt):
+class TaskExecutor:
     """
-    Wrap the webscout default method in a try-except block to catch any unhandled
-    exceptions and print a helpful message.
+    Manages an interactive chat session, handling user input, AI responses, 
+    and optional features like web search, code execution, and text-to-speech.
     """
-    try:
-        webai_bot = Main(
-            max_tokens=500, 
-            provider="cohere",
-            temperature=0.7,  
-            top_k=40,          
-            top_p=0.95,        
-            model="command-r-plus",  # Replace with your desired model
-            auth=None,     # Replace with your auth key/value (if needed)
-            timeout=30,
-            disable_conversation=True,
-            filepath=None,
-            update_file=True,
-            intro=None,
-            rawdog=True,
-            history_offset=10250,
-            awesome_prompt=None,
-            proxy_path=None,
-            quiet=True
+
+    def __init__(self) -> None:
+        """Initializes the conversational assistant with default settings."""
+        self._console: Console = Console()
+
+        # Session configuration
+        self._selected_provider: str = "phind"
+        self._selected_model: str = "Phind Model"
+        self._conversation_enabled: bool = True
+        self._max_tokens: int = 600
+        self._temperature: float = 0.2
+        self._top_k: int = -1
+        self._top_p: float = 0.999
+        self._timeout: int = 30
+        self._auth_token: str = None  # API key, if required
+        self._chat_completion_enabled: bool = True  # g4fauto
+        self._ignore_working: bool = False  # Ignore working status of providers
+        self._proxy_path: str = None  # Path to proxy configuration
+
+        # History Management
+        self._history_filepath: str = None
+        self._update_history_file: bool = True
+        self._history_offset: int = 10250
+
+        # Prompt Engineering
+        self._initial_prompt: str = None
+        self._awesome_prompt_content: str = None 
+
+        # Optional Features
+        self._web_search_enabled: bool = False  # Enable web search
+        self._rawdog_enabled: bool = True
+        self._internal_script_execution_enabled: bool = False
+        self._script_confirmation_required: bool = False
+        self._selected_interpreter: str = "python"
+        self._selected_optimizer: str = "code"
+        self._suppress_output: bool = False  # Suppress verbose output
+
+        # AI provider mapping
+        self._ai_provider_mapping: Dict[str, Any] = {
+            "phind": webscout.PhindSearch,
+            "opengpt": webscout.OPENGPT,
+            "koboldai": webscout.KOBOLDAI,
+            "blackboxai": webscout.BLACKBOXAI,
+            "llama2": webscout.LLAMA2,
+            "yepchat": webscout.YEPCHAT,
+            "leo": webscout.LEO,
+            "groq": webscout.GROQ,
+            "openai": webscout.OPENAI,
+            "perplexity": webscout.PERPLEXITY,
+            "you": webscout.YouChat,
+            "xjai": webscout.Xjai,
+            "cohere": webscout.Cohere,
+            "reka": webscout.REKA,
+            "thinkany": webscout.ThinkAnyAI,
+            "gemini": webscout.GEMINI, 
+            "berlin4h": webscout.Berlin4h,
+            "chatgptuk": webscout.ChatGPTUK,
+            "poe": webscout.POE,
+            "basedgpt": webscout.BasedGPT,
+        }
+
+        # Initialize Rawdog if enabled
+        if self._rawdog_enabled:
+            self._rawdog_instance: webscout.AIutel.RawDog = webscout.AIutel.RawDog(
+                quiet=self._suppress_output,
+                internal_exec=self._internal_script_execution_enabled,
+                confirm_script=self._script_confirmation_required,
+                interpreter=self._selected_interpreter,
+            )
+
+            self._initial_prompt = self._rawdog_instance.intro_prompt
+
+        # Initialize the selected AI model 
+        self._ai_model = self._get_ai_model()
+
+    def _get_ai_model(self):
+        """
+        Determines the appropriate AI model based on the selected provider, 
+        including automatic provider selection and g4fauto support.
+        """
+        if self._selected_provider == "g4fauto":
+            # Automatically select the best provider from g4f
+            test = TestProviders(quiet=self._suppress_output, timeout=self._timeout)
+            g4fauto = test.best if not self._ignore_working else test.auto
+            if isinstance(g4fauto, str):
+                self._selected_provider = "g4fauto+" + g4fauto
+                self._ai_model = self._create_g4f_model(g4fauto)
+            else:
+                raise Exception(
+                    "No working g4f provider found. "
+                    "Consider running 'webscout.webai gpt4free test -y' first"
+                )
+        else:
+            # Use the specified provider
+            self._ai_model = self._ai_provider_mapping[self._selected_provider](
+                is_conversation=self._conversation_enabled,
+                max_tokens=self._max_tokens,
+                timeout=self._timeout,
+                intro=self._initial_prompt,
+                filepath=self._history_filepath,
+                update_file=self._update_history_file,
+                proxies={},  # Load proxies from config if needed
+                history_offset=self._history_offset,
+                act=self._awesome_prompt_content, 
+                model=self._selected_model,
+                quiet=self._suppress_output,
+                # auth=self._auth_token,  # Pass API key if required
+            )
+        return self._ai_model
+
+    def _create_g4f_model(self, provider: str):
+        """
+        Creates a g4f model instance using the provided provider and webscout.WEBS for web search.
+        """
+        return webscout.g4f.GPT4FREE(
+            provider=provider,
+            auth=self._auth_token,
+            max_tokens=self._max_tokens,
+            chat_completion=self._chat_completion_enabled,
+            ignore_working=self._ignore_working,
+            timeout=self._timeout,
+            intro=self._initial_prompt,
+            filepath=self._history_filepath,
+            update_file=self._update_history_file,
+            proxies={},  # Load proxies from config if needed
+            history_offset=self._history_offset,
+            act=self._awesome_prompt_content, 
         )
-        webai_response = webai_bot.default(prompt) 
-    except Exception as e:
-        print("Unexpected error:", e)
 
+    def process_query(self, query: str) -> None:
+        """
+        Processes a user query, potentially enhancing it with web search results, 
+        passing it to the AI model, and handling the response.
+
+        Args:
+            query: The user's text input.
+
+        Returns:
+            None
+        """
+        if self._web_search_enabled:
+            query = self._augment_query_with_web_search(query)
+
+        # Apply code optimization if configured
+        if self._selected_optimizer == "code":
+            query = webscout.AIutel.Optimizers.code(query)
+
+        try:
+            response: str = self._ai_model.chat(query)
+        except webscout.exceptions.FailedToGenerateResponseError as e:
+            self._console.print(Markdown(f"LLM: [red]{e}[/red]"))
+            return
+
+        # Handle Rawdog responses if enabled
+        if self._rawdog_enabled:
+            self._handle_rawdog_response(response)
+        else:
+            self._console.print(Markdown(f"LLM: {response}"))
+
+    def _augment_query_with_web_search(self, query: str) -> str:
+        """Performs a web search and appends the results to the query.
+
+        Args:
+            query: The user's text input.
+
+        Returns:
+            str: The augmented query with web search results.
+        """
+        web_search_results = webscout.WEBS().text(query, max_results=3)
+        if web_search_results:
+            formatted_results = "\n".join(
+                f"{i+1}. {result['title']} - {result['href']}\n\nBody: {result['body']}"
+                for i, result in enumerate(web_search_results)
+            )
+            query += f"\n\n## Web Search Results are:\n\n{formatted_results}"
+        return query
+
+    def _handle_rawdog_response(self, response: str) -> None:
+        """Handles AI responses, potentially executing them as code with Rawdog.
+
+        Args:
+            response: The AI model's response.
+
+        Returns:
+            None
+        """
+        try:
+            is_feedback = self._rawdog_instance.main(response)
+        except Exception as e:
+            self._console.print(Markdown(f"LLM: [red]Error: {e}[/red]"))
+            return
+        if is_feedback:
+            self._console.print(Markdown(f"LLM: {is_feedback}"))
+        else:
+            self._console.print(Markdown("LLM: (Script executed successfully)"))
+
+    async def process_async_query(self, query: str) -> None:
+        """
+        Asynchronously processes a user query, potentially enhancing it with web search results, 
+        passing it to the AI model, and handling the response.
+
+        Args:
+            query: The user's text input.
+
+        Returns:
+            None
+        """
+        if self._web_search_enabled:
+            query = self._augment_query_with_web_search(query)
+
+        # Apply code optimization if configured
+        if self._selected_optimizer == "code":
+            query = webscout.AIutel.Optimizers.code(query)
+
+        async_model = self._get_async_ai_model()
+
+        try:
+            async for response in async_model.chat(query, stream=True):
+                self._console.print(Markdown(f"LLM: {response}"), end="")
+        except webscout.exceptions.FailedToGenerateResponseError as e:
+            self._console.print(Markdown(f"LLM: [red]{e}[/red]"))
+            return
+
+        # Handle Rawdog responses if enabled
+        if self._rawdog_enabled:
+            self._handle_rawdog_response(response)
+        else:
+            self._console.print(Markdown(f"LLM: {response}"))
+
+    def _get_async_ai_model(self):
+        """
+        Determines the appropriate asynchronous AI model based on the selected provider.
+        """
+        if self._selected_provider == "g4fauto":
+            # Automatically select the best provider from g4f
+            test = TestProviders(quiet=self._suppress_output, timeout=self._timeout)
+            g4fauto = test.best if not self._ignore_working else test.auto
+            if isinstance(g4fauto, str):
+                self._selected_provider = "g4fauto+" + g4fauto
+                self._ai_model = self._create_async_g4f_model(g4fauto)
+            else:
+                raise Exception(
+                    "No working g4f provider found. "
+                    "Consider running 'webscout gpt4free test -y' first"
+                )
+        else:
+            # Use the specified provider
+            if self._selected_provider in async_provider_map:
+                self._ai_model = async_provider_map[self._selected_provider](
+                    is_conversation=self._conversation_enabled,
+                    max_tokens=self._max_tokens,
+                    timeout=self._timeout,
+                    intro=self._initial_prompt,
+                    filepath=self._history_filepath,
+                    update_file=self._update_history_file,
+                    proxies={},  # Load proxies from config if needed
+                    history_offset=self._history_offset,
+                    act=self._awesome_prompt_content, 
+                    model=self._selected_model,
+                    quiet=self._suppress_output,
+                    auth=self._auth_token,  # Pass API key if required
+                )
+            else:
+                raise Exception(
+                    f"Asynchronous provider '{self._selected_provider}' is not yet supported"
+                )
+        return self._ai_model
+
+    def _create_async_g4f_model(self, provider: str):
+        """
+        Creates an asynchronous g4f model instance using the provided provider and webscout.WEBS for web search.
+        """
+        return webscout.g4f.AsyncGPT4FREE(
+            provider=provider,
+            auth=self._auth_token,
+            max_tokens=self._max_tokens,
+            chat_completion=self._chat_completion_enabled,
+            ignore_working=self._ignore_working,
+            timeout=self._timeout,
+            intro=self._initial_prompt,
+            filepath=self._history_filepath,
+            update_file=self._update_history_file,
+            proxies={},  # Load proxies from config if needed
+            history_offset=self._history_offset,
+            act=self._awesome_prompt_content,
+        )
 
 if __name__ == "__main__":
-    user_prompt = input("Enter your prompt: ")
-    use_rawdog_with_webai(user_prompt)
+    assistant = TaskExecutor()
+    while True:
+        input_query = input("Enter your query: ")
+        assistant.process_query(input_query)
 
 ```
 ```shell