webscout 4.7__py3-none-any.whl → 4.9__py3-none-any.whl

webscout/Agents/functioncall.py

@@ -3,14 +3,24 @@ 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)
+    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 []
-        # 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
+
+    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.
@@ -18,31 +28,72 @@ class FunctionCallingAgent:
         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}'
-        
+        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:
-            # Extract the JSON-like part of the response
+            # 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("JSON-like structure not found in the response")
+                raise ValueError("No valid JSON structure 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
+
+            # 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()
-            response_data = json.loads(response_json_str)
+
+            # Attempt to load the JSON string
+            return json.loads(response_json_str)
+
         except (ValueError, json.JSONDecodeError) as e:
-            # logging.error(f"An error occurred while parsing response: {e}")
+            logging.error(f"Error parsing function call: {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.
+        """
+        Executes the specified function with the provided arguments.
 
         Args:
             function_call_data (dict): A dictionary containing the function name and arguments.
@@ -50,28 +101,37 @@ class FunctionCallingAgent:
         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
+        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'
 
-        # Parse the arguments string into a dictionary
-        try:
-            arguments_dict = json.loads(arguments)
-        except json.JSONDecodeError:
-            # logging.error("Failed to parse arguments as JSON.")
+        if not isinstance(arguments, dict):
+            logging.error("Invalid arguments format.")
             return "Invalid arguments format."
 
-        # logging.info(f"Executing function: {function_name} with arguments: {arguments_dict}")
+        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."
 
-        # 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."
+    #     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__":
@@ -117,10 +177,10 @@ if __name__ == "__main__":
     ]
 
     agent = FunctionCallingAgent(tools=tools)
-    message = "tell me about HelpingAI flash"
+    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}")
+        print(f"Function Execution Result: {result}")

webscout/Bard.py

@@ -0,0 +1,365 @@
+import argparse
+import asyncio
+import json
+import os
+import random
+import re
+import string
+import sys
+from typing import Dict
+from typing import List
+
+import httpx
+from prompt_toolkit import prompt
+from prompt_toolkit import PromptSession
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+from prompt_toolkit.completion import WordCompleter
+from prompt_toolkit.history import InMemoryHistory
+from prompt_toolkit.key_binding import KeyBindings
+from rich.console import Console
+from rich.markdown import Markdown
+
+
+def __create_session() -> PromptSession:
+    return PromptSession(history=InMemoryHistory())
+
+
+def __create_completer(commands: list, pattern_str: str = "$") -> WordCompleter:
+    return WordCompleter(words=commands, pattern=re.compile(pattern_str))
+
+
+def __get_input(
+    prompt_sess: PromptSession = None,
+    completer: WordCompleter = None,
+    key_bindings: KeyBindings = None,
+) -> str:
+    """
+    Multiline input function.
+    """
+    return (
+        prompt_sess.prompt(
+            completer=completer,
+            multiline=True,
+            auto_suggest=AutoSuggestFromHistory(),
+            key_bindings=key_bindings,
+        )
+        if prompt_sess
+        else prompt(multiline=True)
+    )
+
+
+class Chatbot:
+    """
+    Synchronous wrapper for the AsyncChatbot class.
+    """
+
+    def __init__(
+        self,
+        secure_1psid: str,
+        secure_1psidts: str,
+        proxy: dict = None,
+        timeout: int = 20,
+    ):
+        self.loop = asyncio.get_event_loop()
+        self.async_chatbot = self.loop.run_until_complete(
+            AsyncChatbot.create(secure_1psid, secure_1psidts, proxy, timeout),
+        )
+
+    def save_conversation(self, file_path: str, conversation_name: str):
+        return self.loop.run_until_complete(
+            self.async_chatbot.save_conversation(file_path, conversation_name),
+        )
+
+    def load_conversations(self, file_path: str) -> List[Dict]:
+        return self.loop.run_until_complete(
+            self.async_chatbot.load_conversations(file_path),
+        )
+
+    def load_conversation(self, file_path: str, conversation_name: str) -> bool:
+        return self.loop.run_until_complete(
+            self.async_chatbot.load_conversation(file_path, conversation_name),
+        )
+
+    def ask(self, message: str) -> dict:
+        return self.loop.run_until_complete(self.async_chatbot.ask(message))
+
+
+class AsyncChatbot:
+    """
+    A class to interact with Google Gemini.
+    Parameters
+        session: str
+            The __Secure_1PSID cookie.
+        session_ts: str
+            The __secure_1psidts cookie.
+        proxy: str
+        timeout: int
+            Request timeout in seconds.
+    """
+
+    __slots__ = [
+        "headers",
+        "_reqid",
+        "SNlM0e",
+        "conversation_id",
+        "response_id",
+        "choice_id",
+        "proxy",
+        "secure_1psidts",
+        "secure_1psid",
+        "session",
+        "timeout",
+    ]
+
+    def __init__(
+        self,
+        secure_1psid: str,
+        secure_1psidts: str,
+        proxy: dict = None,
+        timeout: int = 20,
+    ):
+        """Constructor
+
+        Args:
+            secure_1psid (str): __Secure-1PSID cookie value
+            secure_1psidts (str): __Secure-1PSIDTS cookie value
+            proxy (dict, optional): Http request proxy. Defaults to None.
+            timeout (int, optional): htpp request timeout. Defaults to 20.
+        """
+        headers = {
+            "Content-Type": "application/x-www-form-urlencoded;charset=utf-8",
+            "Host": "gemini.google.com",
+            "Origin": "https://gemini.google.com",
+            "Referer": "https://gemini.google.com/",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+            "X-Same-Domain": "1",
+        }
+        self._reqid = int("".join(random.choices(string.digits, k=4)))
+        self.proxy = proxy
+        self.conversation_id = ""
+        self.response_id = ""
+        self.choice_id = ""
+        self.secure_1psid = secure_1psid
+        self.secure_1psidts = secure_1psidts
+        self.session = httpx.AsyncClient(proxies=self.proxy)
+        self.session.headers = headers
+        self.session.cookies.set("__Secure-1PSID", secure_1psid)
+        self.session.cookies.set("__Secure-1PSIDTS", secure_1psidts)
+        self.timeout = timeout
+
+    @classmethod
+    async def create(
+        cls,
+        secure_1psid: str,
+        secure_1psidts: str,
+        proxy: dict = None,
+        timeout: int = 20,
+    ) -> "AsyncChatbot":
+        """
+        Async constructor.
+        """
+        instance = cls(secure_1psid, secure_1psidts, proxy, timeout)
+        instance.SNlM0e = await instance.__get_snlm0e()
+        return instance
+
+    async def save_conversation(self, file_path: str, conversation_name: str) -> None:
+        """
+        Saves conversation to the file
+        :param file_path: file to save (json)
+        :param conversation_name: any name of current conversation (unique one)
+        :return: None
+        """
+        # Load conversations from file
+        conversations = await self.load_conversations(file_path)
+
+        # Update existing one
+        conversation_exists = False
+        for conversation in conversations:
+            if conversation["conversation_name"] == conversation_name:
+                conversation["conversation_name"] = conversation_name
+                conversation["_reqid"] = self._reqid
+                conversation["conversation_id"] = self.conversation_id
+                conversation["response_id"] = self.response_id
+                conversation["choice_id"] = self.choice_id
+                conversation["SNlM0e"] = self.SNlM0e
+                conversation_exists = True
+
+        # Create conversation object
+        if not conversation_exists:
+            conversation = {
+                "conversation_name": conversation_name,
+                "_reqid": self._reqid,
+                "conversation_id": self.conversation_id,
+                "response_id": self.response_id,
+                "choice_id": self.choice_id,
+                "SNlM0e": self.SNlM0e,
+            }
+            conversations.append(conversation)
+
+        # Save to the file
+        with open(file_path, "w", encoding="utf-8") as f:
+            json.dump(conversations, f, indent=4)
+
+    async def load_conversations(self, file_path: str) -> List[Dict]:
+        # Check if file exists
+        if not os.path.isfile(file_path):
+            return []
+        with open(file_path, encoding="utf-8") as f:
+            return json.load(f)
+
+    async def load_conversation(self, file_path: str, conversation_name: str) -> bool:
+        """
+        Loads a conversation from history file. Returns whether the conversation was found
+        :param file_path: File with conversations (json)
+        :param conversation_name: unique conversation name
+        :return: True if the conversation was found
+        """
+        conversations = await self.load_conversations(file_path)
+        for conversation in conversations:
+            if conversation["conversation_name"] == conversation_name:
+                self._reqid = conversation["_reqid"]
+                self.conversation_id = conversation["conversation_id"]
+                self.response_id = conversation["response_id"]
+                self.choice_id = conversation["choice_id"]
+                self.SNlM0e = conversation["SNlM0e"]
+                return True
+        return False
+
+    async def __get_snlm0e(self):
+        # Find "SNlM0e":"<ID>"
+        if (
+            not (self.secure_1psid and self.secure_1psidts)
+            or self.secure_1psid[:2] != "g."
+        ):
+            raise Exception(
+                "Enter correct __Secure_1PSID and __Secure_1PSIDTS value. __Secure_1PSID value must start with a g dot (g.). ",
+            )
+        resp = await self.session.get(
+            "https://gemini.google.com/app",
+            timeout=10,
+            follow_redirects=True,
+        )
+        if resp.status_code != 200:
+            raise Exception(
+                f"Response code not 200. Response Status is {resp.status_code}",
+            )
+        SNlM0e = re.search(r'"SNlM0e":"(.*?)"', resp.text)
+        if not SNlM0e:
+            raise Exception(
+                "SNlM0e value not found in response. Check __Secure_1PSID value."
+                "\nNOTE : The cookies expire after a short period; ensure you update them as frequent as possible."
+                f" Failed with status {resp.status_code} - {resp.reason_phrase}",
+            )
+        return SNlM0e.group(1)
+
+    async def ask(self, message: str) -> dict:
+        """
+        Send a message to Google Gemini and return the response.
+        :param message: The message to send to Google Gemini.
+        :return: A dict containing the response from Google Gemini.
+        """
+        # url params
+        params = {
+            "bl": "boq_assistant-bard-web-server_20230713.13_p0",
+            "_reqid": str(self._reqid),
+            "rt": "c",
+        }
+
+        # message arr -> data["f.req"]. Message is double json stringified
+        message_struct = [
+            [message],
+            None,
+            [self.conversation_id, self.response_id, self.choice_id],
+        ]
+        data = {
+            "f.req": json.dumps([None, json.dumps(message_struct)]),
+            "at": self.SNlM0e,
+        }
+        resp = await self.session.post(
+            "https://gemini.google.com/_/BardChatUi/data/assistant.lamda.BardFrontendService/StreamGenerate",
+            params=params,
+            data=data,
+            timeout=self.timeout,
+        )
+        chat_data = json.loads(resp.content.splitlines()[3])[0][2]
+        if not chat_data:
+            return {"content": f"Gemini encountered an error: {resp.content}."}
+        json_chat_data = json.loads(chat_data)
+        images = []
+        if len(json_chat_data) >= 3:
+            if len(json_chat_data[4][0]) >= 4:
+                if json_chat_data[4][0][4]:
+                    for img in json_chat_data[4][0][4]:
+                        images.append(img[0][0][0])
+        results = {
+            "content": json_chat_data[4][0][1][0],
+            "conversation_id": json_chat_data[1][0],
+            "response_id": json_chat_data[1][1],
+            "factualityQueries": json_chat_data[3],
+            "textQuery": json_chat_data[2][0] if json_chat_data[2] is not None else "",
+            "choices": [{"id": i[0], "content": i[1]} for i in json_chat_data[4]],
+            "images": images,
+        }
+        self.conversation_id = results["conversation_id"]
+        self.response_id = results["response_id"]
+        self.choice_id = results["choices"][0]["id"]
+        self._reqid += 100000
+        return results
+
+
+if __name__ == "__main__":
+    import sys
+    console = Console()
+    if os.getenv("Gemini_QUICK"):
+        Secure_1PSID = os.getenv("Gemini__Secure_1PSID")
+        secure_1psidts = os.getenv("Gemini__secure_1psidts")
+        if not (Secure_1PSID and secure_1psidts):
+            print(
+                "Gemini__Secure_1PSID or Gemini__secure_1psidts environment variable not set.",
+            )
+            sys.exit(1)
+        chatbot = Chatbot(Secure_1PSID, secure_1psidts)
+        # Join arguments into a single string
+        MESSAGE = " ".join(sys.argv[1:])
+        response = chatbot.ask(MESSAGE)
+        console.print(Markdown(response["content"]))
+        console.print(response["images"] if response.get("images") else "")
+        sys.exit(0)
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--session",
+        help="__Secure-1PSID cookie",
+        type=str,
+        required=True,
+    )
+    parser.add_argument(
+        "--session_ts",
+        help="__secure_1psidts cookie.",
+        type=str,
+        required=True,
+    )
+    args = parser.parse_args()
+
+    chatbot = Chatbot(args.session, args.session_ts)
+    prompt_session = __create_session()
+    completions = __create_completer(["!exit", "!reset"])
+
+    try:
+        while True:
+            console.print("You:")
+            user_prompt = __get_input(prompt_sess=prompt_session, completer=completions)
+            console.print()
+            if user_prompt == "!exit":
+                break
+            elif user_prompt == "!reset":
+                chatbot.conversation_id = ""
+                chatbot.response_id = ""
+                chatbot.choice_id = ""
+                continue
+            print("Google Gemini:")
+            response = chatbot.ask(user_prompt)
+            console.print(Markdown(response["content"]))
+            console.print(response["images"] if response.get("images") else "")
+            print()
+    except KeyboardInterrupt:
+        print("Exiting...")

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)