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

webscout/AIauto.py

@@ -1,8 +1,7 @@
 from webscout.AIbase import Provider, AsyncProvider
 from webscout.Provider.ThinkAnyAI import ThinkAnyAI
 from webscout.Provider.Xjai import Xjai
-from webscout.Provider.Llama import LLAMA2
-from webscout.Provider.Llama import AsyncLLAMA2
+from webscout.Provider.Llama import LLAMA
 from webscout.Provider.Leo import LEO
 from webscout.Provider.Leo import AsyncLEO
 from webscout.Provider.Koboldai import KOBOLDAI
@@ -44,7 +43,7 @@ provider_map: dict[
     Union[
         ThinkAnyAI,
         Xjai,
-        LLAMA2,
+        LLAMA,
         LEO,
         KOBOLDAI,
         OPENGPT,
@@ -69,7 +68,7 @@ provider_map: dict[
 ] = {
     "ThinkAnyAI": ThinkAnyAI,
     "Xjai": Xjai,
-    "LLAMA2": LLAMA2,
+    "LLAMA2": LLAMA,
     "LEO": LEO,
     "KOBOLDAI": KOBOLDAI,
     "OPENGPT": OPENGPT,
@@ -124,7 +123,7 @@ class AUTO(Provider):
         self.provider: Union[
             ThinkAnyAI,
             Xjai,
-            LLAMA2,
+            LLAMA,
             LEO,
             KOBOLDAI,
             OPENGPT,
@@ -353,13 +352,12 @@ class AsyncAUTO(AsyncProvider):
             AsyncOPENGPT,
             AsyncKOBOLDAI,
             AsyncPhindSearch,
-            AsyncLLAMA2,
             AsyncBLACKBOXAI,
             AsyncGPT4FREE,
             AsyncLEO,
             ThinkAnyAI,
             Xjai,
-            LLAMA2,
+            LLAMA,
             LEO,
             KOBOLDAI,
             OPENGPT,

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

@@ -1,6 +1,14 @@
 import subprocess
 import argparse
 import os
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import track
+from yaspin import yaspin
+from pyfiglet import figlet_format
+import time
+
+console = Console()
 
 def autollama(model_path, gguf_file):
     """Manages models with Ollama using the autollama.sh script.
@@ -9,6 +17,7 @@ def autollama(model_path, gguf_file):
         model_path (str): The path to the Hugging Face model.
         gguf_file (str): The name of the GGUF file. 
     """
+    console.print(f"[bold green]{figlet_format('Autollama')}[/]\n", justify="center")
 
     # Check if autollama.sh exists in the current working directory
     script_path = os.path.join(os.getcwd(), "autollama.sh")
@@ -172,25 +181,27 @@ echo "Use Ollama run $MODEL_NAME"
     # Execute the command
     process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
 
-    # Print the output and error in real-time
-    for line in process.stdout:
-        print(line, end='')
-
-    for line in process.stderr:
-        print(line, end='')
+    for line in iter(process.stdout.readline, ''): 
+        console.print(Panel(line.strip(), title="Autollama Output", expand=False)) 
 
+    for line in iter(process.stderr.readline, ''): 
+        console.print(Panel(line.strip(), title="Autollama Errors (if any)", expand=False))
+    
     process.wait()
+    console.print("[green]Model is ready![/]")
 
 def main():
     parser = argparse.ArgumentParser(description='Automatically create and run an Ollama model in Ollama')
-    parser.add_argument('-m', '--model_path', required=True, help='Set the hunggingface model id to the Hugging Face model')
+    parser.add_argument('-m', '--model_path', required=True, help='Set the huggingface model id to the Hugging Face model')
     parser.add_argument('-g', '--gguf_file', required=True, help='Set the GGUF file name')
     args = parser.parse_args()
 
     try:
-        autollama(args.model_path, args.gguf_file)
+        with yaspin(text="Processing...") as spinner:
+            autollama(args.model_path, args.gguf_file)
+        spinner.ok("Done!")
     except Exception as e:
-        print(f"Error: {e}")
+        console.print(f"[red]Error: {e}[/]")
         exit(1)
 
 if __name__ == "__main__":

webscout/Extra/gguf.py

@@ -1,7 +1,10 @@
 # webscout/Extra/gguf.py
 import subprocess
-import argparse
 import os 
+from pyfiglet import figlet_format
+from rich.console import Console
+
+console = Console()
 
 def convert(model_id, username=None, token=None, quantization_methods="q4_k_m,q5_k_m"):
     """Converts and quantizes a Hugging Face model to GGUF format.
@@ -17,6 +20,7 @@ def convert(model_id, username=None, token=None, quantization_methods="q4_k_m,q5
         ValueError: If an invalid quantization method is provided.
     """
 
+    console.print(f"[bold green]{figlet_format('GGUF Converter')}[/]\n", justify="center")
     # List of valid quantization methods
     valid_methods = [
         "q2_k", "q3_k_l", "q3_k_m", "q3_k_s", 
@@ -220,21 +224,3 @@ echo "Script completed."
     process.wait()
 
 
-def main():
-    parser = argparse.ArgumentParser(description='Convert and quantize model using gguf.sh')
-    parser.add_argument('-m', '--model_id', required=True, help='Set the HF model ID (e.g., "google/flan-t5-xl")')
-    parser.add_argument('-u', '--username', help='Set your Hugging Face username (required for uploads)')
-    parser.add_argument('-t', '--token', help='Set your Hugging Face API token (required for uploads)')
-    parser.add_argument('-q', '--quantization_methods', default="q4_k_m,q5_k_m", 
-                        help='Comma-separated quantization methods (default: q4_k_m,q5_k_m). Valid methods: q2_k, q3_k_l, q3_k_m, q3_k_s, q4_0, q4_1, q4_k_m, q4_k_s, q5_0, q5_1, q5_k_m, q5_k_s, q6_k, q8_0')
-    
-    args = parser.parse_args()
-    
-    try:
-        convert(args.model_id, args.username, args.token, args.quantization_methods)
-    except ValueError as e:
-        print(e)
-        exit(1)
-
-if __name__ == "__main__":
-    main()

webscout/Extra/weather.py

@@ -1,4 +1,10 @@
 import requests
+from rich.console import Console
+from rich.table import Table
+from yaspin import yaspin
+from pyfiglet import figlet_format
+
+console = Console()
 
 def get(location):
     """Fetches weather data for the given location.
@@ -12,7 +18,9 @@ def get(location):
     """
     url = f"https://wttr.in/{location}?format=j1"
     
-    response = requests.get(url)
+    with yaspin(text="Fetching weather data...") as spinner:
+        response = requests.get(url)
+        spinner.ok("✅ ")
 
     if response.status_code == 200:
         return response.json()
@@ -27,23 +35,33 @@ def print_weather(weather_data):
                                   or an error message.
     """
     if isinstance(weather_data, str):
-        print(weather_data)
+        console.print(f"[bold red]Error:[/] {weather_data}")
         return
 
     current = weather_data['current_condition'][0]
     location_name = weather_data['nearest_area'][0]['areaName'][0]['value']
 
-    print(f"Weather in {location_name}:")
-    print(f"Temperature: {current['temp_C']}°C / {current['temp_F']}°F")
-    print(f"Condition: {current['weatherDesc'][0]['value']}")
-    print(f"Humidity: {current['humidity']}%")
-    print(f"Wind: {current['windspeedKmph']} km/h, {current['winddir16Point']}")
+    console.print(f"[bold blue]\n{figlet_format('Weather Report')}[/]\n", justify="center")
+    console.print(f"[bold green]Weather in {location_name}:[/]\n")
 
+    table = Table(show_header=False, show_lines=True)
+    table.add_row("Temperature:", f"{current['temp_C']}°C / {current['temp_F']}°F")
+    table.add_row("Condition:", current['weatherDesc'][0]['value'])
+    table.add_row("Humidity:", f"{current['humidity']}%")
+    table.add_row("Wind:", f"{current['windspeedKmph']} km/h, {current['winddir16Point']}")
+    console.print(table)
 
-    print("\nForecast:")
+    console.print(f"\n[bold green]Forecast:[/]")
+    table = Table(show_header=True, header_style="bold cyan")
+    table.add_column("Date", style="dim", width=12)
+    table.add_column("Temperature Range")
+    table.add_column("Description")
+    
     for day in weather_data['weather']:
         date = day['date']
         max_temp = day['maxtempC']
         min_temp = day['mintempC']
         desc = day['hourly'][4]['weatherDesc'][0]['value'] 
-        print(f"{date}: {min_temp}°C to {max_temp}°C, {desc}")
+        table.add_row(date, f"{min_temp}°C to {max_temp}°C", desc)
+    console.print(table)
+

webscout/Extra/weather_ascii.py

@@ -1,5 +1,8 @@
 import requests
+from rich.console import Console
+from pyfiglet import figlet_format
 
+console = Console()
 def get(location):
     """Fetches ASCII art weather data for the given location.
     Args:
@@ -9,6 +12,7 @@ def get(location):
         str: ASCII art weather report if the request is successful,
              otherwise an error message.
     """
+    console.print(f"[bold green]{figlet_format('Weather')}[/]\n", justify="center")
     url = f"https://wttr.in/{location}"
     response = requests.get(url, headers={'User-Agent': 'curl'}) 
 
@@ -16,3 +20,4 @@ def get(location):
         return "\n".join(response.text.splitlines()[:-1]) 
     else:
         return f"Error: Unable to fetch weather data. Status code: {response.status_code}"
+