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

webscout/AIutel.py

@@ -52,7 +52,9 @@ webai = [
    "vtlchat",
    "geminiflash",
    "geminipro",
-   "ollama"
+   "ollama",
+   "andi",
+   "llama3"
 ]
 
 gpt4free_providers = [
@@ -532,6 +534,15 @@ LLM:
 ```python
 print("The essay is about...")
 ```
+
+3. User: Weather in qazigund
+
+LLM:
+```python
+from webscout import weather as w
+weather = w.get("Qazigund")
+w.print_weather(weather)
+```
 """
 
 

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/Extra/gguf.py

@@ -153,7 +153,7 @@ huggingface-cli download "$MODEL_ID" --local-dir "./${MODEL_NAME}" --local-dir-u
 # Convert to fp16
 FP16="${MODEL_NAME}/${MODEL_NAME,,}.fp16.bin"
 echo "Converting the model to fp16..."
-python3 llama.cpp/convert-hf-to-gguf.py "$MODEL_NAME" --outtype f16 --outfile "$FP16"
+python3 llama.cpp/convert_hf_to_gguf.py "$MODEL_NAME" --outtype f16 --outfile "$FP16"
 
 # Quantize the model
 echo "Quantizing the model..."

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"]