webscout 4.8__py3-none-any.whl → 5.0__py3-none-any.whl

webscout/Agents/functioncall.py

@@ -1,72 +1,44 @@
 import json
 import logging
-from webscout import DeepInfra, WEBS
+from webscout import LLAMA3, WEBS
 
 class FunctionCallingAgent:
-    def __init__(self, model: str = "Qwen/Qwen2-72B-Instruct", 
+    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):
-        """
-        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.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:
-        """
-        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)
+        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:
-        """
-        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])
+        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}"
+            "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:
-        """
-        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("{")
@@ -76,14 +48,7 @@ class FunctionCallingAgent:
                 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)
 
@@ -92,17 +57,8 @@ class FunctionCallingAgent:
             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'
+        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.")
@@ -110,28 +66,32 @@ class FunctionCallingAgent:
 
         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."
+    #     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:
-    #     """
-    #     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}"
+    #     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__":
@@ -139,48 +99,44 @@ if __name__ == "__main__":
         {
             "type": "function",
             "function": {
-                "name": "UserDetail",
+                "name": "web_search",
+                "description": "Search query on Google",
                 "parameters": {
                     "type": "object",
-                    "title": "UserDetail",
                     "properties": {
-                        "name": {
-                            "title": "Name",
-                            "type": "string"
-                        },
-                        "age": {
-                            "title": "Age",
-                            "type": "integer"
+                        "query": {
+                            "type": "string",
+                            "description": "web search query"
                         }
                     },
-                    "required": ["name", "age"]
+                    "required": ["query"]
                 }
             }
         },
         {
             "type": "function",
             "function": {
-                "name": "web_search",
-                "description": "Search query on google",
+                "name": "general_ai",
+                "description": "Use AI to answer a general question",
                 "parameters": {
                     "type": "object",
                     "properties": {
-                        "query": {
+                        "question": {
                             "type": "string",
-                            "description": "web search query"
+                            "description": "The question to be answered by the AI"
                         }
                     },
-                    "required": ["query"]
+                    "required": ["question"]
                 }
             }
         }
     ]
 
     agent = FunctionCallingAgent(tools=tools)
-    message = "websearch about helpingai-9b"
+    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}")
+        print(f"Function Execution Result: {result}")

webscout/Bing_search.py

@@ -0,0 +1,124 @@
+from bs4 import BeautifulSoup
+import requests
+from typing import Dict, List, Optional, Union
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from urllib.parse import urlparse
+from termcolor import colored
+import time
+import random
+
+class BingS:
+    """Bing search class to get search results from bing.com."""
+
+    _executor: ThreadPoolExecutor = ThreadPoolExecutor(max_workers=10)
+
+    def __init__(
+        self,
+        headers: Optional[Dict[str, str]] = None,
+        proxy: Optional[str] = None,
+        timeout: Optional[int] = 10,
+    ) -> None:
+        """Initialize the BingS object."""
+        self.proxy: Optional[str] = proxy
+        self.headers = headers if headers else {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36 Edg/111.0.1661.62"
+        }
+        self.headers["Referer"] = "https://www.bing.com/"
+        self.client = requests.Session()
+        self.client.headers.update(self.headers)
+        self.client.proxies.update({"http": self.proxy, "https": self.proxy})
+        self.timeout = timeout
+
+    def __enter__(self) -> "BingS":
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.client.close()
+
+    def _get_url(
+        self,
+        method: str,
+        url: str,
+        params: Optional[Dict[str, str]] = None,
+        data: Optional[Union[Dict[str, str], bytes]] = None,
+    ) -> bytes:
+        try:
+            resp = self.client.request(method, url, params=params, data=data, timeout=self.timeout)
+        except Exception as ex:
+            raise Exception(f"{url} {type(ex).__name__}: {ex}") from ex
+        if resp.status_code == 200:
+            return resp.content
+        raise Exception(f"{resp.url} returned status code {resp.status_code}. {params=} {data=}")
+
+    def search(
+        self,
+        keywords: str,
+        region: str = "us-EN",  # Bing uses us-EN
+        lang: str = "en",
+        safe: str = "off",
+        timelimit: Optional[str] = None,  # Not directly supported by Bing
+        max_results: Optional[int] = None,
+    ) -> List[Dict[str, str]]:
+        """Bing text search."""
+        assert keywords, "keywords is mandatory"
+
+        results = []
+        start = 1  # Bing uses 1-based indexing for pages
+        while len(results) < (max_results or float('inf')):
+            params = {
+                "q": keywords,
+                "count": 10,  # Number of results per page
+                "mkt": region,
+                "setlang": lang,
+                "safeSearch": safe,
+                "first": start,  # Bing uses 'first' for pagination
+            }
+
+            try:
+                resp_content = self._get_url("GET", "https://www.bing.com/search", params=params)
+                soup = BeautifulSoup(resp_content, "html.parser")
+                result_block = soup.find_all("li", class_="b_algo")
+
+                if not result_block:
+                    break
+
+                for result in result_block:
+                    try:
+                        link = result.find("a", href=True)
+                        if link:
+                            initial_url = link["href"]
+
+                            title = result.find("h2").text if result.find("h2") else ""
+                            description = result.find("p").text.strip() if result.find("p") else ""  # Strip whitespace
+
+                            # Remove 'WEB' prefix if present
+                            if description.startswith("WEB"):
+                                description = description[4:]  # Skip the first 4 characters ('WEB ')
+
+                            results.append({
+                                "title": title,
+                                "href": initial_url,
+                                "abstract": description,
+                                "index": len(results),
+                                "type": "web",
+                            })
+
+                            if len(results) >= max_results:
+                                return results
+
+                    except Exception as e:
+                        print(f"Error extracting result: {e}")
+
+            except Exception as e:
+                print(f"Error fetching URL: {e}")
+
+            start += 10
+
+        return results
+
+if __name__ == "__main__":
+    from rich import print
+    searcher = BingS()
+    results = searcher.search("Python development tools", max_results=30)
+    for result in results:
+        print(result)