webscout 4.4__py3-none-any.whl → 4.5__py3-none-any.whl

webscout/AIutel.py

@@ -52,7 +52,8 @@ webai = [
    "vtlchat",
    "geminiflash",
    "geminipro",
-   "ollama"
+   "ollama",
+   "andi",
 ]
 
 gpt4free_providers = [

webscout/Agents/Onlinesearcher.py

@@ -0,0 +1,175 @@
+import json
+from webscout import WEBS
+import httpx
+from bs4 import BeautifulSoup
+from typing import List, Dict
+
+class DeepInfra:
+    def __init__(
+        self,
+        model: str = "meta-llama/Meta-Llama-3.1-70B-Instruct",
+        max_tokens: int = 8000,
+        timeout: int = 120,
+        system_prompt: str = "You are a helpful AI assistant.",
+        proxies: dict = {}
+    ):
+        self.model = model
+        self.max_tokens = max_tokens
+        self.timeout = timeout
+        self.system_prompt = system_prompt
+        self.chat_endpoint = "https://api.deepinfra.com/v1/openai/chat/completions"
+        
+        self.headers = {
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36',
+            'Accept-Language': 'en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+            'Content-Type': 'application/json',
+            'Origin': 'https://deepinfra.com',
+            'Pragma': 'no-cache',
+            'Referer': 'https://deepinfra.com/',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-site',
+            'X-Deepinfra-Source': 'web-embed',
+            'accept': 'text/event-stream',
+            'sec-ch-ua': '"Google Chrome";v="119", "Chromium";v="119", "Not?A_Brand";v="24"',
+            'sec-ch-ua-mobile': '?0',
+            'sec-ch-ua-platform': '"macOS"'
+        }
+        
+        self.client = httpx.Client(proxies=proxies, headers=self.headers)
+
+    def ask(self, prompt: str, system_prompt: str = None) -> str:
+        payload = {
+            'model': self.model,
+            'messages': [
+                {"role": "system", "content": system_prompt or self.system_prompt},
+                {"role": "user", "content": prompt},
+            ],
+            'temperature': 0.7,
+            'max_tokens': self.max_tokens,
+            'stop': []
+        }
+
+        response = self.client.post(self.chat_endpoint, json=payload, timeout=self.timeout)
+        if response.status_code != 200:
+            raise Exception(f"Failed to generate response - ({response.status_code}, {response.reason_phrase}) - {response.text}")
+
+        resp = response.json()
+        return resp["choices"][0]["message"]["content"]
+
+class WebSearchAgent:
+
+    def __init__(self, model="Qwen/Qwen2-72B-Instruct"):
+        self.webs = WEBS()
+        self.deepinfra = DeepInfra(model=model)
+
+    def generate_search_query(self, information):
+        prompt = f"""
+        Instructions:
+        You are a smart online searcher for a large language model.
+        Given information, you must create a search query to search the internet for relevant information.
+        Your search query must be in the form of a json response.
+        Exact json response format must be as follows:
+        
+        {{
+            "search_query": "your search query"
+        }}
+        - You must only provide ONE search query
+        - You must provide the BEST search query for the given information
+        - The search query must be normal text.
+
+        Information: {information}
+        """
+
+        response = self.deepinfra.ask(prompt)
+        return json.loads(response)["search_query"]
+
+    def search(self, information, region='wt-wt', safesearch='off', timelimit='y', max_results=5):
+        search_query = self.generate_search_query(information)
+        
+        results = []
+        with self.webs as webs:
+            for result in webs.text(search_query, region=region, safesearch=safesearch, timelimit=timelimit, max_results=max_results):
+                results.append(result)
+        
+        return results
+
+    def extract_urls(self, results):
+        urls = []
+        for result in results:
+            url = result.get('href')
+            if url:
+                urls.append(url)
+        return list(set(urls))  # Remove duplicates
+
+    def fetch_webpage(self, url: str) -> str:
+        try:
+            response = httpx.get(url, timeout=120)
+            if response.status_code == 200:
+                html = response.text
+                soup = BeautifulSoup(html, 'html.parser')
+                
+                # Extract text from <p> tags
+                paragraphs = soup.find_all('p')
+                text = ' '.join([p.get_text() for p in paragraphs])
+                
+                # Limit the text to around 4000 words
+                words = text.split()
+                if len(words) > 4000:
+                    text = ' '.join(words[:4000]) + '...'
+                
+                return text
+            else:
+                return f"Failed to fetch {url}: HTTP {response.status}"
+        except Exception as e:
+            return f"Error fetching {url}: {str(e)}"
+
+    def fetch_all_webpages(self, urls: List[str]) -> List[Dict[str, str]]:
+        contents = []
+        for url in urls:
+            content = self.fetch_webpage(url)
+            contents.append({"url": url, "content": content})
+        return contents
+
+class OnlineSearcher:
+    def __init__(self, model="meta-llama/Meta-Llama-3.1-405B-Instruct"):
+        self.agent = WebSearchAgent(model)
+        self.deepinfra = DeepInfra(model="model")
+
+    def answer_question(self, question: str) -> str:
+        # Perform web search
+        search_results = self.agent.search(question)
+
+        # Extract URLs
+        urls = self.agent.extract_urls(search_results)
+
+        # Fetch webpage contents
+        webpage_contents = self.agent.fetch_all_webpages(urls)
+
+        # Prepare context for AI
+        context = "Based on the following search results and webpage contents:\n\n"
+        for i, result in enumerate(search_results, 1):
+            context += f"{i}. Title: {result['title']}\n   URL: {result['href']}\n   Snippet: {result['body']}\n\n"
+
+        context += "Extracted webpage contents:\n"
+        for i, webpage in enumerate(webpage_contents):
+            context += f"{i}. URL: {webpage['url']}\n   Content: {webpage['content'][:4000]}...\n\n"
+
+        # Generate answer using AI
+        prompt = f"{context}\n\nQuestion: {question}\n\nPlease provide a comprehensive answer to the question based on the search results and webpage contents above. Include relevant webpage URLs in your answer when appropriate. If the search results and webpage contents don't contain relevant information, please state that and provide the best answer you can based on your general knowledge. [YOUR RESPONSE WITH SOURCE LINKS ([➊](URL))"
+
+        answer = self.deepinfra.ask(prompt)
+        return answer
+
+# Usage example
+if __name__ == "__main__":
+    assistant = OnlineSearcher()
+    while True:
+        question = input(">>> ")
+        if question.lower() == 'quit':
+            break
+        answer = assistant.answer_question(question)
+        print(answer)
+        print("\n" + "-"*50 + "\n")

webscout/Agents/__init__.py

@@ -0,0 +1,2 @@
+from .Onlinesearcher import *
+from .functioncall import *

webscout/Agents/functioncall.py

@@ -0,0 +1,126 @@
+import json
+import logging
+from webscout import DeepInfra, WEBS
+
+class FunctionCallingAgent:
+    def __init__(self, model: str = "Qwen/Qwen2-72B-Instruct", system_prompt: str = 'You are a helpful assistant that will always answer what user wants', tools: list = None):
+        self.deepinfra = DeepInfra(model=model, system_prompt=system_prompt)
+        self.tools = tools if tools is not None else []
+        # logging.basicConfig(level=logging.INFO)
+        # self.webs = WEBS()  # Initialize a WEBS object for web search
+
+    def function_call_handler(self, message_text: str):
+        """Handles function calls based on the provided message text
+
+        Args:
+            message_text (str): The input message text from the user.
+
+        Returns:
+            dict: The extracted function call and arguments.
+        """
+        system_message = f'[SYSTEM]You are a helpful assistant. You have access to the following functions: \n {str(self.tools)}\n\nTo use these functions respond with:\n<functioncall> {{ "name": "function_name", "arguments": {{ "arg_1": "value_1", "arg_2": "value_2", ... }} }}  </functioncall>  [USER] {message_text}'
+        
+        response = self.deepinfra.chat(system_message)
+        # logging.info(f"Raw response: {response}")
+
+        try:
+            # Extract the JSON-like part of the response
+            start_idx = response.find("{")
+            end_idx = response.rfind("}") + 1
+            if start_idx == -1 or end_idx == -1:
+                raise ValueError("JSON-like structure not found in the response")
+
+            response_json_str = response[start_idx:end_idx]
+            # Ensure the JSON string is properly formatted
+            response_json_str = response_json_str.replace("'", '"')  # Replace single quotes with double quotes
+            response_json_str = response_json_str.strip()
+            response_data = json.loads(response_json_str)
+        except (ValueError, json.JSONDecodeError) as e:
+            # logging.error(f"An error occurred while parsing response: {e}")
+            return {"error": str(e)}
+
+        return response_data
+
+    def execute_function(self, function_call_data: dict) -> str:
+        """Executes the specified function with the provided arguments.
+
+        Args:
+            function_call_data (dict): A dictionary containing the function name and arguments.
+
+        Returns:
+            str: The result of the function execution.
+        """
+        function_name = function_call_data.get("name")
+        arguments = function_call_data.get("arguments", "{}")  # Default to empty dict if not present
+
+        # Parse the arguments string into a dictionary
+        try:
+            arguments_dict = json.loads(arguments)
+        except json.JSONDecodeError:
+            # logging.error("Failed to parse arguments as JSON.")
+            return "Invalid arguments format."
+
+        # logging.info(f"Executing function: {function_name} with arguments: {arguments_dict}")
+
+        # if function_name == "web_search":
+        #     query = arguments_dict.get("query")
+        #     if query:
+        #         search_results = self.webs.text(query)
+        #         # You can process the search results here, e.g., extract URLs, summarize, etc.
+        #         return f"Here's what I found:\n\n{search_results}"
+        #     else:
+        #         return "Please provide a search query."
+        # else:
+        #     return f"Function '{function_name}' is not yet implemented."
+
+# Example usage
+if __name__ == "__main__":
+    tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "UserDetail",
+                "parameters": {
+                    "type": "object",
+                    "title": "UserDetail",
+                    "properties": {
+                        "name": {
+                            "title": "Name",
+                            "type": "string"
+                        },
+                        "age": {
+                            "title": "Age",
+                            "type": "integer"
+                        }
+                    },
+                    "required": ["name", "age"]
+                }
+            }
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "web_search",
+                "description": "Search query on google",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "query": {
+                            "type": "string",
+                            "description": "web search query"
+                        }
+                    },
+                    "required": ["query"]
+                }
+            }
+        }
+    ]
+
+    agent = FunctionCallingAgent(tools=tools)
+    message = "tell me about HelpingAI flash"
+    function_call_data = agent.function_call_handler(message)
+    print(f"Function Call Data: {function_call_data}")
+
+    if "error" not in function_call_data:
+        result = agent.execute_function(function_call_data)
+        # print(f"Function Execution Result: {result}")

webscout/Provider/Andi.py

@@ -0,0 +1,275 @@
+import time
+import uuid
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+import click
+import requests
+from requests import get
+from uuid import uuid4
+from re import findall
+from requests.exceptions import RequestException
+from curl_cffi.requests import get, RequestsError
+import g4f
+from random import randint
+from PIL import Image
+import io
+import re
+import json
+import yaml
+from webscout.AIutel import Optimizers
+from webscout.AIutel import Conversation
+from webscout.AIutel import AwesomePrompts, sanitize_stream
+from webscout.AIbase import  Provider, AsyncProvider
+from webscout import exceptions
+from typing import Any, AsyncGenerator, Dict
+import logging
+import httpx
+from webscout import WEBS
+from rich import print
+
+class AndiSearch(Provider):
+    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,
+    ):
+        """Instantiates AndiSearch
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True.
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.session = requests.Session()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.chat_endpoint = "https://write.andisearch.com/v1/write_streaming"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.headers = {
+            "accept": "text/event-stream",
+            "accept-encoding": "gzip, deflate, br, zstd",
+            "accept-language": "en-US,en;q=0.9,en-IN;q=0.8",
+            "andi-auth-key": "andi-summarizer",
+            "andi-origin": "x-andi-origin",
+            "authorization": str(uuid4()),
+            "content-type": "application/json",
+            "dnt": "1",
+            "origin": "https://andisearch.com",
+            "priority": "u=1, i",
+            "sec-ch-ua": '"Not)A;Brand";v="99", "Microsoft Edge";v="127", "Chromium";v="127"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-site",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36 Edg/127.0.0.0",
+            "x-amz-date": "20240730T031106Z",
+            "x-amz-security-token": str(uuid4()),
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(self.headers)
+        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
+        self.session.proxies = proxies
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict : {}
+        ```json
+        {
+            "id": "chatcmpl-TaREJpBZsRVQFRFic1wIA7Q7XfnaD",
+            "object": "chat.completion",
+            "created": 1704623244,
+            "model": "gpt-3.5-turbo",
+            "usage": {
+                "prompt_tokens": 0,
+                "completion_tokens": 0,
+                "total_tokens": 0
+                },
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "Hello! How can I assist you today?"
+                },
+                "finish_reason": "stop",
+                "index": 0
+                }
+            ]
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        # Initialize the webscout instance
+        webs = WEBS()
+
+        # Fetch search results
+        search_query = prompt
+        search_results = webs.text(search_query, max_results=7)
+
+        # Format the search results into the required serp payload structure
+        serp_payload = {
+            "query": search_query,
+            "serp": {
+                "results_type": "Search",
+                "answer": "",
+                "type": "navigation",
+                "title": "",
+                "description": "",
+                "image": "",
+                "link": "",
+                "source": "liftndrift.com",
+                "engine": "andi-b",
+                "results": [
+                    {
+                        "title": result["title"],
+                        "link": result["href"],
+                        "desc": result["body"],
+                        "image": "",  
+                        "type": "website",
+                        "source": result["href"].split("//")[1].split("/")[0]  # Extract the domain name
+                    }
+                    for result in search_results
+                ]
+            }
+        }
+        self.session.headers.update(self.headers)
+        payload = serp_payload
+
+        def for_stream():
+            response = self.session.post(
+                self.chat_endpoint, json=payload, stream=True, timeout=self.timeout
+            )
+            if not response.ok:
+                raise exceptions.FailedToGenerateResponseError(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
+
+            streaming_text = ""
+            for value in response.iter_lines(
+                decode_unicode=True,
+                chunk_size=self.stream_chunk_size,
+                delimiter="\n",
+            ):
+                try:
+                    if bool(value):
+                        streaming_text += value + ("\n" if stream else "")
+                        resp = dict(text=streaming_text)
+                        self.last_response.update(resp)
+                        yield value if raw else resp
+                except json.decoder.JSONDecodeError:
+                    pass
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+
+        def for_non_stream():
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]

webscout/Provider/__init__.py

@@ -38,6 +38,7 @@ from .Geminipro import GEMINIPRO
 from .Geminiflash import GEMINIFLASH
 from .OLLAMA import OLLAMA
 from .FreeGemini import FreeGemini
+from .Andi import AndiSearch
 __all__ = [
     'ThinkAnyAI',
     'Xjai',
@@ -78,7 +79,8 @@ __all__ = [
     'GEMINIPRO',
     'GEMINIFLASH',
     'OLLAMA',
-    'FreeGemini'
+    'FreeGemini',
+    'AndiSearch'
 
 
 ]

webscout/__init__.py

@@ -7,14 +7,14 @@ from .voice import play_audio
 from .websx_search import WEBSX
 from .LLM import VLM, LLM
 from .YTdownloader import *
-from .GoogleS import *
+
 import g4f
 from .YTdownloader import *
 from .Provider import *
 from .Extra import gguf
 from .Extra import autollama
 from .Extra import weather_ascii, weather
-
+from .Agents import *
 __repo__ = "https://github.com/OE-LUCIFER/Webscout"
 
 webai = [
@@ -44,7 +44,8 @@ webai = [
    "vtlchat",
    "geminiflash",
    "geminipro",
-   "ollama"
+   "ollama",
+   "andi",
 ]
 
 gpt4free_providers = [

webscout/voice.py

@@ -24,4 +24,11 @@ def play_audio(message: str, voice: str = "Brian") -> typing.Union[str, typing.N
         result = requests.get(url=url, headers=headers)
         return result.content
     except:
-        return None
+        return None
+
+if __name__ == "__main__":
+    # Example usage of the play_audio function
+    message = "Hello, world!"
+    voice = "Brian"
+    audio_result = play_audio(message, voice)
+    print(audio_result)

webscout/webai.py

@@ -765,7 +765,20 @@ class Main(cmd.Cmd):
                     model=getOr(model, "Phind Model"),
                     quiet=quiet,
                 )
+            elif provider == "andi":
+                from webscout import AndiSearch
 
+                self.bot = AndiSearch(
+                    is_conversation=disable_conversation,
+                    max_tokens=max_tokens,
+                    timeout=timeout,
+                    intro=intro,
+                    filepath=filepath,
+                    update_file=update_file,
+                    proxies=proxies,
+                    history_offset=history_offset,
+                    act=awesome_prompt,
+                )
             elif provider == "blackboxai":
 
                 from webscout import BLACKBOXAI

webscout/webscout_search.py

@@ -142,6 +142,7 @@ class WEBS:
             "gpt-3.5": "gpt-3.5-turbo-0125",
             "llama-3-70b": "meta-llama/Llama-3-70b-chat-hf",
             "mixtral-8x7b": "mistralai/Mixtral-8x7B-Instruct-v0.1",
+            "gpt-4o-mini": "gpt-4o-mini",
         }
         # vqd
         if not self._chat_vqd:

webscout/websx_search.py

@@ -1,370 +1,19 @@
-from __future__ import annotations
-
-import os
-from typing import Any, Dict, Optional
-import json
-from typing import Any, Dict, List, Optional
-
-import aiohttp
 import requests
-from importlib import metadata
-
-try:
-    from pydantic.v1 import *  
-except ImportError:
-    from pydantic import *  
-
-
-try:
-    _PYDANTIC_MAJOR_VERSION: int = int(metadata.version("pydantic").split(".")[0])
-except metadata.PackageNotFoundError:
-    _PYDANTIC_MAJOR_VERSION = 0
-
-
-
-
-def env_var_is_set(env_var: str) -> bool:
-    """Check if an environment variable is set.
-
-    Args:
-        env_var (str): The name of the environment variable.
-
-    Returns:
-        bool: True if the environment variable is set, False otherwise.
-    """
-    return env_var in os.environ and os.environ[env_var] not in (
-        "",
-        "0",
-        "false",
-        "False",
-    )
-
-
-def get_from_dict_or_env(
-    data: Dict[str, Any], key: str, env_key: str, default: Optional[str] = None
-) -> str:
-    """Get a value from a dictionary or an environment variable."""
-    if key in data and data[key]:
-        return data[key]
-    else:
-        return get_from_env(key, env_key, default=default)
-
-
-def get_from_env(key: str, env_key: str, default: Optional[str] = None) -> str:
-    """Get a value from a dictionary or an environment variable."""
-    if env_key in os.environ and os.environ[env_key]:
-        return os.environ[env_key]
-    elif default is not None:
-        return default
-    else:
-        raise ValueError(
-            f"Did not find {key}, please add an environment variable"
-            f" `{env_key}` which contains it, or pass"
-            f" `{key}` as a named parameter."
-        )
-
-
-def _get_default_params() -> dict:
-    return {"language": "en", "format": "json"}
-
-
-class WEBSXResults(dict):
-    """Dict like wrapper around search api results."""
-
-    _data: str = ""
-
-    def __init__(self, data: str):
-        """Take a raw result from WEBSX and make it into a dict like object."""
-        json_data = json.loads(data)
-        super().__init__(json_data)
-        self.__dict__ = self
-
-    def __str__(self) -> str:
-        """Text representation of WEBSX result."""
-        return self._data
-
-    @property
-    def results(self) -> Any:
-        """Silence mypy for accessing this field.
-
-        :meta private:
-        """
-        return self.get("results")
-
-    @property
-    def answers(self) -> Any:
-        """Helper accessor on the json result."""
-        return self.get("answers")
-
-
-class WEBSX(BaseModel):
-
-    _result: WEBSXResults = PrivateAttr()
-    WEBSX_host: str = "https://8080-01j06maryf9vpw2mm2afqkypps.cloudspaces.litng.ai/"
-    unsecure: bool = False
-    params: dict = Field(default_factory=_get_default_params)
-    headers: Optional[dict] = None
-    engines: Optional[List[str]] = []
-    categories: Optional[List[str]] = []
-    query_suffix: Optional[str] = ""
-    k: int = 10
-    aiosession: Optional[Any] = None
-
-    @validator("unsecure")
-    def disable_ssl_warnings(cls, v: bool) -> bool:
-        """Disable SSL warnings."""
-        if v:
-            # requests.urllib3.disable_warnings()
-            try:
-                import urllib3
-
-                urllib3.disable_warnings()
-            except ImportError as e:
-                print(e)  # noqa: T201
-
-        return v
-
-    @root_validator()
-    def validate_params(cls, values: Dict) -> Dict:
-        """Validate that custom WEBSX params are merged with default ones."""
-        user_params = values["params"]
-        default = _get_default_params()
-        values["params"] = {**default, **user_params}
-
-        engines = values.get("engines")
-        if engines:
-            values["params"]["engines"] = ",".join(engines)
-
-        categories = values.get("categories")
-        if categories:
-            values["params"]["categories"] = ",".join(categories)
-
-        WEBSX_host = get_from_dict_or_env(values, "WEBSX_host", "WEBSX_HOST")
-        if not WEBSX_host.startswith("http"):
-            print(  # noqa: T201
-                f"Warning: missing the url scheme on host \
-                ! assuming secure https://{WEBSX_host} "
-            )
-            WEBSX_host = "https://" + WEBSX_host
-        elif WEBSX_host.startswith("http://"):
-            values["unsecure"] = True
-            cls.disable_ssl_warnings(True)
-        values["WEBSX_host"] = WEBSX_host
-
-        return values
-
-    class Config:
-        """Configuration for this pydantic object."""
-
-        extra = Extra.forbid
-
-    def _WEBSX_api_query(self, params: dict) -> WEBSXResults:
-        """Actual request to WEBSX API."""
-        raw_result = requests.get(
-            self.WEBSX_host,
-            headers=self.headers,
-            params=params,
-            verify=not self.unsecure,
-        )
-        # test if http result is ok
-        if not raw_result.ok:
-            raise ValueError("WEBSX API returned an error: ", raw_result.text)
-        res = WEBSXResults(raw_result.text)
-        self._result = res
-        return res
-
-    async def _aWEBSX_api_query(self, params: dict) -> WEBSXResults:
-        if not self.aiosession:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(
-                    self.WEBSX_host,
-                    headers=self.headers,
-                    params=params,
-                    ssl=(lambda: False if self.unsecure else None)(),
-                ) as response:
-                    if not response.ok:
-                        raise ValueError("WEBSX API returned an error: ", response.text)
-                    result = WEBSXResults(await response.text())
-                    self._result = result
-        else:
-            async with self.aiosession.get(
-                self.WEBSX_host,
-                headers=self.headers,
-                params=params,
-                verify=not self.unsecure,
-            ) as response:
-                if not response.ok:
-                    raise ValueError("WEBSX API returned an error: ", response.text)
-                result = WEBSXResults(await response.text())
-                self._result = result
-
-        return result
-
-    def run(
-        self,
-        query: str,
-        engines: Optional[List[str]] = None,
-        categories: Optional[List[str]] = None,
-        query_suffix: Optional[str] = "",
-        **kwargs: Any,
-    ) -> str:
-        _params = {
-            "q": query,
-        }
-        params = {**self.params, **_params, **kwargs}
-
-        if self.query_suffix and len(self.query_suffix) > 0:
-            params["q"] += " " + self.query_suffix
-
-        if isinstance(query_suffix, str) and len(query_suffix) > 0:
-            params["q"] += " " + query_suffix
-
-        if isinstance(engines, list) and len(engines) > 0:
-            params["engines"] = ",".join(engines)
-
-        if isinstance(categories, list) and len(categories) > 0:
-            params["categories"] = ",".join(categories)
-
-        res = self._WEBSX_api_query(params)
-
-        if len(res.answers) > 0:
-            toret = res.answers[0]
-
-        # only return the content of the results list
-        elif len(res.results) > 0:
-            toret = "\n\n".join([r.get("content", "") for r in res.results[: self.k]])
-        else:
-            toret = "No good search result found"
-
-        return toret
-
-    async def arun(
-        self,
-        query: str,
-        engines: Optional[List[str]] = None,
-        query_suffix: Optional[str] = "",
-        **kwargs: Any,
-    ) -> str:
-        """Asynchronously version of `run`."""
-        _params = {
-            "q": query,
-        }
-        params = {**self.params, **_params, **kwargs}
-
-        if self.query_suffix and len(self.query_suffix) > 0:
-            params["q"] += " " + self.query_suffix
-
-        if isinstance(query_suffix, str) and len(query_suffix) > 0:
-            params["q"] += " " + query_suffix
-
-        if isinstance(engines, list) and len(engines) > 0:
-            params["engines"] = ",".join(engines)
-
-        res = await self._aWEBSX_api_query(params)
-
-        if len(res.answers) > 0:
-            toret = res.answers[0]
-
-        # only return the content of the results list
-        elif len(res.results) > 0:
-            toret = "\n\n".join([r.get("content", "") for r in res.results[: self.k]])
-        else:
-            toret = "No good search result found"
-
-        return toret
-
-    def results(
-        self,
-        query: str,
-        num_results: int,
-        engines: Optional[List[str]] = None,
-        categories: Optional[List[str]] = None,
-        query_suffix: Optional[str] = "",
-        **kwargs: Any,
-    ) -> List[Dict]:
-        """Run query through WEBSX API and returns the results with metadata.
-
-        Args:
-            query: The query to search for.
-            query_suffix: Extra suffix appended to the query.
-            num_results: Limit the number of results to return.
-            engines: List of engines to use for the query.
-            categories: List of categories to use for the query.
-            **kwargs: extra parameters to pass to the WEBSX API.
-
-        Returns:
-            Dict with the following keys:
-            {
-                snippet:  The description of the result.
-                title:  The title of the result.
-                link: The link to the result.
-                engines: The engines used for the result.
-                category: WEBSX category of the result.
-            }
-
-        """
-        _params = {
-            "q": query,
-        }
-        params = {**self.params, **_params, **kwargs}
-        if self.query_suffix and len(self.query_suffix) > 0:
-            params["q"] += " " + self.query_suffix
-        if isinstance(query_suffix, str) and len(query_suffix) > 0:
-            params["q"] += " " + query_suffix
-        if isinstance(engines, list) and len(engines) > 0:
-            params["engines"] = ",".join(engines)
-        if isinstance(categories, list) and len(categories) > 0:
-            params["categories"] = ",".join(categories)
-        results = self._WEBSX_api_query(params).results[:num_results]
-        if len(results) == 0:
-            return [{"Result": "No good Search Result was found"}]
-
-        return [
-            {
-                "snippet": result.get("content", ""),
-                "title": result["title"],
-                "link": result["url"],
-                "engines": result["engines"],
-                "category": result["category"],
-            }
-            for result in results
-        ]
-
-    async def aresults(
-        self,
-        query: str,
-        num_results: int,
-        engines: Optional[List[str]] = None,
-        query_suffix: Optional[str] = "",
-        **kwargs: Any,
-    ) -> List[Dict]:
-        """Asynchronously query with json results.
-
-        Uses aiohttp. See `results` for more info.
-        """
-        _params = {
-            "q": query,
-        }
-        params = {**self.params, **_params, **kwargs}
-
-        if self.query_suffix and len(self.query_suffix) > 0:
-            params["q"] += " " + self.query_suffix
-        if isinstance(query_suffix, str) and len(query_suffix) > 0:
-            params["q"] += " " + query_suffix
-        if isinstance(engines, list) and len(engines) > 0:
-            params["engines"] = ",".join(engines)
-        results = (await self._aWEBSX_api_query(params)).results[:num_results]
-        if len(results) == 0:
-            return [{"Result": "No good Search Result was found"}]
-
-        return [
-            {
-                "snippet": result.get("content", ""),
-                "title": result["title"],
-                "link": result["url"],
-                "engines": result["engines"],
-                "category": result["category"],
-            }
-            for result in results
-        ]
-
+from rich import print
+
+def WEBSX(query):
+    url = 'https://searx.bnngpt.com/api/v1/scrape/'
+    data = {'query': query}
+    response = requests.post(url, data=data)
+    responses = response.json().get('responses')
+    return responses
+
+if __name__ == "__main__":
+    # Example search query
+    search_query = "Python development tools"
+    
+    # Call the WEBSX function with the search query
+    result = WEBSX(search_query)
+    
+    # Pretty-print the JSON response
+    print(result)

{webscout-4.4.dist-info → webscout-4.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: webscout
-Version: 4.4
+Version: 4.5
 Summary: Search for anything using Google, DuckDuckGo, brave, qwant,  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
@@ -742,30 +742,11 @@ with WEBS() as WEBS:
 ## usage of WEBSX -- Another Websearch thing
 ```python
 from webscout import WEBSX
+s = "Python development tools"
 
-def main():
-    # Initialize the WEBSX client
-    search = WEBSX(
-        k=10,  
-    )
+result = WEBSX(s)
 
-    # Example using `run` method - Get a summary
-    query = "What is the capital of France?"
-    answer = search.run(query)
-    print(f"Answer: {answer}\n")
-
-    # Example using `results` method - Get detailed results with metadata
-    query = "What is the capital of France?"
-    results = search.results(query, num_results=3)
-    print("Search Results:")
-    for result in results:
-        print(f"Title: {result['title']}")
-        print(f"Snippet: {result['snippet']}")
-        print(f"Link: {result['link']}\n")
-        print(f'Engines: {result["engines"]}')
-
-if __name__ == "__main__":
-    main()
+print(result)
 ```
 ## ALL acts
 <details>
@@ -1028,7 +1009,7 @@ ___
 ### 0. `Duckchat` - chat with LLM
 ```python
 from webscout import WEBS as w
-R = w().chat("hello", model='claude-3-haiku') # GPT-3.5 Turbo, mixtral-8x7b, llama-3-70b, claude-3-haiku
+R = w().chat("Who are you", model='gpt-4o-mini') # GPT-3.5 Turbo, mixtral-8x7b, llama-3-70b, claude-3-haiku, gpt-4o-mini
 print(R)
 ```
 ### 1. `PhindSearch` - Search using Phind.com 
@@ -1505,7 +1486,12 @@ llama = LLAMA()
 r = llama.chat("What is the meaning of life?")
 print(r)
 ```
-
+### 25. AndiSearch
+```python
+from webscout import AndiSearch
+a = AndiSearch()
+print(a.chat("HelpingAI-9B"))
+```
 ### `LLM` 
 ```python
 from webscout.LLM import LLM

{webscout-4.4.dist-info → webscout-4.5.dist-info}/RECORD

@@ -1,11 +1,11 @@
 webscout/AIauto.py,sha256=gC01wLPpnqONf9DwKqkmbC_gIWo5Lh5V8YPu4OmYnhE,19923
 webscout/AIbase.py,sha256=GoHbN8r0gq2saYRZv6LA-Fr9Jlcjv80STKFXUq2ZeGU,4710
-webscout/AIutel.py,sha256=1NQAchS2e6c1SrIq0efsVtX3ANZ5XI1hjKVHGpJG7OU,34076
+webscout/AIutel.py,sha256=joj1W7SFEM0jpj-qA__vnIJXrLUPtfu0YdLxTF8AHbc,34089
 webscout/DWEBS.py,sha256=QLuT1IKu0lnwdl7W6c-ctBAO7Jj0Zk3PYm6-13BC7rU,25740
 webscout/GoogleS.py,sha256=dW_iArNTyFT5MWBEI1HQvqf-Noj3uJeJA_Eods8D4ms,11587
 webscout/LLM.py,sha256=LbGCZdJf8A5dwfoGS4tyy39tAh5BDdhMZP0ScKaaQfU,4184
 webscout/YTdownloader.py,sha256=uWpUWnw9pxeEGw9KJ_3XDyQ5gd38gH1dJpr-HJo4vzU,39144
-webscout/__init__.py,sha256=teSwl1Gx50AfNu7OibwZrltsErbRDcUuD7W5oAjIc7M,2257
+webscout/__init__.py,sha256=Enum5IvS-CEcQ-zs3HWGEHAs3PUk5JzV9I3r771UHVk,2269
 webscout/__main__.py,sha256=ZtTRgsRjUi2JOvYFLF1ZCh55Sdoz94I-BS-TlJC7WDU,126
 webscout/async_providers.py,sha256=MRj0klEhBYVQXnzZGG_15d0e-TPA0nOc2nn735H-wR4,622
 webscout/cli.py,sha256=RlBKeS9CSIsiBMqlzxevWtKjbY9htkZvA7J0bM_hHE8,14999
@@ -16,11 +16,14 @@ webscout/tempid.py,sha256=5oc3UbXhPGKxrMRTfRABT-V-dNzH_hOKWtLYM6iCWd4,5896
 webscout/transcriber.py,sha256=EddvTSq7dPJ42V3pQVnGuEiYQ7WjJ9uyeR9kMSxN7uY,20622
 webscout/utils.py,sha256=2O8_lftBKsv5OEvVaXCN-h0sipup0m3jxzhFdWQrdY8,2873
 webscout/version.py,sha256=Pp5thQN3CvwDpubKz9MHn-UvDhuocamnBfB2VckwBGI,44
-webscout/voice.py,sha256=0QjXTHAQmCK07IDZXRc7JXem47cnPJH7u3X0sVP1-UQ,967
-webscout/webai.py,sha256=32mRZqAGCOSCeyfAMzqac-94r2RD5_SWUxfh4QjZ95M,89037
-webscout/webscout_search.py,sha256=lYrsPVB4QdSGJl4zehvSmGxK61xBAZ2dZGCmuN3ar2w,43686
+webscout/voice.py,sha256=AHyeb3D8rYuAa-zBJsuMDgHq_Zvi98ROMKAUnEsKldo,1169
+webscout/webai.py,sha256=zUSjlckZSTSUpLSoLqZx0qXD7mrlwdaXjxhnFE7ZmXc,89575
+webscout/webscout_search.py,sha256=evbJPy8vG2YgBuUwyHaOkinIdVlgM-esvjVOvy6N8jY,43729
 webscout/webscout_search_async.py,sha256=dooKGwLm0cwTml55Vy6NHPPY-nymEqX2h8laX94Zg5A,14537
-webscout/websx_search.py,sha256=n-qVwiHozJEF-GFRPcAfh4k1d_tscTmDe1dNL-1ngcU,12094
+webscout/websx_search.py,sha256=5hfkkmGFhyQzojUpvMzIOJ3DBZIBNS90UReaacsfu6s,521
+webscout/Agents/Onlinesearcher.py,sha256=GzF2JcMfj07d74mxQEoaxwtxahgLHl3b_ugTbXjOwq4,7113
+webscout/Agents/__init__.py,sha256=VbGyW5pulh3LRqbVTv54n5TwWsrTqOANRioG18xtdJ0,58
+webscout/Agents/functioncall.py,sha256=5Nfmh8gmFOs7ZV7jJgZElZlJhi7hHrhxbITgLT7UpeI,5242
 webscout/Extra/__init__.py,sha256=GG1qUwS-HspT4TeeAIT4qFpM8PaO1ZdQhpelctaM7Rs,99
 webscout/Extra/autollama.py,sha256=8lyodIWAgJABzlMMHytlolPCgvUKh8ynkZD6MMEltXs,5970
 webscout/Extra/gguf.py,sha256=3QzQIClcVoHyAeb60xxv4msJudC2Maf41StdbzAq1bk,7009
@@ -34,6 +37,7 @@ webscout/Local/rawdog.py,sha256=ojY_O8Vb1KvR34OwWdfLgllgaAK_7HMf64ElMATvCXs,3668
 webscout/Local/samplers.py,sha256=qXwU4eLXER-2aCYzcJcTgA6BeFmi5GMpTDUX1C9pTN4,4372
 webscout/Local/thread.py,sha256=Lyf_N2CaGAn2usSWSiUXLPAgpWub8vUu_tgFgtnvZVA,27408
 webscout/Local/utils.py,sha256=CSt9IqHhVGk_nJEnKvSFbLhC5nNf01e0MtwpgMmF9pA,6197
+webscout/Provider/Andi.py,sha256=y7Y9sC83NeMvK3MheROFoMttrFs9nGwjYaLNLPZMGCQ,10485
 webscout/Provider/BasedGPT.py,sha256=LhC9WdRXhmzPEUaCYTNQF9CRFqhH4BeV1KtVf-B_Hc8,8416
 webscout/Provider/Berlin4h.py,sha256=zMpmWmdFCbcE3UWB-F9xbbTWZTfx4GnjnRf6sDoaiC0,8552
 webscout/Provider/Blackboxai.py,sha256=HUk0moEGsgGvidD1LF9tbfaKdx7bPnGU_SrYPdcfHU8,17182
@@ -61,10 +65,10 @@ webscout/Provider/VTLchat.py,sha256=_sErGr-wOi16ZAfiGOo0bPsAEMkjzzwreEsIqjIZMIU,
 webscout/Provider/Xjai.py,sha256=BIlk2ouz9Kh_0Gg9hPvTqhI7XtcmWdg5vHSX_4uGrIs,9039
 webscout/Provider/Yepchat.py,sha256=2Eit-A7w1ph1GQKNQuur_yaDzI64r0yBGxCIjDefJxQ,19875
 webscout/Provider/Youchat.py,sha256=fhMpt94pIPE_XDbC4z9xyfgA7NbkNE2wlRFJabsjv90,8069
-webscout/Provider/__init__.py,sha256=j6lZqjLYext2a-KTnvGEvVm-D3jezHIlnanlj2H37FI,1962
-webscout-4.4.dist-info/LICENSE.md,sha256=9P0imsudI7MEvZe2pOcg8rKBn6E5FGHQ-riYozZI-Bk,2942
-webscout-4.4.dist-info/METADATA,sha256=bgSEbiMKbSplv_CNKFCFWvY9Mp44VyxuuWpBJSxIKgQ,57749
-webscout-4.4.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
-webscout-4.4.dist-info/entry_points.txt,sha256=Hh4YIIjvkqB9SVxZ2ri4DZUkgEu_WF_5_r_nZDIvfG8,73
-webscout-4.4.dist-info/top_level.txt,sha256=nYIw7OKBQDr_Z33IzZUKidRD3zQEo8jOJYkMVMeN334,9
-webscout-4.4.dist-info/RECORD,,
+webscout/Provider/__init__.py,sha256=bi6ja0K5KWO6B4UT78CYR3LvjKTZpIpGlshC4-BqW90,2011
+webscout-4.5.dist-info/LICENSE.md,sha256=9P0imsudI7MEvZe2pOcg8rKBn6E5FGHQ-riYozZI-Bk,2942
+webscout-4.5.dist-info/METADATA,sha256=KB7C4B6I_Ml0H2DLfvp1PSed-P-UsCsC1TwLEYKn8MU,57233
+webscout-4.5.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
+webscout-4.5.dist-info/entry_points.txt,sha256=Hh4YIIjvkqB9SVxZ2ri4DZUkgEu_WF_5_r_nZDIvfG8,73
+webscout-4.5.dist-info/top_level.txt,sha256=nYIw7OKBQDr_Z33IzZUKidRD3zQEo8jOJYkMVMeN334,9
+webscout-4.5.dist-info/RECORD,,