webscout 4.9__tar.gz → 5.1__tar.gz

{webscout-4.9/webscout.egg-info → webscout-5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: webscout
-Version: 4.9
+Version: 5.1
 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
@@ -66,6 +66,8 @@ Requires-Dist: requests_html
 Requires-Dist: bson
 Requires-Dist: cloudscraper
 Requires-Dist: emoji
+Requires-Dist: colorlog
+Requires-Dist: openai
 Provides-Extra: dev
 Requires-Dist: ruff>=0.1.6; extra == "dev"
 Requires-Dist: pytest>=7.4.2; extra == "dev"
@@ -1645,15 +1647,13 @@ gguf.convert(
 
 Webscout's `autollama` utility download model from huggingface and then automatically makes it ollama ready
 
-**Example:**
-
 ```python
 from webscout import autollama
 
-autollama(
-    model_path="OEvortex/HelpingAI-Lite-1.5T",  # Hugging Face model ID
-    gguf_file="HelpingAI-Lite-1.5T.q4_k_m.gguf" #  GGUF file ID
-)
+model_path = "Vortex4ai/Jarvis-0.5B"
+gguf_file = "test2-q4_k_m.gguf"
+
+autollama.main(model_path, gguf_file)  
 ```
 
 **Command Line Usage:**

{webscout-4.9 → webscout-5.1}/README.md

@@ -1568,15 +1568,13 @@ gguf.convert(
 
 Webscout's `autollama` utility download model from huggingface and then automatically makes it ollama ready
 
-**Example:**
-
 ```python
 from webscout import autollama
 
-autollama(
-    model_path="OEvortex/HelpingAI-Lite-1.5T",  # Hugging Face model ID
-    gguf_file="HelpingAI-Lite-1.5T.q4_k_m.gguf" #  GGUF file ID
-)
+model_path = "Vortex4ai/Jarvis-0.5B"
+gguf_file = "test2-q4_k_m.gguf"
+
+autollama.main(model_path, gguf_file)  
 ```
 
 **Command Line Usage:**

{webscout-4.9 → webscout-5.1}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", encoding="utf-8") as f:
 
 setup(
     name="webscout",
-    version="4.9",
+    version="5.1",
     description="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",
     long_description=README,
     long_description_content_type="text/markdown",
@@ -69,7 +69,9 @@ setup(
         "requests_html",
         "bson",
         "cloudscraper",
-        "emoji"
+        "emoji",
+        "colorlog",
+        "openai",
     ],
     entry_points={
         "console_scripts": [

webscout-5.1/webscout/Agents/functioncall.py

@@ -0,0 +1,142 @@
+import json
+import logging
+from webscout import LLAMA3, WEBS
+
+class FunctionCallingAgent:
+    def __init__(self, model: str = "llama3-8b", 
+                 system_prompt: str = 'You are a helpful assistant that will always answer what the user wants', 
+                 tools: list = None):
+        self.LLAMA3 = LLAMA3(model=model, system=system_prompt, timeout=300)
+        self.tools = tools if tools is not None else []
+        self.webs = WEBS()
+
+    def function_call_handler(self, message_text: str) -> dict:
+        system_message = self._generate_system_message(message_text)
+        response = self.LLAMA3.chat(system_message)
+        # logging.info(f"Raw response: {response}")
+        return self._parse_function_call(response)
+
+    def _generate_system_message(self, user_message: str) -> str:
+        tools_description = '\n'.join([f"- {tool['function']['name']}: {tool['function'].get('description', '')}" for tool in self.tools])
+        return (
+            "You are an AI assistant capable of understanding user requests and using tools to fulfill them. "
+            "Always respond using the JSON format specified below, even if you're not sure about the answer. "
+            f"Available tools:\n{tools_description}\n\n"
+            "Instructions:\n"
+            "1. Analyze the user's request.\n"
+            "2. Choose the most appropriate tool based on the request.\n"
+            "3. Respond ONLY with a JSON object in this exact format:\n"
+            "{\n"
+            '  "tool_name": "name_of_the_tool",\n'
+            '  "tool_input": {\n'
+            '    "param1": "value1",\n'
+            '    "param2": "value2"\n'
+            "  }\n"
+            "}\n\n"
+            "If you can't determine a suitable tool, use the 'general_ai' tool with the user's message as the 'question' parameter.\n\n"
+            f"User request: {user_message}\n\n"
+            "Your response (in JSON format):"
+        )
+
+    def _parse_function_call(self, response: str) -> dict:
+        try:
+            # Find 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("No valid JSON structure found in the response.")
+
+            response_json_str = response[start_idx:end_idx]
+            
+            # Attempt to load the JSON string
+            return json.loads(response_json_str)
+
+        except (ValueError, json.JSONDecodeError) as e:
+            logging.error(f"Error parsing function call: {e}")
+            return {"error": str(e)}
+
+    def execute_function(self, function_call_data: dict) -> str:
+        function_name = function_call_data.get("tool_name")
+        arguments = function_call_data.get("tool_input", {})
+
+        if not isinstance(arguments, dict):
+            logging.error("Invalid arguments format.")
+            return "Invalid arguments format."
+
+        logging.info(f"Executing function: {function_name} with arguments: {arguments}")
+
+    #     if function_name == "web_search":
+    #         return self._handle_web_search(arguments)
+    #     elif function_name == "general_ai":
+    #         return self._handle_general_ai(arguments)
+    #     else:
+    #         return f"Function '{function_name}' is not implemented."
+
+    # def _handle_web_search(self, arguments: dict) -> str:
+    #     query = arguments.get("query")
+    #     if not query:
+    #         return "Please provide a search query."
+
+    #     search_results = self.webs.text(query, max_results=3)
+    #     formatted_results = "\n\n".join(
+    #         f"{i+1}. {result['title']}\n{result['body']}\nURL: {result['href']}"
+    #         for i, result in enumerate(search_results)
+    #     )
+    #     return f"Here's what I found:\n\n{formatted_results}"
+
+    # def _handle_general_ai(self, arguments: dict) -> str:
+    #     question = arguments.get("question")
+    #     if not question:
+    #         return "Please provide a question for the AI to answer."
+
+    #     response = self.LLAMA3.chat(question)
+    #     return response
+
+# Example usage
+if __name__ == "__main__":
+    tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "web_search",
+                "description": "Search query on Google",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "query": {
+                            "type": "string",
+                            "description": "web search query"
+                        }
+                    },
+                    "required": ["query"]
+                }
+            }
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "general_ai",
+                "description": "Use AI to answer a general question",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "question": {
+                            "type": "string",
+                            "description": "The question to be answered by the AI"
+                        }
+                    },
+                    "required": ["question"]
+                }
+            }
+        }
+    ]
+
+    agent = FunctionCallingAgent(tools=tools)
+    message = "open yt"
+    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-5.1/webscout/Extra/autollama.py

@@ -0,0 +1,179 @@
+import warnings
+from datetime import time
+import os
+import sys
+import subprocess
+import logging
+import psutil
+from huggingface_hub import hf_hub_url, cached_download
+import colorlog
+import ollama  # Import ollama for interactive chat
+import argparse  # Import argparse for command-line arguments
+
+# Suppress specific warnings
+warnings.filterwarnings(
+    "ignore", category=FutureWarning, module="huggingface_hub.file_download"
+)
+
+# Configure logging with colors
+handler = colorlog.StreamHandler()
+handler.setFormatter(
+    colorlog.ColoredFormatter(
+        "%(log_color)s%(asctime)s - %(levelname)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+        log_colors={
+            "DEBUG": "cyan",
+            "INFO": "green",
+            "WARNING": "yellow",
+            "ERROR": "red",
+            "CRITICAL": "red,bg_white",
+        },
+    )
+)
+
+logger = colorlog.getLogger(__name__)
+if not logger.hasHandlers():
+    logger.addHandler(handler)
+    logger.setLevel(logging.INFO)
+
+# Redirect warnings to the logger but avoid duplication
+logging.captureWarnings(True)
+py_warnings_logger = logging.getLogger("py.warnings")
+if not py_warnings_logger.hasHandlers():
+    py_warnings_logger.addHandler(handler)
+
+
+def show_art():
+    logger.info("Made with love in India")
+
+
+def usage():
+    logger.info("Usage: python script.py -m <model_path> -g <gguf_file>")
+    logger.info("Options:")
+    logger.info("  -m <model_path>    Set the path to the model")
+    logger.info("  -g <gguf_file>     Set the GGUF file name")
+    logger.info("  -h                 Display this help and exit")
+
+
+def is_model_downloaded(logging_name, download_log):
+    if not os.path.exists(download_log):
+        return False
+    with open(download_log, "r") as f:
+        for line in f:
+            if line.strip() == logging_name:
+                return True
+    return False
+
+
+def log_downloaded_model(logging_name, download_log):
+    with open(download_log, "a") as f:
+        f.write(logging_name + "\n")
+
+
+def is_model_created(model_name):
+    result = subprocess.run(["ollama", "list"], stdout=subprocess.PIPE)
+    return model_name in result.stdout.decode("utf-8")
+
+
+def download_model(repo_id, filename, token, cache_dir="downloads"):
+    url = hf_hub_url(repo_id, filename)
+    filepath = cached_download(
+        url, cache_dir=cache_dir, force_filename=filename, use_auth_token=token
+    )
+    return filepath
+
+
+def is_ollama_running():
+    for proc in psutil.process_iter(["name"]):
+        if proc.info["name"] in ["ollama", "ollama.exe"]:
+            return True
+    return False
+
+
+def main(model_path=None, gguf_file=None):  # Modified to handle both CLI and non-CLI
+    show_art()
+
+    # Parse command-line arguments if provided
+    parser = argparse.ArgumentParser(description="Download and create an Ollama model")
+    parser.add_argument("-m", "--model_path", help="Path to the model on Hugging Face Hub")
+    parser.add_argument("-g", "--gguf_file", help="Name of the GGUF file")
+    args = parser.parse_args()
+
+    # Use arguments from command line or function parameters
+    model_path = args.model_path if args.model_path else model_path
+    gguf_file = args.gguf_file if args.gguf_file else gguf_file
+
+    if not model_path or not gguf_file:
+        logger.error("Error: model_path and gguf_file are required.")
+        usage()
+        sys.exit(2)
+
+    model_name = gguf_file.split(".Q4")[0]
+    download_log = "downloaded_models.log"
+    logging_name = f"{model_path}_{model_name}"
+
+    # Ensure the log file exists
+    if not os.path.exists(download_log):
+        with open(download_log, 'w') as f:
+            pass
+
+    # Check if huggingface-hub is installed, and install it if not
+    try:
+        subprocess.check_output(['pip', 'show', 'huggingface-hub'])
+    except subprocess.CalledProcessError:
+        logger.info("Installing huggingface-hub...")
+        subprocess.check_call(['pip', 'install', '-U', 'huggingface_hub[cli]'])
+    else:
+        logger.info("huggingface-hub is already installed.")
+
+    # Check if the model has already been downloaded
+    if is_model_downloaded(logging_name, download_log):
+        logger.info(f"Model {logging_name} has already been downloaded. Skipping download.")
+    else:
+        logger.info(f"Downloading model {logging_name}...")
+        token = os.getenv('HUGGINGFACE_TOKEN', None)
+        if not token:
+            logger.warning("Warning: HUGGINGFACE_TOKEN environment variable is not set. Using None.")
+            token = None
+
+        filepath = download_model(model_path, gguf_file, token)
+        log_downloaded_model(logging_name, download_log)
+        logger.info(f"Model {logging_name} downloaded and logged.")
+
+    # Check if Ollama is installed, and install it if not
+    try:
+        subprocess.check_output(['ollama', '--version'])
+    except subprocess.CalledProcessError:
+        logger.info("Installing Ollama...")
+        subprocess.check_call(['curl', '-fsSL', 'https://ollama.com/install.sh', '|', 'sh'])
+    else:
+        logger.info("Ollama is already installed.")
+
+    # Check if Ollama is already running
+    if is_ollama_running():
+        logger.info("Ollama is already running. Skipping the start.")
+    else:
+        logger.info("Starting Ollama...")
+        subprocess.Popen(['ollama', 'serve'])
+
+        while not is_ollama_running():
+            logger.info("Waiting for Ollama to start...")
+            time.sleep(1)
+
+        logger.info("Ollama has started.")
+
+    # Check if the model has already been created
+    if is_model_created(model_name):
+        logger.info(f"Model {model_name} is already created. Skipping creation.")
+    else:
+        logger.info(f"Creating model {model_name}...")
+        with open('Modelfile', 'w') as f:
+            f.write(f"FROM ./downloads/{gguf_file}")
+        subprocess.check_call(['ollama', 'create', model_name, '-f', 'Modelfile'])
+        logger.info(f"Model {model_name} created.")
+
+    logger.info(f"model name is > {model_name}")
+    logger.info(f"Use Ollama run {model_name}")
+
+if __name__ == "__main__":
+    main()

{webscout-4.9 → webscout-5.1}/webscout/Provider/DiscordRocks.py

@@ -122,7 +122,7 @@ class DiscordRocks(Provider):
 
     def __init__(
         self,
-        model: str = "gpt-4o", 
+        model: str = "llama-3.1-405b-turbo", 
         max_tokens: int = 4096,
         temperature: float = 1,
         top_p: float = 1,
@@ -176,6 +176,7 @@ class DiscordRocks(Provider):
             "accept-language": "en-US,en;q=0.9,en-IN;q=0.8",
             "content-type": "application/json",
             "dnt": "1",
+            "authorization": "Bearer missing api key",
             "origin": "https://llmplayground.net",
             "priority": "u=1, i",
             "referer": "https://llmplayground.net/",

{webscout-4.9 → webscout-5.1}/webscout/Provider/Llama3.py

@@ -21,7 +21,7 @@ class LLAMA3(Provider):
         history_offset: int = 10250,
         act: str = None,
         model: str = "llama3-8b",  
-        system: str = "Answer as concisely as possible.",
+        system: str = "GPT syle",
     ):
         """Instantiates Snova
 

{webscout-4.9 → webscout-5.1}/webscout/Provider/OLLAMA.py

@@ -36,11 +36,12 @@ class OLLAMA(Provider):
         proxies: dict = {},
         history_offset: int = 10250,
         act: str = None,
+        system_prompt: str = "You are a helpful and friendly AI assistant.", 
     ):
         """Instantiates Ollama
 
         Args:
-            model (str, optional): Model name. Defaults to 'llama2'.
+            model (str, optional): Model name. Defaults to 'qwen2:0.5b'.
             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.
@@ -50,12 +51,14 @@ class OLLAMA(Provider):
             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.
+            system_prompt (str, optional): System prompt for Ollama. Defaults to "You are a helpful and friendly AI assistant.". 
         """
         self.model = model
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
         self.timeout = timeout
         self.last_response = {}
+        self.system_prompt = system_prompt
 
         self.__available_optimizers = (
             method
@@ -110,21 +113,19 @@ class OLLAMA(Provider):
                 )
 
         def for_stream():
+            # Correctly call ollama.chat with stream=True
             stream = ollama.chat(model=self.model, messages=[
+                {'role': 'system', 'content': self.system_prompt}, 
                 {'role': 'user', 'content': conversation_prompt}
             ], stream=True)
 
-            message_load = ""
+            # Yield each chunk directly
             for chunk in stream:
-                message_load += chunk['message']['content']
-                yield chunk['message']['content'] if raw else dict(text=message_load)
-            self.last_response.update(dict(text=message_load))
-            self.conversation.update_chat_history(
-                prompt, self.get_message(self.last_response)
-            )
+                yield chunk['message']['content'] if raw else dict(text=chunk['message']['content'])
 
         def for_non_stream():
             response = ollama.chat(model=self.model, messages=[
+                {'role': 'system', 'content': self.system_prompt}, # Add system message
                 {'role': 'user', 'content': conversation_prompt}
             ])
             self.last_response.update(dict(text=response['message']['content']))
@@ -183,6 +184,6 @@ class OLLAMA(Provider):
         return response["text"]
 if __name__ == "__main__":
     ollama_provider = OLLAMA(model="qwen:0.5b")
-    response = ollama_provider.chat("hi")
+    response = ollama_provider.chat("hi", stream=True)
     for r in response:
-        print(r, end="", flush=True)
+        print(r, end="", flush=True)

{webscout-4.9 → webscout-5.1/webscout.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: webscout
-Version: 4.9
+Version: 5.1
 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
@@ -66,6 +66,8 @@ Requires-Dist: requests_html
 Requires-Dist: bson
 Requires-Dist: cloudscraper
 Requires-Dist: emoji
+Requires-Dist: colorlog
+Requires-Dist: openai
 Provides-Extra: dev
 Requires-Dist: ruff>=0.1.6; extra == "dev"
 Requires-Dist: pytest>=7.4.2; extra == "dev"
@@ -1645,15 +1647,13 @@ gguf.convert(
 
 Webscout's `autollama` utility download model from huggingface and then automatically makes it ollama ready
 
-**Example:**
-
 ```python
 from webscout import autollama
 
-autollama(
-    model_path="OEvortex/HelpingAI-Lite-1.5T",  # Hugging Face model ID
-    gguf_file="HelpingAI-Lite-1.5T.q4_k_m.gguf" #  GGUF file ID
-)
+model_path = "Vortex4ai/Jarvis-0.5B"
+gguf_file = "test2-q4_k_m.gguf"
+
+autollama.main(model_path, gguf_file)  
 ```
 
 **Command Line Usage:**

{webscout-4.9 → webscout-5.1}/webscout.egg-info/requires.txt

@@ -40,6 +40,8 @@ requests_html
 bson
 cloudscraper
 emoji
+colorlog
+openai
 
 [dev]
 ruff>=0.1.6

webscout-4.9/webscout/Agents/functioncall.py

@@ -1,186 +0,0 @@
-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 the user wants', 
-                 tools: list = None):
-        """
-        Initialize the FunctionCallingAgent with the model, system prompt, and tools.
-
-        Args:
-            model (str): The model to use for deepinfra chat.
-            system_prompt (str): The system prompt to initialize the model.
-            tools (list): A list of tools the agent can use.
-        """
-        self.deepinfra = DeepInfra(model=model, system_prompt=system_prompt, timeout=300)
-        self.tools = tools if tools is not None else []
-
-
-    def function_call_handler(self, message_text: str) -> dict:
-        """
-        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 = self._generate_system_message(message_text)
-        response = self.deepinfra.chat(system_message)
-        # logging.info(f"Raw response: {response}")
-
-        return self._parse_function_call(response)
-
-    def _generate_system_message(self, user_message: str) -> str:
-        """
-        Generates a system message incorporating the user message and available tools.
-
-        Args:
-            user_message (str): The input message from the user.
-
-        Returns:
-            str: The formatted system message.
-        """
-        tools_description = '\n'.join([f"{tool['function']['name']}: {tool['function'].get('description', '')}" for tool in self.tools])
-        return (
-            f"[SYSTEM] You are a helpful and capable AI assistant. "
-            "Your goal is to understand the user's request and provide accurate and relevant information. "
-            "You have access to the following tools:\n\n"
-            f"{tools_description}\n\n"
-            "To use a tool, please follow this format:\n\n"
-            "```json\n"
-            "{{ 'tool_name': 'tool_name', 'tool_input': {{ 'arg_1': 'value_1', 'arg_2': 'value_2', ... }} }}\n"
-            "```\n\n"
-            f"[USER] {user_message}"
-        )
-
-    def _parse_function_call(self, response: str) -> dict:
-        """
-        Parses the response from the model to extract the function call.
-
-        Args:
-            response (str): The raw response from the model.
-
-        Returns:
-            dict: A dictionary containing the function name and arguments.
-        """
-        try:
-            # Find 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("No valid JSON structure found in the response.")
-
-            response_json_str = response[start_idx:end_idx]
-
-            # Replace single quotes with double quotes and remove extra braces
-            response_json_str = response_json_str.replace("'", '"')
-            response_json_str = response_json_str.replace("{{", "{").replace("}}", "}")
-            
-            # Remove any leading or trailing whitespace
-            response_json_str = response_json_str.strip()
-
-            # Attempt to load the JSON string
-            return json.loads(response_json_str)
-
-        except (ValueError, json.JSONDecodeError) as e:
-            logging.error(f"Error parsing function call: {e}")
-            return {"error": str(e)}
-
-    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("tool_name")  # Use 'tool_name' instead of 'name'
-        arguments = function_call_data.get("tool_input", {})  # Use 'tool_input' instead of 'arguments'
-
-        if not isinstance(arguments, dict):
-            logging.error("Invalid arguments format.")
-            return "Invalid arguments format."
-
-        logging.info(f"Executing function: {function_name} with arguments: {arguments}")
-
-        if function_name == "web_search":
-            return self._handle_web_search(arguments)
-        else:
-            return f"Function '{function_name}' is not implemented."
-
-    # def _handle_web_search(self, arguments: dict) -> str:
-    #     """
-    #     Handles web search queries using the WEBS tool.
-
-    #     Args:
-    #         arguments (dict): A dictionary containing the query argument.
-
-    #     Returns:
-    #         str: The result of the web search.
-    #     """
-    #     query = arguments.get("query")
-    #     if not query:
-    #         return "Please provide a search query."
-
-    #     search_results = self.webs.text(query)
-    #     # Additional processing of search results can be done here if needed.
-    #     return f"Here's what I found:\n\n{search_results}"
-
-# 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 = "websearch about helpingai-9b"
-    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-4.9/webscout/Extra/autollama.py

@@ -1,209 +0,0 @@
-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.
-
-    Args:
-        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")
-    if not os.path.exists(script_path):
-        # Create autollama.sh with the content provided
-        with open(script_path, "w") as f:
-            f.write("""
-function show_art() {
-    cat << "EOF"
-    Made with love in India
-EOF
-}
-
-show_art
-
-# Initialize default values
-MODEL_PATH=""
-GGUF_FILE=""
-
-# Display help/usage information
-usage() {
-echo "Usage: $0 -m <model_path> -g <gguf_file>"
-echo
-echo "Options:"
-echo "  -m <model_path>    Set the path to the model"
-echo "  -g <gguf_file>     Set the GGUF file name"
-echo "  -h                 Display this help and exit"
-echo
-}
-
-# Parse command-line options
-while getopts ":m:g:h" opt; do
-case ${opt} in
-    m )
-    MODEL_PATH=$OPTARG
-    ;;
-    g )
-    GGUF_FILE=$OPTARG
-    ;;
-    h )
-    usage
-    exit 0
-    ;;
-    \? )
-    echo "Invalid Option: -$OPTARG" 1>&2
-    usage
-    exit 1
-    ;;
-    : )
-    echo "Invalid Option: -$OPTARG requires an argument" 1>&2
-    usage
-    exit 1
-    ;;
-esac
-done
-
-# Check required parameters
-if [ -z "$MODEL_PATH" ] || [ -z "$GGUF_FILE" ]; then
-    echo "Error: -m (model_path) and -g (gguf_file) are required."
-    usage
-    exit 1
-fi
-
-# Derive MODEL_NAME
-MODEL_NAME=$(echo $GGUF_FILE | sed 's/\(.*\)\.Q4.*/\\1/')
-
-# Log file where downloaded models are recorded
-DOWNLOAD_LOG="downloaded_models.log"
-
-# Composite logging name
-LOGGING_NAME="${MODEL_PATH}_${MODEL_NAME}"
-
-# Check if the model has been downloaded
-function is_model_downloaded {
-    grep -qxF "$LOGGING_NAME" "$DOWNLOAD_LOG" && return 0 || return 1
-}
-
-# Log the downloaded model
-function log_downloaded_model {
-    echo "$LOGGING_NAME" >> "$DOWNLOAD_LOG"
-}
-
-# Function to check if the model has already been created
-function is_model_created {
-    # 'ollama list' lists all models
-    ollama list | grep -q "$MODEL_NAME" && return 0 || return 1
-}
-
-# Check if huggingface-hub is installed, and install it if not
-if ! pip show huggingface-hub > /dev/null; then
-echo "Installing huggingface-hub..."
-pip install -U "huggingface_hub[cli]"
-else
-echo "huggingface-hub is already installed."
-fi
-
-# Check if the model has already been downloaded
-if is_model_downloaded; then
-    echo "Model $LOGGING_NAME has already been downloaded. Skipping download."
-else
-    echo "Downloading model $LOGGING_NAME..."
-    # Download the model
-    huggingface-cli download $MODEL_PATH $GGUF_FILE --local-dir downloads --local-dir-use-symlinks False
-
-    # Log the downloaded model
-    log_downloaded_model
-    echo "Model $LOGGING_NAME downloaded and logged."
-fi
-
-# Check if Ollama is installed, and install it if not
-if ! command -v ollama &> /dev/null; then
-echo "Installing Ollama..."
-curl -fsSL https://ollama.com/install.sh | sh
-else
-echo "Ollama is already installed."
-fi
-
-# Check if Ollama is already running
-if pgrep -f 'ollama serve' > /dev/null; then
-    echo "Ollama is already running. Skipping the start."
-else
-    echo "Starting Ollama..."
-    # Start Ollama in the background
-    ollama serve &
-
-    # Wait for Ollama to start
-    while true; do
-        if pgrep -f 'ollama serve' > /dev/null; then
-            echo "Ollama has started."
-            sleep 60
-            break
-        else
-            echo "Waiting for Ollama to start..."
-            sleep 1 # Wait for 1 second before checking again
-        fi
-    done
-fi
-
-# Check if the model has already been created
-if is_model_created; then
-    echo "Model $MODEL_NAME is already created. Skipping creation."
-else
-    echo "Creating model $MODEL_NAME..."
-    # Create the model in Ollama
-    # Prepare Modelfile with the downloaded path
-    echo "FROM ./downloads/$GGUF_FILE" > Modelfile
-    ollama create $MODEL_NAME -f Modelfile
-    echo "Model $MODEL_NAME created."
-fi
-
-
-echo "model name is > $MODEL_NAME"
-echo "Use Ollama run $MODEL_NAME"
-            """)
-        # Make autollama.sh executable (using chmod)
-        os.chmod(script_path, 0o755)
-
-    # Initialize command list
-    command = ["bash", script_path, "-m", model_path, "-g", gguf_file]
-
-    # Execute the command
-    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-
-    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 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:
-        with yaspin(text="Processing...") as spinner:
-            autollama(args.model_path, args.gguf_file)
-        spinner.ok("Done!")
-    except Exception as e:
-        console.print(f"[red]Error: {e}[/]")
-        exit(1)
-
-if __name__ == "__main__":
-    main()
-