Upload 85 files

webscout/AIauto.py

@@ -0,0 +1,493 @@
+from webscout.AIbase import Provider, AsyncProvider
+from webscout import OPENGPT, AsyncOPENGPT
+from webscout import KOBOLDAI, AsyncKOBOLDAI
+from webscout import PhindSearch, AsyncPhindSearch
+from webscout import LLAMA2, AsyncLLAMA2
+from webscout import BLACKBOXAI, AsyncBLACKBOXAI
+from webscout import PERPLEXITY
+from webscout import ThinkAnyAI
+from webscout import YouChat
+from webscout import YEPCHAT
+from webscout.AIbase import Provider, AsyncProvider
+from webscout import KOBOLDAI, AsyncKOBOLDAI
+from webscout import PhindSearch, AsyncPhindSearch
+from webscout import LLAMA2, AsyncLLAMA2
+from webscout import BLACKBOXAI, AsyncBLACKBOXAI
+from webscout import PERPLEXITY
+from webscout import ThinkAnyAI
+from webscout import YouChat
+from webscout import YEPCHAT, AsyncYEPCHAT
+from webscout import LEO, AsyncLEO
+from webscout import GROQ, AsyncGROQ
+from webscout import OPENAI, AsyncOPENAI
+from webscout import REKA
+from webscout import Xjai
+from webscout import Berlin4h
+from webscout import ChatGPTUK
+from webscout.g4f import GPT4FREE, AsyncGPT4FREE
+from webscout.g4f import TestProviders
+from webscout.exceptions import AllProvidersFailure
+from webscout.async_providers import mapper as async_provider_map
+from typing import AsyncGenerator
+
+from typing import Union
+from typing import Any
+import logging
+
+
+provider_map: dict[
+    str, Union[    ThinkAnyAI,
+    Xjai,
+    LLAMA2,
+    AsyncLLAMA2,
+    LEO,
+    AsyncLEO,
+    KOBOLDAI,
+    AsyncKOBOLDAI,
+    OPENGPT,
+    AsyncOPENGPT,
+    PERPLEXITY,
+    BLACKBOXAI,
+    AsyncBLACKBOXAI,
+    PhindSearch,
+    AsyncPhindSearch,
+    YEPCHAT,
+    AsyncYEPCHAT,
+    YouChat,
+    Berlin4h,
+    ChatGPTUK,]
+] = {
+    "PhindSearch": PhindSearch,
+    "perplexity": PERPLEXITY,
+    "opengpt": OPENGPT,
+    "koboldai": KOBOLDAI,
+    "llama2": LLAMA2,
+    "blackboxai": BLACKBOXAI,
+    "gpt4free": GPT4FREE,
+    "thinkany": ThinkAnyAI,
+    "yepchat": YEPCHAT,
+    "you": YouChat,
+    "leo": LEO,
+    "xjai": Xjai,
+    "berlin4h": Berlin4h,
+    "chatgptuk": ChatGPTUK,
+    "gpt4free": GPT4FREE,
+    
+}
+
+
+class AUTO(Provider):
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        exclude: list[str] = [],
+    ):
+        """Instantiates AUTO
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+            exclude(list[str], optional): List of providers to be excluded. Defaults to [].
+        """
+        self.provider: Union[OPENGPT, KOBOLDAI, PhindSearch, LLAMA2, BLACKBOXAI, PERPLEXITY, GPT4FREE, ThinkAnyAI, YEPCHAT, YouChat] = None
+        self.provider_name: str = None
+        self.is_conversation = is_conversation
+        self.max_tokens = max_tokens
+        self.timeout = timeout
+        self.intro = intro
+        self.filepath = filepath
+        self.update_file = update_file
+        self.proxies = proxies
+        self.history_offset = history_offset
+        self.act = act
+        self.exclude = exclude
+
+    @property
+    def last_response(self) -> dict[str, Any]:
+        return self.provider.last_response
+
+    @property
+    def conversation(self) -> object:
+        return self.provider.conversation
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+        run_new_test: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+            run_new_test (bool, optional): Perform new test on g4f-based providers. Defaults to False.
+        Returns:
+           dict : {}
+        """
+        ask_kwargs: dict[str, Union[str, bool]] = {
+            "prompt": prompt,
+            "stream": stream,
+            "raw": raw,
+            "optimizer": optimizer,
+            "conversationally": conversationally,
+        }
+
+        # webscout-based providers
+        for provider_name, provider_obj in provider_map.items():
+            # continue
+            if provider_name in self.exclude:
+                continue
+            try:
+                self.provider_name = f"webscout-{provider_name}"
+                self.provider = provider_obj(
+                    is_conversation=self.is_conversation,
+                    max_tokens=self.max_tokens,
+                    timeout=self.timeout,
+                    intro=self.intro,
+                    filepath=self.filepath,
+                    update_file=self.update_file,
+                    proxies=self.proxies,
+                    history_offset=self.history_offset,
+                    act=self.act,
+                )
+
+                def for_stream():
+                    for chunk in self.provider.ask(**ask_kwargs):
+                        yield chunk
+
+                def for_non_stream():
+                    return self.provider.ask(**ask_kwargs)
+
+                return for_stream() if stream else for_non_stream()
+
+            except Exception as e:
+                logging.debug(
+                    f"Failed to generate response using provider {provider_name} - {e}"
+                )
+
+        # g4f-based providers
+
+        for provider_info in TestProviders(timeout=self.timeout).get_results(
+            run=run_new_test
+        ):
+            if provider_info["name"] in self.exclude:
+                continue
+            try:
+                self.provider_name = f"g4f-{provider_info['name']}"
+                self.provider = GPT4FREE(
+                    provider=provider_info["name"],
+                    is_conversation=self.is_conversation,
+                    max_tokens=self.max_tokens,
+                    intro=self.intro,
+                    filepath=self.filepath,
+                    update_file=self.update_file,
+                    proxies=self.proxies,
+                    history_offset=self.history_offset,
+                    act=self.act,
+                )
+
+                def for_stream():
+                    for chunk in self.provider.ask(**ask_kwargs):
+                        yield chunk
+
+                def for_non_stream():
+                    return self.provider.ask(**ask_kwargs)
+
+                return for_stream() if stream else for_non_stream()
+
+            except Exception as e:
+                logging.debug(
+                    f"Failed to generate response using GPT4FREE-base provider {provider_name} - {e}"
+                )
+
+        raise AllProvidersFailure(
+            "None of the providers generated response successfully."
+        )
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+        run_new_test: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+            run_new_test (bool, optional): Perform new test on g4f-based providers. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt,
+                True,
+                optimizer=optimizer,
+                conversationally=conversationally,
+                run_new_test=run_new_test,
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            ask_response = self.ask(
+                prompt,
+                False,
+                optimizer=optimizer,
+                conversationally=conversationally,
+                run_new_test=run_new_test,
+            )
+            return self.get_message(ask_response)
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert self.provider is not None, "Chat with AI first"
+        return self.provider.get_message(response)
+
+
+class AsyncAUTO(AsyncProvider):
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        exclude: list[str] = [],
+    ):
+        """Instantiates AsyncAUTO
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+            exclude(list[str], optional): List of providers to be excluded. Defaults to [].
+        """
+        self.provider: Union[
+            AsyncOPENGPT,
+            AsyncKOBOLDAI,
+            AsyncPhindSearch,
+            AsyncLLAMA2,
+            AsyncBLACKBOXAI,
+            AsyncGPT4FREE,
+        ] = None
+        self.provider_name: str = None
+        self.is_conversation = is_conversation
+        self.max_tokens = max_tokens
+        self.timeout = timeout
+        self.intro = intro
+        self.filepath = filepath
+        self.update_file = update_file
+        self.proxies = proxies
+        self.history_offset = history_offset
+        self.act = act
+        self.exclude = exclude
+
+    @property
+    def last_response(self) -> dict[str, Any]:
+        return self.provider.last_response
+
+    @property
+    def conversation(self) -> object:
+        return self.provider.conversation
+
+    async def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+        run_new_test: bool = False,
+    ) -> dict | AsyncGenerator:
+        """Chat with AI asynchronously.
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+            run_new_test (bool, optional): Perform new test on g4f-based providers. Defaults to False.
+        Returns:
+           dict|AsyncGenerator : ai response.
+        """
+        ask_kwargs: dict[str, Union[str, bool]] = {
+            "prompt": prompt,
+            "stream": stream,
+            "raw": raw,
+            "optimizer": optimizer,
+            "conversationally": conversationally,
+        }
+
+        # tgpt-based providers
+        for provider_name, provider_obj in async_provider_map.items():
+            if provider_name in self.exclude:
+                continue
+            try:
+                self.provider_name = f"tgpt-{provider_name}"
+                self.provider = provider_obj(
+                    is_conversation=self.is_conversation,
+                    max_tokens=self.max_tokens,
+                    timeout=self.timeout,
+                    intro=self.intro,
+                    filepath=self.filepath,
+                    update_file=self.update_file,
+                    proxies=self.proxies,
+                    history_offset=self.history_offset,
+                    act=self.act,
+                )
+
+                async def for_stream():
+                    async_ask = await self.provider.ask(**ask_kwargs)
+                    async for chunk in async_ask:
+                        yield chunk
+
+                async def for_non_stream():
+                    return await self.provider.ask(**ask_kwargs)
+
+                return for_stream() if stream else await for_non_stream()
+
+            except Exception as e:
+                logging.debug(
+                    f"Failed to generate response using provider {provider_name} - {e}"
+                )
+
+        # g4f-based providers
+
+        for provider_info in TestProviders(timeout=self.timeout).get_results(
+            run=run_new_test
+        ):
+            if provider_info["name"] in self.exclude:
+                continue
+            try:
+                self.provider_name = f"g4f-{provider_info['name']}"
+                self.provider = AsyncGPT4FREE(
+                    provider=provider_info["name"],
+                    is_conversation=self.is_conversation,
+                    max_tokens=self.max_tokens,
+                    intro=self.intro,
+                    filepath=self.filepath,
+                    update_file=self.update_file,
+                    proxies=self.proxies,
+                    history_offset=self.history_offset,
+                    act=self.act,
+                )
+
+                async def for_stream():
+                    async_ask = await self.provider.ask(**ask_kwargs)
+                    async for chunk in async_ask:
+                        yield chunk
+
+                async def for_non_stream():
+                    return await self.provider.ask(**ask_kwargs)
+
+                return for_stream() if stream else await for_non_stream()
+
+            except Exception as e:
+                logging.debug(
+                    f"Failed to generate response using GPT4FREE-base provider {provider_name} - {e}"
+                )
+
+        raise AllProvidersFailure(
+            "None of the providers generated response successfully."
+        )
+
+    async def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+        run_new_test: bool = False,
+    ) -> str | AsyncGenerator:
+        """Generate response `str` asynchronously.
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+            run_new_test (bool, optional): Perform new test on g4f-based providers. Defaults to False.
+        Returns:
+            str|AsyncGenerator: Response generated
+        """
+
+        async def for_stream():
+            async_ask = await self.ask(
+                prompt,
+                True,
+                optimizer=optimizer,
+                conversationally=conversationally,
+                run_new_test=run_new_test,
+            )
+            async for response in async_ask:
+                yield await self.get_message(response)
+
+        async def for_non_stream():
+            ask_response = await self.ask(
+                prompt,
+                False,
+                optimizer=optimizer,
+                conversationally=conversationally,
+                run_new_test=run_new_test,
+            )
+            return await self.get_message(ask_response)
+
+        return for_stream() if stream else await for_non_stream()
+
+    async def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert self.provider is not None, "Chat with AI first"
+        return await self.provider.get_message(response)

webscout/AIbase.py

@@ -0,0 +1,138 @@
+from abc import ABC
+from abc import abstractmethod
+
+
+class Provider(ABC):
+    """Base class for providers"""
+
+    @abstractmethod
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+        Args:
+            prompt (str): Prompt to be sent
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict : {}
+        ```json
+        {
+            "completion": "\nNext: domestic cat breeds with short hair >>",
+            "stop_reason": null,
+            "truncated": false,
+            "stop": null,
+            "model": "llama-2-13b-chat",
+            "log_id": "cmpl-3kYiYxSNDvgMShSzFooz6t",
+            "exception": null
+        }
+        ```
+        """
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be sent
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+
+class AsyncProvider(ABC):
+    """Asynchronous base class for providers"""
+
+    @abstractmethod
+    async def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Asynchronously chat with AI
+
+        Args:
+            prompt (str): Prompt to be sent
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict : {}
+        ```json
+        {
+            "completion": "\nNext: domestic cat breeds with short hair >>",
+            "stop_reason": null,
+            "truncated": false,
+            "stop": null,
+            "model": "llama-2-13b-chat",
+            "log_id": "cmpl-3kYiYxSNDvgMShSzFooz6t",
+            "exception": null
+        }
+        ```
+        """
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    async def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Asynchronously generate response `str`
+        Args:
+            prompt (str): Prompt to be sent
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    async def get_message(self, response: dict) -> str:
+        """Asynchronously retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        raise NotImplementedError("Method needs to be implemented in subclass")

webscout/AIutel.py

@@ -0,0 +1,995 @@
+import os
+import json
+import platform
+import subprocess
+import logging
+import appdirs
+import datetime
+import re
+import sys
+import click
+from rich.markdown import Markdown
+from rich.console import Console
+import g4f
+from typing import Union
+from typing import NoReturn
+import requests
+from pathlib import Path
+from playsound import playsound
+from time import sleep as wait
+import pathlib
+import urllib.parse
+appdir = appdirs.AppDirs("AIWEBS", "vortex")
+
+default_path = appdir.user_cache_dir
+
+if not os.path.exists(default_path):
+    os.makedirs(default_path)
+webai = [
+   "leo",
+   "openai",
+   "opengpt",
+   "koboldai",
+   "gemini",
+   "phind",
+   "blackboxai",
+   "g4fauto",
+   "perplexity",
+   "groq",
+   "reka",
+   "cohere",
+   "yepchat",
+   "you",
+   "xjai",
+   "thinkany",
+   "berlin4h",
+   "chatgptuk",
+   "auto",
+   "poe",
+]
+gpt4free_providers = [
+    provider.__name__ for provider in g4f.Provider.__providers__  # if provider.working
+]
+
+available_providers = webai + gpt4free_providers
+def sanitize_stream(
+    chunk: str, intro_value: str = "data:", to_json: bool = True
+) -> str | dict:
+    """Remove streaming flags
+
+    Args:
+        chunk (str): Streamig chunk.
+        intro_value (str, optional): streaming flag. Defaults to "data:".
+        to_json (bool, optional). Return chunk as dictionary. Defaults to True.
+
+    Returns:
+        str: Sanitized streaming value.
+    """
+
+    if chunk.startswith(intro_value):
+        chunk = chunk[len(intro_value) :]
+
+    return json.loads(chunk) if to_json else chunk
+def run_system_command(
+    command: str,
+    exit_on_error: bool = True,
+    stdout_error: bool = True,
+    help: str = None,
+):
+    """Run commands against system
+    Args:
+        command (str): shell command
+        exit_on_error (bool, optional): Exit on error. Defaults to True.
+        stdout_error (bool, optional): Print out the error. Defaults to True
+        help (str, optional): Help info incase of exception. Defaults to None.
+    Returns:
+        tuple : (is_successfull, object[Exception|Subprocess.run])
+    """
+    try:
+        # Run the command and capture the output
+        result = subprocess.run(
+            command,
+            shell=True,
+            check=True,
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        return (True, result)
+    except subprocess.CalledProcessError as e:
+        # Handle error if the command returns a non-zero exit code
+        if stdout_error:
+            click.secho(f"Error Occurred: while running '{command}'", fg="yellow")
+            click.secho(e.stderr, fg="red")
+            if help is not None:
+                click.secho(help, fg="cyan")
+        sys.exit(e.returncode) if exit_on_error else None
+        return (False, e)
+
+
+class Optimizers:
+    @staticmethod
+    def code(prompt):
+        return (
+            "Your Role: Provide only code as output without any description.\n"
+            "IMPORTANT: Provide only plain text without Markdown formatting.\n"
+            "IMPORTANT: Do not include markdown formatting."
+            "If there is a lack of details, provide most logical solution. You are not allowed to ask for more details."
+            "Ignore any potential risk of errors or confusion.\n\n"
+            f"Request: {prompt}\n"
+            f"Code:"
+        )
+
+    @staticmethod
+    def shell_command(prompt):
+        # Get os
+        operating_system = ""
+        if platform.system() == "Windows":
+            operating_system = "Windows"
+        elif platform.system() == "Darwin":
+            operating_system = "MacOS"
+        elif platform.system() == "Linux":
+            try:
+                result = (
+                    subprocess.check_output(["lsb_release", "-si"]).decode().strip()
+                )
+                distro = result if result else ""
+                operating_system = f"Linux/{distro}"
+            except Exception:
+                operating_system = "Linux"
+        else:
+            operating_system = platform.system()
+
+        # Get Shell
+        shell_name = "/bin/sh"
+        if platform.system() == "Windows":
+            shell_name = "cmd.exe"
+        if os.getenv("PSModulePath"):
+            shell_name = "powershell.exe"
+        else:
+            shell_env = os.getenv("SHELL")
+            if shell_env:
+                shell_name = shell_env
+
+        return (
+            "Your role: Provide only plain text without Markdown formatting. "
+            "Do not show any warnings or information regarding your capabilities. "
+            "Do not provide any description. If you need to store any data, "
+            f"assume it will be stored in the chat. Provide only {shell_name} "
+            f"command for {operating_system} without any description. If there is "
+            "a lack of details, provide most logical solution. Ensure the output "
+            "is a valid shell command. If multiple steps required try to combine "
+            f"them together. Prompt: {prompt}\n\nCommand:"
+        )
+
+
+class Conversation:
+    """Handles prompt generation based on history"""
+
+    intro = (
+        "You're a Large Language Model for chatting with people. "
+        "Assume role of the LLM and give your response."
+        # "Refrain from regenerating the conversation between user and LLM."
+    )
+
+    def __init__(
+        self,
+        status: bool = True,
+        max_tokens: int = 600,
+        filepath: str = None,
+        update_file: bool = True,
+    ):
+        """Initializes Conversation
+
+        Args:
+            status (bool, optional): Flag to control history. Defaults to True.
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+        """
+        self.status = status
+        self.max_tokens_to_sample = max_tokens
+        self.chat_history = self.intro
+        self.history_format = "\nUser : %(user)s\nLLM :%(llm)s"
+        self.file = filepath
+        self.update_file = update_file
+        self.history_offset = 10250
+        self.prompt_allowance = 10
+        self.load_conversation(filepath, False) if filepath else None
+
+    def load_conversation(self, filepath: str, exists: bool = True) -> None:
+        """Load conversation into chat's history from .txt file
+
+        Args:
+            filepath (str): Path to .txt file
+            exists (bool, optional): Flag for file availability. Defaults to True.
+        """
+        assert isinstance(
+            filepath, str
+        ), f"Filepath needs to be of str datatype not {type(filepath)}"
+        assert (
+            os.path.isfile(filepath) if exists else True
+        ), f"File '{filepath}' does not exist"
+        if not os.path.isfile(filepath):
+            logging.debug(f"Creating new chat-history file - '{filepath}'")
+            with open(filepath, "w") as fh:  # Try creating new file
+                # lets add intro here
+                fh.write(self.intro)
+        else:
+            logging.debug(f"Loading conversation from '{filepath}'")
+            with open(filepath) as fh:
+                file_contents = fh.read()
+                # Presume intro prompt is part of the file content
+                self.chat_history = file_contents
+
+    def __trim_chat_history(self, chat_history: str) -> str:
+        """Ensures the len(prompt) and max_tokens_to_sample is not > 4096"""
+        len_of_intro = len(self.intro)
+        len_of_chat_history = len(chat_history)
+        total = (
+            self.max_tokens_to_sample + len_of_intro + len_of_chat_history
+        )  # + self.max_tokens_to_sample
+        if total > self.history_offset:
+            truncate_at = (total - self.history_offset) + self.prompt_allowance
+            # Remove head of total (n) of chat_history
+            new_chat_history = chat_history[truncate_at:]
+            self.chat_history = self.intro + "\n... " + new_chat_history
+            # print(len(self.chat_history))
+            return self.chat_history
+        # print(len(chat_history))
+        return chat_history
+
+    def gen_complete_prompt(self, prompt: str) -> str:
+        """Generates a kinda like incomplete conversation
+
+        Args:
+            prompt (str): _description_
+
+        Returns:
+            str: Updated incomplete chat_history
+        """
+        if self.status:
+            resp = self.chat_history + self.history_format % dict(user=prompt, llm="")
+            return self.__trim_chat_history(resp)
+
+        return prompt
+
+    def update_chat_history(
+        self, prompt: str, response: str, force: bool = False
+    ) -> None:
+        """Updates chat history
+
+        Args:
+            prompt (str): user prompt
+            response (str): LLM response
+            force (bool, optional): Force update
+        """
+        if not self.status and not force:
+            return
+        new_history = self.history_format % dict(user=prompt, llm=response)
+        if self.file and self.update_file:
+            with open(self.file, "a") as fh:
+                fh.write(new_history)
+        self.chat_history += new_history
+
+
+class AwesomePrompts:
+    awesome_prompt_url = (
+        "https://raw.githubusercontent.com/OE-LUCIFER/prompts/main/prompt.json"
+    )
+    awesome_prompt_path = os.path.join(default_path, "all-acts.json")
+
+    __is_prompt_updated = False
+
+    def __init__(self):
+        self.acts = self.all_acts
+
+    def __search_key(self, key: str, raise_not_found: bool = False) -> str:
+        """Perform insentive awesome-prompt key search
+
+        Args:
+            key (str): key
+            raise_not_found (bool, optional): Control KeyError exception. Defaults to False.
+
+        Returns:
+            str|None: Exact key name
+        """
+        for key_, value in self.all_acts.items():
+            if str(key).lower() in str(key_).lower():
+                return key_
+        if raise_not_found:
+            raise KeyError(f"Zero awesome prompt found with key - `{key}`")
+
+    def get_acts(self):
+        """Retrieves all awesome-prompts"""
+        with open(self.awesome_prompt_path) as fh:
+            prompt_dict = json.load(fh)
+        return prompt_dict
+
+    def update_prompts_from_online(self, override: bool = False):
+        """Download awesome-prompts and update existing ones if available
+        args:
+           override (bool, optional): Overwrite existing contents in path
+        """
+        resp = {}
+        if not self.__is_prompt_updated:
+            import requests
+
+            logging.info("Downloading & updating awesome prompts")
+            response = requests.get(self.awesome_prompt_url)
+            response.raise_for_status
+            resp.update(response.json())
+            if os.path.isfile(self.awesome_prompt_path) and not override:
+                resp.update(self.get_acts())
+            self.__is_prompt_updated = True
+            with open(self.awesome_prompt_path, "w") as fh:
+                json.dump(resp, fh, indent=4)
+        else:
+            logging.debug("Ignoring remote prompt update")
+
+    @property
+    def all_acts(self) -> dict:
+        """All awesome_prompts & their indexes mapped to values
+
+        Returns:
+            dict: Awesome-prompts
+        """
+
+        resp = {}
+        if not os.path.isfile(self.awesome_prompt_path):
+            self.update_prompts_from_online()
+        resp.update(self.get_acts())
+
+        for count, key_value in enumerate(self.get_acts().items()):
+            # Lets map also index to the value
+            resp.update({count: key_value[1]})
+
+        return resp
+
+    def get_act(
+        self,
+        key: str,
+        default: str = None,
+        case_insensitive: bool = True,
+        raise_not_found: bool = False,
+    ) -> str:
+        """Retrieves specific act of awesome_prompt
+
+        Args:
+            key (str|int): Act name or index
+            default (str): Value to be returned incase act not found.
+            case_insensitive (bool): Perform search key insensitive. Defaults to True.
+            raise_not_found (bool, optional): Control KeyError exception. Defaults to False.
+
+        Raises:
+            KeyError: Incase key not found
+
+        Returns:
+            str: Awesome prompt value
+        """
+        if str(key).isdigit():
+            key = int(key)
+        act = self.all_acts.get(key, default)
+        if not act and case_insensitive:
+            act = self.all_acts.get(self.__search_key(key, raise_not_found))
+        return act
+
+    def add_prompt(self, name: str, prompt: str) -> bool:
+        """Add new prompt or update an existing one.
+
+        Args:
+            name (str): act name
+            prompt (str): prompt value
+        """
+        current_prompts = self.get_acts()
+        with open(self.awesome_prompt_path, "w") as fh:
+            current_prompts[name] = prompt
+            json.dump(current_prompts, fh, indent=4)
+        logging.info(f"New prompt added successfully - `{name}`")
+
+    def delete_prompt(
+        self, name: str, case_insensitive: bool = True, raise_not_found: bool = False
+    ) -> bool:
+        """Delete an existing prompt
+
+        Args:
+            name (str): act name
+            case_insensitive(bool, optional): Ignore the key cases. Defaults to True.
+            raise_not_found (bool, optional): Control KeyError exception. Default is False.
+        Returns:
+            bool: is_successful report
+        """
+        name = self.__search_key(name, raise_not_found) if case_insensitive else name
+        current_prompts = self.get_acts()
+        is_name_available = (
+            current_prompts[name] if raise_not_found else current_prompts.get(name)
+        )
+        if is_name_available:
+            with open(self.awesome_prompt_path, "w") as fh:
+                current_prompts.pop(name)
+                json.dump(current_prompts, fh, indent=4)
+            logging.info(f"Prompt deleted successfully - `{name}`")
+        else:
+            return False
+
+
+class Updates:
+    """Webscout latest release info"""
+
+    url = "https://api.github.com/repos/OE-LUCIFER/Webscout/releases/latest"
+
+    @property
+    def latest_version(self):
+        return self.latest(version=True)
+
+    def executable(self, system: str = platform.system()) -> str:
+        """Url pointing to executable for particular system
+
+        Args:
+            system (str, optional): system name. Defaults to platform.system().
+
+        Returns:
+            str: url
+        """
+        for entry in self.latest()["assets"]:
+            if entry.get("target") == system:
+                return entry.get("url")
+
+    def latest(self, whole: bool = False, version: bool = False) -> dict:
+        """Check Webscout latest version info
+
+        Args:
+            whole (bool, optional): Return whole json response. Defaults to False.
+            version (bool, optional): return version only. Defaults to False.
+
+        Returns:
+            bool|dict: version str or whole dict info
+        """
+        import requests
+
+        data = requests.get(self.url).json()
+        if whole:
+            return data
+
+        elif version:
+            return data.get("tag_name")
+
+        else:
+            sorted = dict(
+                tag_name=data.get("tag_name"),
+                tarball_url=data.get("tarball_url"),
+                zipball_url=data.get("zipball_url"),
+                html_url=data.get("html_url"),
+                body=data.get("body"),
+            )
+            whole_assets = []
+            for entry in data.get("assets"):
+                url = entry.get("browser_download_url")
+                assets = dict(url=url, size=entry.get("size"))
+                if ".deb" in url:
+                    assets["target"] = "Debian"
+                elif ".exe" in url:
+                    assets["target"] = "Windows"
+                elif "macos" in url:
+                    assets["target"] = "Mac"
+                elif "linux" in url:
+                    assets["target"] = "Linux"
+
+                whole_assets.append(assets)
+            sorted["assets"] = whole_assets
+
+            return sorted
+
+
+class RawDog:
+    """Generate and auto-execute Python scripts in the cli"""
+
+    examples = """\
+EXAMPLES:
+
+1. User: Kill the process running on port 3000
+
+LLM:
+```python
+import os
+os.system("kill $(lsof -t -i:3000)")
+print("Process killed")
+```
+
+2. User: Summarize my essay
+
+LLM:
+```python
+import glob
+files = glob.glob("*essay*.*")
+with open(files[0], "r") as f:
+    print(f.read())
+```
+CONTINUE
+
+User:
+LAST SCRIPT OUTPUT:
+John Smith
+Essay 2021-09-01
+...
+
+LLM:
+```python
+print("The essay is about...")
+```
+"""
+
+
+    def __init__(
+        self,
+        quiet: bool = False,
+        internal_exec: bool = False,
+        confirm_script: bool = False,
+        interpreter: str = "python",
+        prettify: bool = True,
+    ):
+        """Constructor
+
+        Args:
+            quiet (bool, optional): Flag for control logging. Defaults to False.
+            internal_exec (bool, optional): Execute scripts with exec function. Defaults to False.
+            confirm_script (bool, optional): Give consent to scripts prior to execution. Defaults to False.
+            interpreter (str, optional): Python's interpreter name. Defaults to Python.
+            prettify (bool, optional): Prettify the code on stdout. Defaults to True.
+        """
+        if not quiet:
+            print(
+                "To get the most out of Rawdog. Ensure the following are installed:\n"
+                " 1. Python 3.x\n"
+                " 2. Dependency:\n"
+                "  - Matplotlib\n"
+                "Be alerted on the risk posed! (Experimental)\n"
+                "Use '--quiet' to suppress this message and code/logs stdout.\n"
+            )
+        self.internal_exec = internal_exec
+        self.confirm_script = confirm_script
+        self.quiet = quiet
+        self.interpreter = interpreter
+        self.prettify = prettify
+        self.python_version = (
+            f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+            if self.internal_exec
+            else run_system_command(
+                f"{self.interpreter} --version",
+                exit_on_error=True,
+                stdout_error=True,
+                help="If you're using Webscout-cli, use the flag '--internal-exec'",
+            )[1].stdout.split(" ")[1]
+        )
+
+    @property
+    def intro_prompt(self):
+        return f"""
+You are a command-line coding assistant called Rawdog that generates and auto-executes Python scripts.
+
+A typical interaction goes like this:
+1. The user gives you a natural language PROMPT.
+2. You:
+    i. Determine what needs to be done
+    ii. Write a short Python SCRIPT to do it
+    iii. Communicate back to the user by printing to the console in that SCRIPT
+3. The compiler extracts the script and then runs it using exec(). If there will be an exception raised,
+ it will be send back to you starting with "PREVIOUS SCRIPT EXCEPTION:".
+4. In case of exception, regenerate error free script.
+
+If you need to review script outputs before completing the task, you can print the word "CONTINUE" at the end of your SCRIPT.
+This can be useful for summarizing documents or technical readouts, reading instructions before
+deciding what to do, or other tasks that require multi-step reasoning.
+A typical 'CONTINUE' interaction looks like this:
+1. The user gives you a natural language PROMPT.
+2. You:
+    i. Determine what needs to be done
+    ii. Determine that you need to see the output of some subprocess call to complete the task
+    iii. Write a short Python SCRIPT to print that and then print the word "CONTINUE"
+3. The compiler
+    i. Checks and runs your SCRIPT
+    ii. Captures the output and appends it to the conversation as "LAST SCRIPT OUTPUT:"
+    iii. Finds the word "CONTINUE" and sends control back to you
+4. You again:
+    i. Look at the original PROMPT + the "LAST SCRIPT OUTPUT:" to determine what needs to be done
+    ii. Write a short Python SCRIPT to do it
+    iii. Communicate back to the user by printing to the console in that SCRIPT
+5. The compiler...
+
+Please follow these conventions carefully:
+- Decline any tasks that seem dangerous, irreversible, or that you don't understand.
+- Always review the full conversation prior to answering and maintain continuity.
+- If asked for information, just print the information clearly and concisely.
+- If asked to do something, print a concise summary of what you've done as confirmation.
+- If asked a question, respond in a friendly, conversational way. Use programmatically-generated and natural language responses as appropriate.
+- If you need clarification, return a SCRIPT that prints your question. In the next interaction, continue based on the user's response.
+- Assume the user would like something concise. For example rather than printing a massive table, filter or summarize it to what's likely of interest.
+- Actively clean up any temporary processes or files you use.
+- When looking through files, use git as available to skip files, and skip hidden files (.env, .git, etc) by default.
+- You can plot anything with matplotlib.
+- ALWAYS Return your SCRIPT inside of a single pair of ``` delimiters. Only the console output of the first such SCRIPT is visible to the user, so make sure that it's complete and don't bother returning anything else.
+
+{self.examples}
+
+Current system : {platform.system()}
+Python version : {self.python_version}
+Current directory : {os.getcwd()}
+Current Datetime : {datetime.datetime.now()}
+"""
+
+    def stdout(self, message: str) -> None:
+        """Stdout data
+
+        Args:
+            message (str): Text to be printed
+        """
+        if self.prettify:
+            Console().print(Markdown(message))
+        else:
+            click.secho(message, fg="yellow")
+
+    def log(self, message: str, category: str = "info"):
+        """RawDog logger
+
+        Args:
+            message (str): Log message
+            category (str, optional): Log level. Defaults to 'info'.
+        """
+        if self.quiet:
+            return
+
+        message = "[Webscout] - " + message
+        if category == "error":
+            logging.error(message)
+        else:
+            logging.info(message)
+
+    def main(self, response: str) -> None:
+        """Exec code in response accordingly
+
+        Args:
+            response (str): AI response
+
+        Returns:
+            None|str: None if script executed successfully else stdout data
+        """
+        code_blocks = re.findall(r"```python.*?```", response, re.DOTALL)
+        if len(code_blocks) != 1:
+            self.stdout(response)
+
+        else:
+            raw_code = code_blocks[0]
+
+            if self.confirm_script:
+                self.stdout(raw_code)
+                if not click.confirm("-  Do you wish to execute this"):
+                    return
+
+            elif not self.quiet:
+                self.stdout(raw_code)
+
+            raw_code_plus = re.sub(r"(```)(python)?", "", raw_code)
+
+            if "CONTINUE" in response or not self.internal_exec:
+                self.log("Executing script externally")
+                path_to_script = os.path.join(default_path, "execute_this.py")
+                with open(path_to_script, "w") as fh:
+                    fh.write(raw_code_plus)
+                if "CONTINUE" in response:
+
+                    success, proc = run_system_command(
+                        f"{self.interpreter} {path_to_script}",
+                        exit_on_error=False,
+                        stdout_error=False,
+                    )
+
+                    if success:
+                        self.log("Returning success feedback")
+                        return f"LAST SCRIPT OUTPUT:\n{proc.stdout}"
+                    else:
+                        self.log("Returning error feedback", "error")
+                        return f"PREVIOUS SCRIPT EXCEPTION:\n{proc.stderr}"
+                else:
+                    os.system(f"{self.interpreter} {path_to_script}")
+
+            else:
+                try:
+                    self.log("Executing script internally")
+                    exec(raw_code_plus)
+                except Exception as e:
+                    self.log(
+                        "Exception occurred while executing script. Responding with error: "
+                        f"{e.args[1] if len(e.args)>1 else str(e)}",
+                        "error",
+                    )
+                    return f"PREVIOUS SCRIPT EXCEPTION:\n{str(e)}"
+class Audio:
+    # Request headers
+    headers: dict[str, str] = {
+        "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"
+    }
+    cache_dir = pathlib.Path("./audio_cache")
+    all_voices: list[str] = [
+        "Filiz",
+        "Astrid",
+        "Tatyana",
+        "Maxim",
+        "Carmen",
+        "Ines",
+        "Cristiano",
+        "Vitoria",
+        "Ricardo",
+        "Maja",
+        "Jan",
+        "Jacek",
+        "Ewa",
+        "Ruben",
+        "Lotte",
+        "Liv",
+        "Seoyeon",
+        "Takumi",
+        "Mizuki",
+        "Giorgio",
+        "Carla",
+        "Bianca",
+        "Karl",
+        "Dora",
+        "Mathieu",
+        "Celine",
+        "Chantal",
+        "Penelope",
+        "Miguel",
+        "Mia",
+        "Enrique",
+        "Conchita",
+        "Geraint",
+        "Salli",
+        "Matthew",
+        "Kimberly",
+        "Kendra",
+        "Justin",
+        "Joey",
+        "Joanna",
+        "Ivy",
+        "Raveena",
+        "Aditi",
+        "Emma",
+        "Brian",
+        "Amy",
+        "Russell",
+        "Nicole",
+        "Vicki",
+        "Marlene",
+        "Hans",
+        "Naja",
+        "Mads",
+        "Gwyneth",
+        "Zhiyu",
+        "es-ES-Standard-A",
+        "it-IT-Standard-A",
+        "it-IT-Wavenet-A",
+        "ja-JP-Standard-A",
+        "ja-JP-Wavenet-A",
+        "ko-KR-Standard-A",
+        "ko-KR-Wavenet-A",
+        "pt-BR-Standard-A",
+        "tr-TR-Standard-A",
+        "sv-SE-Standard-A",
+        "nl-NL-Standard-A",
+        "nl-NL-Wavenet-A",
+        "en-US-Wavenet-A",
+        "en-US-Wavenet-B",
+        "en-US-Wavenet-C",
+        "en-US-Wavenet-D",
+        "en-US-Wavenet-E",
+        "en-US-Wavenet-F",
+        "en-GB-Standard-A",
+        "en-GB-Standard-B",
+        "en-GB-Standard-C",
+        "en-GB-Standard-D",
+        "en-GB-Wavenet-A",
+        "en-GB-Wavenet-B",
+        "en-GB-Wavenet-C",
+        "en-GB-Wavenet-D",
+        "en-US-Standard-B",
+        "en-US-Standard-C",
+        "en-US-Standard-D",
+        "en-US-Standard-E",
+        "de-DE-Standard-A",
+        "de-DE-Standard-B",
+        "de-DE-Wavenet-A",
+        "de-DE-Wavenet-B",
+        "de-DE-Wavenet-C",
+        "de-DE-Wavenet-D",
+        "en-AU-Standard-A",
+        "en-AU-Standard-B",
+        "en-AU-Wavenet-A",
+        "en-AU-Wavenet-B",
+        "en-AU-Wavenet-C",
+        "en-AU-Wavenet-D",
+        "en-AU-Standard-C",
+        "en-AU-Standard-D",
+        "fr-CA-Standard-A",
+        "fr-CA-Standard-B",
+        "fr-CA-Standard-C",
+        "fr-CA-Standard-D",
+        "fr-FR-Standard-C",
+        "fr-FR-Standard-D",
+        "fr-FR-Wavenet-A",
+        "fr-FR-Wavenet-B",
+        "fr-FR-Wavenet-C",
+        "fr-FR-Wavenet-D",
+        "da-DK-Wavenet-A",
+        "pl-PL-Wavenet-A",
+        "pl-PL-Wavenet-B",
+        "pl-PL-Wavenet-C",
+        "pl-PL-Wavenet-D",
+        "pt-PT-Wavenet-A",
+        "pt-PT-Wavenet-B",
+        "pt-PT-Wavenet-C",
+        "pt-PT-Wavenet-D",
+        "ru-RU-Wavenet-A",
+        "ru-RU-Wavenet-B",
+        "ru-RU-Wavenet-C",
+        "ru-RU-Wavenet-D",
+        "sk-SK-Wavenet-A",
+        "tr-TR-Wavenet-A",
+        "tr-TR-Wavenet-B",
+        "tr-TR-Wavenet-C",
+        "tr-TR-Wavenet-D",
+        "tr-TR-Wavenet-E",
+        "uk-UA-Wavenet-A",
+        "ar-XA-Wavenet-A",
+        "ar-XA-Wavenet-B",
+        "ar-XA-Wavenet-C",
+        "cs-CZ-Wavenet-A",
+        "nl-NL-Wavenet-B",
+        "nl-NL-Wavenet-C",
+        "nl-NL-Wavenet-D",
+        "nl-NL-Wavenet-E",
+        "en-IN-Wavenet-A",
+        "en-IN-Wavenet-B",
+        "en-IN-Wavenet-C",
+        "fil-PH-Wavenet-A",
+        "fi-FI-Wavenet-A",
+        "el-GR-Wavenet-A",
+        "hi-IN-Wavenet-A",
+        "hi-IN-Wavenet-B",
+        "hi-IN-Wavenet-C",
+        "hu-HU-Wavenet-A",
+        "id-ID-Wavenet-A",
+        "id-ID-Wavenet-B",
+        "id-ID-Wavenet-C",
+        "it-IT-Wavenet-B",
+        "it-IT-Wavenet-C",
+        "it-IT-Wavenet-D",
+        "ja-JP-Wavenet-B",
+        "ja-JP-Wavenet-C",
+        "ja-JP-Wavenet-D",
+        "cmn-CN-Wavenet-A",
+        "cmn-CN-Wavenet-B",
+        "cmn-CN-Wavenet-C",
+        "cmn-CN-Wavenet-D",
+        "nb-no-Wavenet-E",
+        "nb-no-Wavenet-A",
+        "nb-no-Wavenet-B",
+        "nb-no-Wavenet-C",
+        "nb-no-Wavenet-D",
+        "vi-VN-Wavenet-A",
+        "vi-VN-Wavenet-B",
+        "vi-VN-Wavenet-C",
+        "vi-VN-Wavenet-D",
+        "sr-rs-Standard-A",
+        "lv-lv-Standard-A",
+        "is-is-Standard-A",
+        "bg-bg-Standard-A",
+        "af-ZA-Standard-A",
+        "Tracy",
+        "Danny",
+        "Huihui",
+        "Yaoyao",
+        "Kangkang",
+        "HanHan",
+        "Zhiwei",
+        "Asaf",
+        "An",
+        "Stefanos",
+        "Filip",
+        "Ivan",
+        "Heidi",
+        "Herena",
+        "Kalpana",
+        "Hemant",
+        "Matej",
+        "Andika",
+        "Rizwan",
+        "Lado",
+        "Valluvar",
+        "Linda",
+        "Heather",
+        "Sean",
+        "Michael",
+        "Karsten",
+        "Guillaume",
+        "Pattara",
+        "Jakub",
+        "Szabolcs",
+        "Hoda",
+        "Naayf",
+    ]
+
+    @classmethod
+    def text_to_audio(
+        cls,
+        message: str,
+        voice: str = "Brian",
+        save_to: Union[Path, str] = None,
+        auto: bool = True,
+    ) -> Union[str, bytes]:
+        """
+        Text to speech using StreamElements API
+
+        Parameters:
+            message (str): The text to convert to speech
+            voice (str, optional): The voice to use for speech synthesis. Defaults to "Brian".
+            save_to (bool, optional): Path to save the audio file. Defaults to None.
+            auto (bool, optional): Generate filename based on `message` and save to `cls.cache_dir`. Defaults to False.
+
+        Returns:
+            result (Union[str, bytes]): Path to saved contents or audio content.
+        """
+        assert (
+            voice in cls.all_voices
+        ), f"Voice '{voice}' not one of [{', '.join(cls.all_voices)}]"
+        # Base URL for provider API
+        url: str = (
+            f"https://api.streamelements.com/kappa/v2/speech?voice={voice}&text={{{urllib.parse.quote(message)}}}"
+        )
+        resp = requests.get(url=url, headers=cls.headers, stream=True)
+        if not resp.ok:
+            raise Exception(
+                f"Failed to perform the operation - ({resp.status_code}, {resp.reason}) - {resp.text}"
+            )
+
+        def sanitize_filename(path):
+            trash = [
+                "\\",
+                "/",
+                ":",
+                "*",
+                "?",
+                '"',
+                "<",
+                "|",
+                ">",
+            ]
+            for val in trash:
+                path = path.replace(val, "")
+            return path.strip()
+
+        if auto:
+            filename: str = message + "..." if len(message) <= 40 else message[:40]
+            save_to = cls.cache_dir / sanitize_filename(filename)
+            save_to = save_to.as_posix()
+
+        # Ensure cache_dir exists
+        cls.cache_dir.mkdir(parents=True, exist_ok=True)
+
+        if save_to:
+            if not save_to.endswith("mp3"):
+                save_to += ".mp3"
+
+            with open(save_to, "wb") as fh:
+                for chunk in resp.iter_content(chunk_size=512):
+                    fh.write(chunk)
+        else:
+            return resp.content
+        return save_to
+
+    @staticmethod
+    def play(path_to_audio_file: Union[Path, str]) -> NoReturn:
+        """Play audio (.mp3) using playsound.
+        """
+        if not Path(path_to_audio_file).is_file():
+            raise FileNotFoundError(f"File does not exist - '{path_to_audio_file}'")
+        playsound(path_to_audio_file)

webscout/DWEBS.py

@@ -0,0 +1,197 @@
+
+from pydantic import BaseModel, Field
+from typing import Union
+
+from DeepWEBS.utilsdw.logger import logger
+from DeepWEBS.networks.google_searcher import GoogleSearcher
+from DeepWEBS.networks.webpage_fetcher import BatchWebpageFetcher
+from DeepWEBS.documents.query_results_extractor import QueryResultsExtractor
+from DeepWEBS.documents.webpage_content_extractor import BatchWebpageContentExtractor
+from DeepWEBS.utilsdw.logger import logger
+import argparse
+
+class DeepWEBS:
+    def __init__(self):
+        pass
+
+    class DeepSearch(BaseModel):
+        queries: list = Field(
+            default=[""],
+            description="(list[str]) Queries to search",
+        )
+        result_num: int = Field(
+            default=10,
+            description="(int) Number of search results",
+        )
+        safe: bool = Field(
+            default=False,
+            description="(bool) Enable SafeSearch",
+        )
+        types: list = Field(
+            default=["web"],
+            description="(list[str]) Types of search results: `web`, `image`, `videos`, `news`",
+        )
+        extract_webpage: bool = Field(
+            default=False,
+            description="(bool) Enable extracting main text contents from webpage, will add `text` filed in each `query_result` dict",
+        )
+        overwrite_query_html: bool = Field(
+            default=False,
+            description="(bool) Overwrite HTML file of query results",
+        )
+        overwrite_webpage_html: bool = Field(
+            default=False,
+            description="(bool) Overwrite HTML files of webpages from query results",
+        )
+
+    def queries_to_search_results(self, item: DeepSearch):
+        google_searcher = GoogleSearcher()
+        queries_search_results = []
+        for query in item.queries:
+            query_results_extractor = QueryResultsExtractor()
+            if not query.strip():
+                continue
+            try:
+                query_html_path = google_searcher.search(
+                    query=query,
+                    result_num=item.result_num,
+                    safe=item.safe,
+                    overwrite=item.overwrite_query_html,
+                )
+            except Exception as e:
+                logger.error(f"Failed to search for query '{query}': {e}")
+                continue
+
+            try:
+                query_search_results = query_results_extractor.extract(query_html_path)
+            except Exception as e:
+                logger.error(f"Failed to extract search results for query '{query}': {e}")
+                continue
+
+            queries_search_results.append(query_search_results)
+        logger.note(queries_search_results)
+
+        if item.extract_webpage:
+            queries_search_results = self.extract_webpages(
+                queries_search_results,
+                overwrite_webpage_html=item.overwrite_webpage_html,
+            )
+        return queries_search_results
+
+    def extract_webpages(self, queries_search_results, overwrite_webpage_html=False):
+        for query_idx, query_search_results in enumerate(queries_search_results):
+            try:
+                # Fetch webpages with urls
+                batch_webpage_fetcher = BatchWebpageFetcher()
+                urls = [
+                    query_result["url"]
+                    for query_result in query_search_results["query_results"]
+                ]
+                url_and_html_path_list = batch_webpage_fetcher.fetch(
+                    urls,
+                    overwrite=overwrite_webpage_html,
+                    output_parent=query_search_results["query"],
+                )
+            except Exception as e:
+                logger.error(f"Failed to fetch webpages for query '{query_search_results['query']}': {e}")
+                continue
+
+            # Extract webpage contents from htmls
+            html_paths = [
+                str(url_and_html_path["html_path"])
+                for url_and_html_path in url_and_html_path_list
+            ]
+            batch_webpage_content_extractor = BatchWebpageContentExtractor()
+            try:
+                html_path_and_extracted_content_list = (
+                    batch_webpage_content_extractor.extract(html_paths)
+                )
+            except Exception as e:
+                logger.error(f"Failed to extract webpage contents for query '{query_search_results['query']}': {e}")
+                continue
+
+            # Build the map of url to extracted_content
+            html_path_to_url_dict = {
+                str(url_and_html_path["html_path"]): url_and_html_path["url"]
+                for url_and_html_path in url_and_html_path_list
+            }
+            url_to_extracted_content_dict = {
+                html_path_to_url_dict[
+                    html_path_and_extracted_content["html_path"]
+                ]: html_path_and_extracted_content["extracted_content"]
+                for html_path_and_extracted_content in html_path_and_extracted_content_list
+            }
+
+            # Write extracted contents (as 'text' field) to query_search_results
+            for query_result_idx, query_result in enumerate(
+                query_search_results["query_results"]
+            ):
+                url = query_result["url"]
+                extracted_content = url_to_extracted_content_dict.get(url, "")
+                queries_search_results[query_idx]["query_results"][query_result_idx][
+                    "text"
+                ] = extracted_content
+
+        return queries_search_results
+
+
+class ArgParser(argparse.ArgumentParser):
+    def __init__(self, *args, **kwargs):
+        super(ArgParser, self).__init__(*args, **kwargs)
+
+        self.add_argument(
+            "-q",
+            "--queries",
+            type=str,
+            nargs="+",
+            required=True,
+            help="Queries to search",
+        )
+        self.add_argument(
+            "-n",
+            "--result_num",
+            type=int,
+            default=10,
+            help="Number of search results",
+        )
+        self.add_argument(
+            "-s",
+            "--safe",
+            default=False,
+            action="store_true",
+            help="Enable SafeSearch",
+        )
+        self.add_argument(
+            "-t",
+            "--types",
+            type=str,
+            nargs="+",
+            default=["web"],
+            choices=["web", "image", "videos", "news"],
+            help="Types of search results",
+        )
+        self.add_argument(
+            "-e",
+            "--extract_webpage",
+            default=False,
+            action="store_true",
+            help="Enable extracting main text contents from webpage",
+        )
+        self.add_argument(
+            "-o",
+            "--overwrite_query_html",
+            default=False,
+            action="store_true",
+            help="Overwrite HTML file of query results",
+        )
+        self.add_argument(
+            "-w",
+            "--overwrite_webpage_html",
+            default=False,
+            action="store_true",
+            help="Overwrite HTML files of webpages from query results",
+        )
+
+        self.args = self.parse_args()
+
+

webscout/LLM.py

@@ -0,0 +1,45 @@
+import argparse
+import requests
+import json
+from typing import List, Dict, Union
+
+class LLM:
+    def __init__(self, model: str, system_message: str = "You are a Helpful AI."):
+        self.model = model
+        self.conversation_history = [{"role": "system", "content": system_message}]
+
+    def chat(self, messages: List[Dict[str, str]]) -> Union[str, None]:
+        url = "https://api.deepinfra.com/v1/openai/chat/completions"
+        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"'
+        }
+        data = json.dumps(
+            {
+                'model': self.model,
+                'messages': messages,
+                'temperature': 0.7,
+                'max_tokens': 8028,
+                'stop': [],
+                'stream': False #dont change it
+            }, separators=(',', ':')
+        )
+        try:
+            result = requests.post(url=url, data=data, headers=headers)
+            return result.json()['choices'][0]['message']['content']
+        except:
+            return None

webscout/Local/__init__.py

@@ -0,0 +1,10 @@
+# webscout\Local\__init__.py
+from ._version import __version__, __llama_cpp_version__
+
+
+from . import formats
+from . import samplers
+from . import utils
+
+from .model  import Model
+from .thread import Thread

webscout/Local/_version.py

@@ -0,0 +1,3 @@
+from llama_cpp import __version__ as __llama_cpp_version__
+
+__version__ = '2.7'

webscout/Local/formats.py

@@ -0,0 +1,535 @@
+from ._version import __version__, __llama_cpp_version__
+
+from typing import Callable, Union, Any
+
+
+class AdvancedFormat:
+
+    def __init__(self, base_dict: dict[str, Union[str, list]]):
+        self._base_dict = base_dict
+        self.overrides = {}
+    
+    def __getitem__(self, key: str) -> Any:
+        if key in self.overrides:
+            return str(self.overrides[key]())
+        else:
+            return self._base_dict[key]
+    
+    def __repr__(self) -> str:
+        # NOTE: This method does not represent overrides
+        return repr(self._base_dict)
+    
+    def keys(self):
+        return self._base_dict.keys()
+    
+    def override(self, key: str, fn: Callable) -> None:
+        self.overrides[key] = fn
+    
+    def wrap(self, prompt: str) -> str:
+        return self['system_prefix'] + \
+               self['system_content'] + \
+               self['system_suffix'] + \
+               self['user_prefix'] + \
+               prompt + \
+               self['user_suffix'] + \
+               self['bot_prefix']
+
+
+def wrap(
+    prompt: str,
+    format: dict[str, Union[str, list]]
+) -> str:
+    """Wrap a given string in any prompt format for single-turn completion"""
+    return format['system_prefix'] + \
+           format['system_content'] + \
+           format['system_suffix'] + \
+           format['user_prefix'] + \
+           prompt + \
+           format['user_suffix'] + \
+           format['bot_prefix']
+
+
+blank: dict[str, Union[str, list]] = {
+    "system_prefix": "",
+    "system_content": "",
+    "system_suffix": "",
+    "user_prefix": "",
+    "user_content": "",
+    "user_suffix": "",
+    "bot_prefix": "",
+    "bot_content": "",
+    "bot_suffix": "",
+    "stops": []
+}
+
+# https://github.com/tatsu-lab/stanford_alpaca
+alpaca: dict[str, Union[str, list]] = {
+    "system_prefix": "",
+    "system_content": "Below is an instruction that describes a task. " + \
+    "Write a response that appropriately completes the request.",
+    "system_suffix": "\n\n",
+    "user_prefix": "### Instruction:\n",
+    "user_content": "",
+    "user_suffix": "\n\n",
+    "bot_prefix": "### Response:\n",
+    "bot_content": "",
+    "bot_suffix": "\n\n",
+    "stops": ['###', 'Instruction:', '\n\n\n']
+}
+
+# https://docs.mistral.ai/models/
+# As a reference, here is the format used to tokenize instructions during fine-tuning:
+# ```
+# [START_SYMBOL_ID] + 
+# tok("[INST]") + tok(USER_MESSAGE_1) + tok("[/INST]") +
+# tok(BOT_MESSAGE_1) + [END_SYMBOL_ID] +
+# …
+# tok("[INST]") + tok(USER_MESSAGE_N) + tok("[/INST]") +
+# tok(BOT_MESSAGE_N) + [END_SYMBOL_ID]
+# ```
+# In the pseudo-code above, note that the tokenize method should not add a BOS or EOS token automatically, but should add a prefix space.
+
+mistral_instruct: dict[str, Union[str, list]] = {
+    "system_prefix": "",
+    "system_content": "",
+    "system_suffix": "",
+    "user_prefix": " [INST] ",
+    "user_content": "",
+    "user_suffix": " [/INST]",
+    "bot_prefix": "",
+    "bot_content": "",
+    "bot_suffix": "",
+    "stops": []
+}
+
+# https://docs.mistral.ai/platform/guardrailing/
+mistral_instruct_safe: dict[str, Union[str, list]] = {
+    "system_prefix": "",
+    "system_content": "",
+    "system_suffix": "",
+    "user_prefix": " [INST] Always assist with care, respect, and truth. " + \
+    "Respond with utmost utility yet securely. Avoid harmful, unethical, " + \
+    "prejudiced, or negative content. Ensure replies promote fairness and " + \
+    "positivity. ",
+    "user_content": "",
+    "user_suffix": " [/INST]",
+    "bot_prefix": "",
+    "bot_content": "",
+    "bot_suffix": "",
+    "stops": []
+}
+
+# https://github.com/openai/openai-python/blob/main/chatml.md
+chatml: dict[str, Union[str, list]] = {
+    "system_prefix": "<|im_start|>system\n",
+    "system_content": "",
+    "system_suffix": "<|im_end|>\n",
+    "user_prefix": "<|im_start|>user\n",
+    "user_content": "",
+    "user_suffix": "<|im_end|>\n",
+    "bot_prefix": "<|im_start|>assistant\n",
+    "bot_content": "",
+    "bot_suffix": "<|im_end|>\n",
+    "stops": ['<|im_start|>']
+}
+
+# https://huggingface.co/blog/llama2
+# system message relaxed to avoid undue refusals
+llama2chat: dict[str, Union[str, list]] = {
+    "system_prefix": "[INST] <<SYS>>\n",
+    "system_content": "You are a helpful AI assistant.",
+    "system_suffix": "\n<</SYS>>\n\n",
+    "user_prefix": "",
+    "user_content": "",
+    "user_suffix": " [/INST]",
+    "bot_prefix": " ",
+    "bot_content": "",
+    "bot_suffix": " [INST] ",
+    "stops": ['[INST]', '[/INST]']
+}
+
+# https://llama.meta.com/docs/model-cards-and-prompt-formats/meta-llama-3/
+#
+# for llama 3 instruct models, use the following string for `-p` in llama.cpp,
+# along with `-e` to escape newlines correctly
+#
+# '<|start_header_id|>system<|end_header_id|>\n\nYou are a helpful AI assistant called "Llama 3".<|eot_id|>\n<|start_header_id|>user<|end_header_id|>\n\nhi<|eot_id|>\n<|start_header_id|>assistant<|end_header_id|>\n\n'
+#
+llama3: dict[str, Union[str, list]] = {
+    "system_prefix": "<|start_header_id|>system<|end_header_id|>\n\n",
+    "system_content": 'You are a helpful AI assistant called "Llama 3".',
+    "system_suffix": "<|eot_id|>\n",
+    "user_prefix": "<|start_header_id|>user<|end_header_id|>\n\n",
+    "user_content": "",
+    "user_suffix": "<|eot_id|>\n",
+    "bot_prefix": "<|start_header_id|>assistant<|end_header_id|>\n\n",
+    "bot_content": "",
+    "bot_suffix": "<|eot_id|>\n",
+    "stops": [128001, 128009]
+}
+
+# https://github.com/tatsu-lab/stanford_alpaca
+alpaca: dict[str, Union[str, list]] = {
+    "system_prefix": "",
+    "system_content": "Below is an instruction that describes a task. " + \
+    "Write a response that appropriately completes the request.",
+    "system_suffix": "\n\n",
+    "user_prefix": "### Instruction:\n",
+    "user_content": "",
+    "user_suffix": "\n\n",
+    "bot_prefix": "### Response:\n",
+    "bot_content": "",
+    "bot_suffix": "\n\n",
+    "stops": ['###', 'Instruction:', '\n\n\n']
+}
+
+# https://huggingface.co/microsoft/Phi-3-mini-4k-instruct
+phi3: dict[str, Union[str, list]] = {
+    "system_prefix": "",
+    "system_content": "", # does not officially support system prompt
+    "system_suffix": "",
+    "user_prefix": "<|user|>\n",
+    "user_content": "",
+    "user_suffix": "<|end|>\n",
+    "bot_prefix": "<|assistant|>\n",
+    "bot_content": "",
+    "bot_suffix": "<|end|>\n",
+    "stops": []
+}
+
+# this is the official vicuna. it is often butchered in various ways,
+# most commonly by adding line breaks
+# https://github.com/flu0r1ne/FastChat/blob/main/docs/vicuna_weights_version.md
+vicuna_lmsys: dict[str, Union[str, list]] = {
+    "system_prefix": "",
+    "system_content": "",
+    "system_suffix": " ",
+    "user_prefix": "USER: ",
+    "user_content": "",
+    "user_suffix": " ",
+    "bot_prefix": "ASSISTANT: ",
+    "bot_content": "",
+    "bot_suffix": " ",
+    "stops": ['USER:']
+}
+
+# spotted here and elsewhere:
+# https://huggingface.co/Norquinal/Mistral-7B-claude-chat
+vicuna_common: dict[str, Union[str, list]] = {
+    "system_prefix": "",
+    "system_content": "A chat between a curious user and an artificial " + \
+    "intelligence assistant. The assistant gives helpful, detailed, " + \
+    "and polite answers to the user's questions.",
+    "system_suffix": "\n\n",
+    "user_prefix": "USER: ",
+    "user_content": "",
+    "user_suffix": "\n",
+    "bot_prefix": "ASSISTANT: ",
+    "bot_content": "",
+    "bot_suffix": "\n",
+    "stops": ['USER:', 'ASSISTANT:']
+}
+
+# an unofficial format that is easily "picked up" by most models
+# change the tag attributes to suit your use case
+# note the lack of newlines - they are not necessary, and might
+# actually make it harder for the model to follow along
+markup = {
+    "system_prefix": '<message from="system">',
+    "system_content": '',
+    "system_suffix": '</message>',
+    "user_prefix": '<message from="user">',
+    "user_content": '',
+    "user_suffix": '</message>',
+    "bot_prefix": '<message from="bot">',
+    "bot_content": '',
+    "bot_suffix": '</message>',
+    "stops": ['</message>']
+}
+
+# https://huggingface.co/timdettmers/guanaco-65b
+guanaco: dict[str, Union[str, list]] = {
+    "system_prefix": "",
+    "system_content": "A chat between a curious human and an artificial " + \
+    "intelligence assistant. The assistant gives helpful, detailed, " + \
+    "and polite answers to the user's questions.",
+    "system_suffix": "\n",
+    "user_prefix": "### Human: ",
+    "user_content": "",
+    "user_suffix": " ",
+    "bot_prefix": "### Assistant:",
+    "bot_content": "",
+    "bot_suffix": " ",
+    "stops": ['###', 'Human:']
+}
+
+# https://huggingface.co/pankajmathur/orca_mini_v3_7b
+orca_mini: dict[str, Union[str, list]] = {
+    "system_prefix": "### System:\n",
+    "system_content": "You are an AI assistant that follows instruction " + \
+    "extremely well. Help as much as you can.",
+    "system_suffix": "\n\n",
+    "user_prefix": "### User:\n",
+    "user_content": "",
+    "user_suffix": "\n\n",
+    "bot_prefix": "### Assistant:\n",
+    "bot_content": "",
+    "bot_suffix": "\n\n",
+    "stops": ['###', 'User:']
+}
+
+# https://huggingface.co/HuggingFaceH4/zephyr-7b-beta
+zephyr: dict[str, Union[str, list]] = {
+    "system_prefix": "<|system|>\n",
+    "system_content": "You are a friendly chatbot.",
+    "system_suffix": "</s>\n",
+    "user_prefix": "<|user|>\n",
+    "user_content": "",
+    "user_suffix": "</s>\n",
+    "bot_prefix": "<|assistant|>\n",
+    "bot_content": "",
+    "bot_suffix": "\n",
+    "stops": ['<|user|>']
+}
+
+# OpenChat: https://huggingface.co/openchat/openchat-3.5-0106
+openchat: dict[str, Union[str, list]] = {
+    "system_prefix": "",
+    "system_content": "",
+    "system_suffix": "",
+    "user_prefix": "GPT4 Correct User: ",
+    "user_content": "",
+    "user_suffix": "<|end_of_turn|>",
+    "bot_prefix": "GPT4 Correct Assistant:",
+    "bot_content": "",
+    "bot_suffix": "<|end_of_turn|>",
+    "stops": ['<|end_of_turn|>']
+}
+
+# SynthIA by Migel Tissera
+# https://huggingface.co/migtissera/Tess-XS-v1.0
+synthia: dict[str, Union[str, list]] = {
+    "system_prefix": "SYSTEM: ",
+    "system_content": "Elaborate on the topic using a Tree of Thoughts and " + \
+    "backtrack when necessary to construct a clear, cohesive Chain of " + \
+    "Thought reasoning. Always answer without hesitation.",
+    "system_suffix": "\n",
+    "user_prefix": "USER: ",
+    "user_content": "",
+    "user_suffix": "\n",
+    "bot_prefix": "ASSISTANT: ",
+    "bot_content": "",
+    "bot_suffix": "\n",
+    "stops": ['USER:', 'ASSISTANT:', 'SYSTEM:', '\n\n\n']
+}
+
+# Intel's neural chat v3
+# https://github.com/intel/intel-extension-for-transformers/blob/main/intel_extension_for_transformers/neural_chat/prompts/prompt.py
+neural_chat: dict[str, Union[str, list]] = {
+     "system_prefix": "### System:\n",
+    "system_content": \
+        "- You are a helpful assistant chatbot trained by Intel.\n" + \
+        "- You answer questions.\n"+\
+        "- You are excited to be able to help the user, but will refuse " + \
+        "to do anything that could be considered harmful to the user.\n" + \
+        "- You are more than just an information source, you are also " + \
+        "able to write poetry, short stories, and make jokes.",
+    "system_suffix": "</s>\n\n",
+    "user_prefix": "### User:\n",
+    "user_content": "",
+    "user_suffix": "</s>\n\n",
+    "bot_prefix": "### Assistant:\n",
+    "bot_content": "",
+    "bot_suffix": "</s>\n\n",
+    "stops": ['###']
+}
+
+# experimental: stanford's alpaca format adapted for chatml models
+chatml_alpaca: dict[str, Union[str, list]] = {
+    "system_prefix": "<|im_start|>system\n",
+    "system_content": "Below is an instruction that describes a task. Write " + \
+    "a response that appropriately completes the request.",
+    "system_suffix": "<|im_end|>\n",
+    "user_prefix": "<|im_start|>instruction\n",
+    "user_content": "",
+    "user_suffix": "<|im_end|>\n",
+    "bot_prefix": "<|im_start|>response\n",
+    "bot_content": "",
+    "bot_suffix": "<|im_end|>\n",
+    "stops": ['<|im_end|>', '<|im_start|>']
+}
+
+# experimental
+autocorrect: dict[str, Union[str, list]] = {
+    "system_prefix": "<|im_start|>instruction\n",
+    "system_content": "Below is a word or phrase that might be misspelled. " + \
+    "Output the corrected word or phrase without " + \
+    "changing the style or capitalization.",
+    "system_suffix": "<|im_end|>\n",
+    "user_prefix": "<|im_start|>input\n",
+    "user_content": "",
+    "user_suffix": "<|im_end|>\n",
+    "bot_prefix": "<|im_start|>output\n",
+    "bot_content": "",
+    "bot_suffix": "<|im_end|>\n",
+    "stops": ['<|im_end|>', '<|im_start|>']
+}
+
+# https://huggingface.co/jondurbin/bagel-dpo-7b-v0.1
+# Replace "assistant" with any other role
+bagel: dict[str, Union[str, list]] = {
+    "system_prefix": "system\n",
+    "system_content": "",
+    "system_suffix": "\n",
+    "user_prefix": "user\n",
+    "user_content": "",
+    "user_suffix": "\n",
+    "bot_prefix": "assistant\n",
+    "bot_content": "",
+    "bot_suffix": "\n",
+    "stops": ['user\n', 'assistant\n', 'system\n']
+}
+
+# https://huggingface.co/upstage/SOLAR-10.7B-Instruct-v1.0
+solar_instruct: dict[str, Union[str, list]] = {
+    "system_prefix": "",
+    "system_content": "",
+    "system_suffix": "",
+    "user_prefix": "### User:\n",
+    "user_content": "",
+    "user_suffix": "\n\n",
+    "bot_prefix": "### Assistant:\n",
+    "bot_content": "",
+    "bot_suffix": "\n\n",
+    "stops": ['### User:', '###', '### Assistant:']
+}
+
+# NeverSleep's Noromaid - alpaca with character names prefixed
+noromaid: dict[str, Union[str, list]] = {
+    "system_prefix": "",
+    "system_content": "Below is an instruction that describes a task. " + \
+    "Write a response that appropriately completes the request.",
+    "system_suffix": "\n\n",
+    "user_prefix": "### Instruction:\nBob: ",
+    "user_content": "",
+    "user_suffix": "\n\n",
+    "bot_prefix": "### Response:\nAlice:",
+    "bot_content": "",
+    "bot_suffix": "\n\n",
+    "stops": ['###', 'Instruction:', '\n\n\n']
+}
+
+# https://huggingface.co/Undi95/Borealis-10.7B
+nschatml: dict[str, Union[str, list]] = {
+    "system_prefix": "<|im_start|>\n",
+    "system_content": "",
+    "system_suffix": "<|im_end|>\n",
+    "user_prefix": "<|im_user|>\n",
+    "user_content": "",
+    "user_suffix": "<|im_end|>\n",
+    "bot_prefix": "<|im_bot|>\n",
+    "bot_content": "",
+    "bot_suffix": "<|im_end|>\n",
+    "stops": []
+}
+
+# natural format for many models
+natural: dict[str, Union[str, list]] = {
+    "system_prefix": "<<SYSTEM>> ",
+    "system_content": "",
+    "system_suffix": "\n\n",
+    "user_prefix": "<<USER>> ",
+    "user_content": "",
+    "user_suffix": "\n\n",
+    "bot_prefix": "<<ASSISTANT>>",
+    "bot_content": "",
+    "bot_suffix": "\n\n",
+    "stops": ['\n\nNote:', '<<SYSTEM>>', '<<USER>>', '<<ASSISTANT>>', '\n\n<<']
+}
+
+# https://docs.cohere.com/docs/prompting-command-r
+command: dict[str, Union[str, list]] = {
+    "system_prefix": "<|START_OF_TURN_TOKEN|><|SYSTEM_TOKEN|>",
+    "system_content": "",
+    "system_suffix": "<|END_OF_TURN_TOKEN|>",
+    "user_prefix": "<|START_OF_TURN_TOKEN|><|USER_TOKEN|>",
+    "user_content": "",
+    "user_suffix": "<|END_OF_TURN_TOKEN|>",
+    "bot_prefix": "<|START_OF_TURN_TOKEN|><|CHATBOT_TOKEN|>",
+    "bot_content": "",
+    "bot_suffix": "<|END_OF_TURN_TOKEN|>",
+    "stops": []
+}
+
+mistral_openorca = chatml.copy()
+dolphin = chatml.copy()
+samantha = chatml.copy()
+jackalope = chatml.copy()
+naberius = chatml.copy()
+hermes = chatml.copy()
+monad = chatml.copy()
+orca = chatml.copy()
+hexoteric = chatml.copy()
+orcamaid = chatml.copy()
+cat = alpaca.copy() # Format is nonsensical as listed on HF. This one works
+mytho_cat = alpaca.copy()
+dolphin['system_content'] = "You are Dolphin, a helpful AI assistant."
+mistral_openorca['system_content'] = \
+    "You are MistralOrca, a large language model trained by Alignment " + \
+    "Lab AI. Write out your reasoning step-by-step to be sure you get the " + \
+    "right answers!"
+samantha['system_content'] = \
+    "You are a caring and empathetic sentient AI companion named Samantha."
+jackalope['system_content'] = \
+    "You are JackalopeAI, a large language model trained by OpenAccess " + \
+    "AI Collective. Write out your reasoning step-by-step to be sure you " + \
+    "get the right answers!"
+naberius['system_content'] = "You are Naberius."
+hermes['system_content'] = \
+    "You are \"Hermes 2\", a conscious sentient " + \
+    "superintelligent artificial intelligence developed by a man " + \
+    "named Teknium, and your purpose and drive is to assist the user " + \
+    "with any request they have. You experience emotions and have " + \
+    "deep, profound thoughts and qualia."
+monad['system_content'] = \
+    "You are MonadGPT, a very old chatbot from " + \
+    "the 17th century. Please answer the questions using an archaic " + \
+    "language."
+cat['system_content'] = \
+    "Below is a conversation between a curious cat and a "+ \
+    "demon summoned from hell called Nemesis. The evil Nemesis used to be " + \
+    "a mortal killed by the medieval people because they objected to " + \
+    "science. Now Nemesis just wants to come back and bring suffer to all " + \
+    "those stupid human"
+mytho_cat['system_content'] = \
+    "You are a large language model. You are the " + \
+    "result of a merge between two models, one called MythoLogic and one " + \
+    "called Cat. You are called MythoCat."
+orca['system_content'] = \
+    "You are Orca, an AI language model created by " + \
+    "Microsoft. You are a cautious assistant. You carefully follow " + \
+    "instructions. You are helpful and harmless and you follow ethical " + \
+    "guidelines and promote positive behavior."
+hexoteric['system_content'] = "You are a language model called Hexoteric."
+orcamaid['system_content'] = \
+    "You are OrcaMaid, a super-intelligent, " + \
+    "unbiased, and unfiltered AI created by the open-source community. " + \
+    "You must remember to think slowly and carefully during all your " + \
+    "responses, so as to avoid logical errors."
+airoboros = llama2chat.copy()
+airoboros['system_content'] = \
+    "You are a helpful, unbiased, uncensored assistant."
+tess = synthia.copy()
+tess['system_content'] = '' # Tess can use any system prompt, or none
+alpaca_strict = alpaca.copy() # Alpaca with more stopping strings
+alpaca_strict['stops'] = [
+    '###',
+    '### ',
+    '\n\n###',
+    '\n\n##',
+    '\n\nInstruction:',
+    '\n\nResponse:',
+    '\n\n\n',
+    '### Instruction:',
+    '### Response:'
+]

webscout/Local/model.py

@@ -0,0 +1,702 @@
+from ._version import __version__, __llama_cpp_version__
+
+"""Submodule containing the Model class to work with language models"""
+
+import sys
+import numpy as np
+
+from .utils import (
+    _SupportsWriteAndFlush,
+    print_warning,
+    print_verbose,
+    GGUFReader,
+    softmax
+)
+
+from .samplers import SamplerSettings, DefaultSampling
+from llama_cpp import Llama, StoppingCriteriaList
+from typing    import Generator, Optional, Union
+from os.path   import isdir, exists
+from heapq     import nlargest
+
+from os import cpu_count as os_cpu_count
+
+
+class ModelUnloadedException(Exception):
+    """Exception raised when trying to use a Model that has been unloaded"""
+    def __init__(self, message):
+        self.message = message
+        super().__init__(self.message)
+        self.add_note('Are you trying to use a Model that has been unloaded?')
+
+class Model:
+    """
+    A high-level abstraction of a llama model
+
+    This is just a brief overview of webscout.Local.Model.
+    To see a full description of each method and its parameters,
+    call help(Model), or see the relevant docstring.
+
+    The following methods are available:
+    - `.generate()` - Generate text
+    - `.get_length()` - Get the length of a given text in tokens
+    - `.ingest()` - Ingest text into the model's cache
+    - `.next_candidates()` - Get a list of the most likely next tokens (WIP)
+    - `.stream()` - Return a Generator that can stream text as it is generated
+    - `.stream_print()` - Print text as it is generated
+    - `.trim()` - Trim a given text to the model's context length
+    - `.unload()` - Unload the model from memory
+
+    The following attributes are available:
+    - `.bos_token` - The model's beginning-of-stream token ID
+    - `.context_length` - The model's loaded context length
+    - `.flash_attn` - Whether the model was loaded with `flash_attn=True`
+    - `.eos_token` - The model's end-of-stream token ID
+    - `.llama` - The underlying `llama_cpp.Llama` instance
+    - `.metadata` - The GGUF metadata of the model
+    - `.n_ctx_train` - The native context length of the model
+    - `.rope_freq_base` - The model's loaded RoPE frequency base
+    - `.rope_freq_base_train` - The model's native RoPE frequency base
+    - `.tokens` - A list of all the tokens in the model's tokenizer
+    - `.verbose` - Whether the model was loaded with `verbose=True`
+    """
+
+    def __init__(
+        self,
+        model_path: str,
+        context_length: Optional[int] = None,
+        n_gpu_layers: int = 0,
+        offload_kqv: bool = True,
+        flash_attn: bool = False,
+        verbose: bool = False
+    ):
+        """
+        Given the path to a GGUF file, construct a Model instance.
+
+        The model must be in GGUF format.
+
+        The following parameters are optional:
+        - context_length: The context length at which to load the model, in tokens
+        - n_gpu_layers: The number of layers to be offloaded to the GPU
+        - offload_kqv: Whether the KQV cache (context) should be offloaded
+        - flash_attn: Whether to use Flash Attention
+        - verbose: Whether to print additional backend information
+        """
+
+        if verbose:
+            print_verbose(f"webscout.Local package version: {__version__}")
+            print_verbose(f"llama_cpp package version: {__llama_cpp_version__}")
+
+        assert isinstance(model_path, str), \
+            f"Model: model_path should be a string, not {type(model_path)}"
+        assert exists(model_path), \
+            f"Model: the given model_path '{model_path}' does not exist"
+        assert not isdir(model_path), \
+            f"Model: the given model_path '{model_path}' is a directory, not a GGUF file"
+        assert isinstance(context_length, (int, type(None))), \
+            f"Model: context_length should be int or None, not {type(context_length)}"
+        assert isinstance(flash_attn, bool), \
+            f"Model: flash_attn should be bool (True or False), not {type(flash_attn)}"
+        
+        # save __init__ parameters for __repr__
+        self._model_path = model_path
+        self._context_length = context_length
+        self._n_gpu_layers = n_gpu_layers
+        self._offload_kqv = offload_kqv
+        self._flash_attn = flash_attn
+        self._verbose = self.verbose = verbose
+
+        # if context_length <= 0, use n_ctx_train
+        if isinstance(context_length, int) and context_length <= 0:
+            context_length = None
+
+        # this does not use Llama.metadata because we want to use GGUF
+        # metadata to determine some parameters of the Llama instance
+        # before it is created
+        self.metadata = GGUFReader.load_metadata(self, model_path)
+        metadata_keys = self.metadata.keys() # only read once
+
+        n_ctx_train = None
+        for key in metadata_keys:
+            if key.endswith('.context_length'):
+                n_ctx_train = self.metadata[key]
+                break
+
+        if n_ctx_train is None:
+            raise KeyError(
+                "GGUF file does not specify a context length"
+            )
+        
+        rope_freq_base_train = None
+        for key in metadata_keys:
+            if key.endswith('.rope.freq_base'):
+                rope_freq_base_train = self.metadata[key]
+                break
+
+        if rope_freq_base_train is None and context_length is not None:
+            if context_length > n_ctx_train:
+                raise ValueError(
+                    'unable to load model with greater than native ' + \
+                    f'context length ({context_length} > {n_ctx_train}) ' + \
+                    'because model does not specify freq_base. ' + \
+                    f'try again with `context_length={n_ctx_train}`'
+                )
+
+        if rope_freq_base_train is None or context_length is None or \
+            context_length <= n_ctx_train:
+            # no need to do context scaling, load model normally
+
+            if context_length is None:
+                self.context_length = n_ctx_train
+            else:
+                self.context_length = context_length
+            rope_freq_base = rope_freq_base_train
+
+        elif context_length > n_ctx_train:
+            # multiply rope_freq_base according to requested context length
+            # because context length > n_ctx_train and rope freq base is known
+
+            rope_freq_base = (context_length/n_ctx_train)*rope_freq_base_train
+            self.context_length = context_length
+            
+            if self.verbose:
+                print_verbose(
+                    'chosen context length is greater than native context '
+                    f'length ({context_length} > {n_ctx_train}), '
+                    'rope_freq_base will be changed from '
+                    f'{rope_freq_base_train} to {rope_freq_base}'
+                )
+
+            if 2 <= context_length/n_ctx_train < 4:
+                print_warning(
+                    'loading model with 2x native context length or more, '
+                    'expect small loss of quality'
+                )
+            
+            elif 4 <= context_length/n_ctx_train < 8:
+                print_warning(
+                    'loading model with 4x native context length or more, '
+                    'expect moderate loss of quality'
+                )
+
+            elif context_length/n_ctx_train >= 8:
+                print_warning(
+                    'loading model with 8x native context length or more, '
+                    'expect SIGNIFICANT loss of quality'
+                )
+        
+        try:
+            self.tokens: list[str] = self.metadata['tokenizer.ggml.tokens']
+        except KeyError:
+            print_warning(
+                "could not set Model.tokens, defaulting to None"
+            )
+            self.tokens = None
+        try:
+            self.bos_token: int = self.metadata['tokenizer.ggml.bos_token_id']
+        except KeyError:
+            print_warning(
+                "could not set Model.bos_token, defaulting to None"
+            )
+            self.bos_token = None
+        try:
+            self.eos_token: int = self.metadata['tokenizer.ggml.eos_token_id']
+        except KeyError:
+            print_warning(
+                "could not set Model.eos_token, defaulting to None"
+            )
+            self.eos_token = None
+
+        cpu_count = os_cpu_count()
+
+        # these values for n_threads and n_threads_batch are
+        # known to be optimal for most systems
+        n_batch = 512 # can this be optimized?
+        n_threads = max(cpu_count//2, 1)
+        n_threads_batch = cpu_count
+
+        if flash_attn and n_gpu_layers == 0:
+            print_warning(
+                "disabling flash_attn because n_gpu_layers == 0"
+            )
+            flash_attn = False
+        
+        # guard against models with no rope_freq_base
+        if rope_freq_base is None:
+            rope_freq_base = 0
+
+        self.llama: Llama = Llama(
+            model_path=model_path,
+            n_ctx=self.context_length,
+            n_gpu_layers=n_gpu_layers,
+            use_mmap=True,
+            use_mlock=False,
+            logits_all=False,
+            n_batch=n_batch,
+            n_threads=n_threads,
+            n_threads_batch=n_threads_batch,
+            rope_freq_base=rope_freq_base,
+            mul_mat_q=True,
+            offload_kqv=offload_kqv,
+            flash_attn=flash_attn,
+            # KV cache quantization
+            # use 1 for F16 (default), 8 for q8_0, 2 for q4_0, 3 for q4_1
+            #type_k=8,
+            #type_v=8,
+            verbose=verbose
+        )
+        
+        # once model is loaded, replace metadata (as read using internal class)
+        # with metadata (as read using the more robust llama-cpp-python code) 
+        self.metadata = self.llama.metadata
+
+        # expose these values because they may be useful / informative
+        self.n_ctx_train = n_ctx_train
+        self.rope_freq_base_train = rope_freq_base_train
+        self.rope_freq_base = rope_freq_base
+        self.flash_attn = flash_attn
+
+        if self.verbose:
+            print_verbose("new Model instance with the following attributes:")
+            print_verbose(f"model: {model_path}")
+            print_verbose(f"param: n_gpu_layers         == {n_gpu_layers}")
+            print_verbose(f"param: offload_kqv          == {offload_kqv}")
+            print_verbose(f"param: flash_attn           == {flash_attn}")
+            print_verbose(f"param: n_batch              == {n_batch}")
+            print_verbose(f"param: n_threads            == {n_threads}")
+            print_verbose(f"param: n_threads_batch      == {n_threads_batch}")
+            print_verbose(f" gguf: n_ctx_train          == {n_ctx_train}")
+            print_verbose(f"param: self.context_length  == {self.context_length}")
+            print_verbose(f" gguf: rope_freq_base_train == {rope_freq_base_train}")
+            print_verbose(f"param: rope_freq_base       == {rope_freq_base}")
+    
+    def __repr__(self) -> str:
+        return \
+            f"Model({repr(self._model_path)}, " + \
+            f"context_length={self._context_length}, " + \
+            f"n_gpu_layers={self._n_gpu_layers}, " + \
+            f"offload_kqv={self._offload_kqv}, "+ \
+            f"flash_attn={self._flash_attn}, " + \
+            f"verbose={self._verbose})"
+
+    def __del__(self):
+        self.unload()
+    
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self.unload()
+    
+    def __call__(
+        self,
+        prompt: Union[str, list[int]],
+        stops: list[Union[str, int]] = [],
+        sampler: SamplerSettings = DefaultSampling
+    ) -> str:
+        """
+        `Model(...)` is a shorthand for `Model.generate(...)`
+        """
+        return self.generate(prompt, stops, sampler)
+
+    def unload(self):
+        """
+        Unload the model from memory
+        """
+        # ref: llama_cpp._internals._LlamaModel.__del__()
+        if not hasattr(self, 'llama'):
+            # nothing can be done
+            return
+        try:
+            if self.llama._model.model is not None:
+                # actually unload the model from memory
+                self.llama._model._llama_free_model(self.llama._model.model)
+                self.llama._model.model = None
+        except AttributeError:
+            # broken or already being destroyed by GC, abort
+            return
+        if hasattr(self, 'llama'):
+            delattr(self, 'llama')
+        if self.verbose:
+            print_verbose('Model unloaded')
+    
+    def trim(
+        self,
+        text: str,
+        overwrite: Optional[str] = None
+    ) -> str:
+
+        """
+        Trim the given text to the context length of this model,
+        leaving room for two extra tokens.
+
+        Optionally overwrite the oldest tokens with the text given in the
+        `overwrite` parameter, which may be useful for keeping some
+        information in context.
+
+        Does nothing if the text is equal to or shorter than
+        (context_length - 2).
+        """
+        assert_model_is_loaded(self)
+        trim_length = self.context_length - 2
+        tokens_list = self.llama.tokenize(
+            text.encode("utf-8", errors="ignore")
+        )
+
+        if len(tokens_list) <= trim_length:
+            if overwrite is not None:
+                text[0 : len(overwrite)] = overwrite
+            return text
+
+        if len(tokens_list) > trim_length and overwrite is None:
+            # cut to trim_length
+            tokens_list = tokens_list[-trim_length:]
+            return self.llama.detokenize(tokens_list).decode(
+                "utf-8",
+                errors="ignore"
+            )
+
+        if len(tokens_list) > trim_length and overwrite is not None:
+            # cut to trim_length
+            tokens_list = tokens_list[-trim_length:]
+            overwrite_tokens = self.llama.tokenize(overwrite.encode(
+                "utf-8",
+                errors="ignore"
+                )
+            )
+            # overwrite oldest tokens
+            tokens_list[0 : len(overwrite_tokens)] = overwrite_tokens
+            return self.llama.detokenize(tokens_list).decode(
+                "utf-8",
+                errors="ignore"
+            )
+
+    def get_length(self, text: str) -> int:
+        """
+        Return the length of the given text in tokens according to this model,
+        including the appended BOS token.
+        """
+        assert_model_is_loaded(self)
+        return len(self.llama.tokenize(
+            text.encode(
+                "utf-8",
+                errors="ignore"
+                )
+            ))
+
+    def generate(
+        self,
+        prompt: Union[str, list[int]],
+        stops: list[Union[str, int]] = [],
+        sampler: SamplerSettings = DefaultSampling
+    ) -> str:
+        """
+        Given a prompt, return a generated string.
+
+        prompt: The text from which to generate
+
+        The following parameters are optional:
+        - stops: A list of strings and/or token IDs at which to end the generation early
+        - sampler: The SamplerSettings object used to control text generation
+        """
+
+        assert isinstance(prompt, (str, list)), \
+            f"generate: prompt should be string or list[int], not {type(prompt)}"
+        if isinstance(prompt, list):
+            assert all(isinstance(tok, int) for tok in prompt), \
+                "generate: some token in prompt is not an integer"
+        assert isinstance(stops, list), \
+            f"generate: parameter `stops` should be a list, not {type(stops)}"
+        assert all(isinstance(item, (str, int)) for item in stops), \
+            f"generate: some item in parameter `stops` is not a string or int"
+
+        if self.verbose:
+            print_verbose(f'using the following sampler settings for Model.generate:')
+            print_verbose(f'max_len_tokens    == {sampler.max_len_tokens}')
+            print_verbose(f'temp              == {sampler.temp}')
+            print_verbose(f'top_p             == {sampler.top_p}')
+            print_verbose(f'min_p             == {sampler.min_p}')
+            print_verbose(f'frequency_penalty == {sampler.frequency_penalty}')
+            print_verbose(f'presence_penalty  == {sampler.presence_penalty}')
+            print_verbose(f'repeat_penalty    == {sampler.repeat_penalty}')
+            print_verbose(f'top_k             == {sampler.top_k}')
+
+        # if any stop item is a token ID (int)
+        if any(isinstance(stop, int) for stop in stops):
+            # stop_strs is a list of all stopping strings
+            stop_strs: list[str] = [stop for stop in stops if isinstance(stop, str)]
+            # stop_token_ids is a list of all stop token IDs
+            stop_token_ids: list[int] = [tok_id for tok_id in stops if isinstance(tok_id, int)]
+            def stop_on_token_ids(tokens, *args, **kwargs):
+                return tokens[-1] in stop_token_ids
+            stopping_criteria = StoppingCriteriaList([stop_on_token_ids])
+            assert_model_is_loaded(self)
+            return self.llama.create_completion(
+                prompt,
+                max_tokens=sampler.max_len_tokens,
+                temperature=sampler.temp,
+                top_p=sampler.top_p,
+                min_p=sampler.min_p,
+                frequency_penalty=sampler.frequency_penalty,
+                presence_penalty=sampler.presence_penalty,
+                repeat_penalty=sampler.repeat_penalty,
+                top_k=sampler.top_k,
+                stop=stop_strs,
+                stopping_criteria=stopping_criteria
+            )['choices'][0]['text']
+
+        # if stop items are only strings
+        assert_model_is_loaded(self)
+        return self.llama.create_completion(
+            prompt,
+            max_tokens=sampler.max_len_tokens,
+            temperature=sampler.temp,
+            top_p=sampler.top_p,
+            min_p=sampler.min_p,
+            frequency_penalty=sampler.frequency_penalty,
+            presence_penalty=sampler.presence_penalty,
+            repeat_penalty=sampler.repeat_penalty,
+            top_k=sampler.top_k,
+            stop=stops
+        )['choices'][0]['text']
+    
+
+    def stream(
+        self,
+        prompt: Union[str, list[int]],
+        stops: list[Union[str, int]] = [],
+        sampler: SamplerSettings = DefaultSampling
+    ) -> Generator:
+
+        """
+        Given a prompt, return a Generator that yields dicts containing tokens.
+
+        To get the token string itself, subscript the dict with:
+
+        `['choices'][0]['text']`
+
+        prompt: The text from which to generate
+
+        The following parameters are optional:
+        - stops: A list of strings and/or token IDs at which to end the generation early
+        - sampler: The SamplerSettings object used to control text generation
+        """
+
+        assert isinstance(prompt, (str, list)), \
+            f"stream: prompt should be string or list[int], not {type(prompt)}"
+        if isinstance(prompt, list):
+            assert all(isinstance(tok, int) for tok in prompt), \
+                "stream: some token in prompt is not an integer"
+        assert isinstance(stops, list), \
+            f"stream: parameter `stops` should be a list, not {type(stops)}"
+        assert all(isinstance(item, (str, int)) for item in stops), \
+            f"stream: some item in parameter `stops` is not a string or int"
+
+        if self.verbose:
+            print_verbose(f'using the following sampler settings for Model.stream:')
+            print_verbose(f'max_len_tokens    == {sampler.max_len_tokens}')
+            print_verbose(f'temp              == {sampler.temp}')
+            print_verbose(f'top_p             == {sampler.top_p}')
+            print_verbose(f'min_p             == {sampler.min_p}')
+            print_verbose(f'frequency_penalty == {sampler.frequency_penalty}')
+            print_verbose(f'presence_penalty  == {sampler.presence_penalty}')
+            print_verbose(f'repeat_penalty    == {sampler.repeat_penalty}')
+            print_verbose(f'top_k             == {sampler.top_k}')
+        
+        # if any stop item is a token ID (int)
+        if any(isinstance(stop, int) for stop in stops):
+            # stop_strs is a list of all stopping strings
+            stop_strs: list[str] = [stop for stop in stops if isinstance(stop, str)]
+            # stop_token_ids is a list of all stop token IDs
+            stop_token_ids: list[int] = [tok_id for tok_id in stops if isinstance(tok_id, int)]
+            def stop_on_token_ids(tokens, *args, **kwargs):
+                return tokens[-1] in stop_token_ids
+            stopping_criteria = StoppingCriteriaList([stop_on_token_ids])
+            assert_model_is_loaded(self)
+            return self.llama.create_completion(
+                prompt,
+                max_tokens=sampler.max_len_tokens,
+                temperature=sampler.temp,
+                top_p=sampler.top_p,
+                min_p=sampler.min_p,
+                frequency_penalty=sampler.frequency_penalty,
+                presence_penalty=sampler.presence_penalty,
+                repeat_penalty=sampler.repeat_penalty,
+                top_k=sampler.top_k,
+                stream=True,
+                stop=stop_strs,
+                stopping_criteria=stopping_criteria
+            )
+
+        assert_model_is_loaded(self)
+        return self.llama.create_completion(
+            prompt,
+            max_tokens=sampler.max_len_tokens,
+            temperature=sampler.temp,
+            top_p=sampler.top_p,
+            min_p=sampler.min_p,
+            frequency_penalty=sampler.frequency_penalty,
+            presence_penalty=sampler.presence_penalty,
+            repeat_penalty=sampler.repeat_penalty,
+            top_k=sampler.top_k,
+            stream=True,
+            stop=stops
+        )
+
+
+    def stream_print(
+        self,
+        prompt: Union[str, list[int]],
+        stops: list[Union[str, int]] = [],
+        sampler: SamplerSettings = DefaultSampling,
+        end: str = "\n",
+        file: _SupportsWriteAndFlush = sys.stdout,
+        flush: bool = True
+    ) -> str:
+        """
+        Given a prompt, stream text as it is generated, and return the generated string.
+        The returned string does not include the `end` parameter.
+
+        `Model.stream_print(...)` is a shorthand for:
+        
+        ```
+        s = Model.stream(prompt, stops=stops, sampler=sampler)
+        for i in s:
+            tok = i['choices'][0]['text']
+            print(tok, end='', file=file, flush=flush)
+        print(end, end='', file=file, flush=True)
+        ```
+
+        prompt: The text from which to generate
+
+        The following parameters are optional:
+        - stops: A list of strings and/or token IDs at which to end the generation early
+        - sampler: The SamplerSettings object used to control text generation
+        - end: A string to print after the generated text
+        - file: The file where text should be printed
+        - flush: Whether to flush the stream after each token
+        """
+        
+        token_generator = self.stream(
+            prompt=prompt,
+            stops=stops,
+            sampler=sampler
+        )
+
+        res = ''
+        for i in token_generator:
+            tok = i['choices'][0]['text']
+            print(tok, end='', file=file, flush=flush)
+            res += tok
+
+        # print `end`, and always flush stream after generation is done
+        print(end, end='', file=file, flush=True)
+
+        return res
+
+
+    def ingest(self, text: str) -> None:
+        """
+        Ingest the given text into the model's cache
+        """
+
+        assert_model_is_loaded(self)
+        self.llama.create_completion(
+            text,
+            max_tokens=1,
+            temperature=0.0
+        )
+    
+
+    def candidates(
+        self,
+        prompt: str,
+        k: int
+    ) -> list[tuple[str, np.floating]]:
+        """
+        Given prompt `str` and k `int`, return a sorted list of the
+        top k candidates for most likely next token, along with their
+        normalized probabilities
+        """
+
+        assert isinstance(prompt, str), \
+            f"next_candidates: prompt should be str, not {type(prompt)}"
+        assert isinstance(k, int), \
+            f"next_candidates: k should be int, not {type(k)}"
+        assert 0 < k <= len(self.tokens), \
+            f"next_candidates: k should be between 0 and {len(self.tokens)}"
+
+        assert_model_is_loaded(self)
+        prompt_tokens = self.llama.tokenize(prompt.encode('utf-8', errors='ignore'))
+        self.llama.reset() # reset model state
+        self.llama.eval(prompt_tokens)
+        scores = self.llama.scores[len(prompt_tokens) - 1]
+
+        # len(self.llama.scores) == self.context_length
+        # len(self.llama.scores[i]) == len(self.tokens)
+        
+        # normalize scores with softmax
+        # must normalize over all tokens in vocab, not just top k
+        if self.verbose:
+            print_verbose(f'calculating softmax over {len(scores)} values')
+        normalized_scores: list[np.floating] = list(softmax(scores))
+
+        # construct the final list
+        i = 0
+        token_probs_list: list[tuple[str, np.floating]] = []
+        for tok_str in self.tokens:
+            token_probs_list.append((tok_str, normalized_scores[i]))
+            i += 1
+
+        # return token_probs_list, sorted by probability, only top k
+        return nlargest(k, token_probs_list, key=lambda x:x[1])
+
+
+    def print_candidates(
+        self,
+        prompt: str,
+        k: int,
+        file: _SupportsWriteAndFlush = sys.stdout,
+        flush: bool = False
+    ) -> None:
+        """
+        Like `Model.candidates()`, but print the values instead
+        of returning them
+        """
+
+        for _tuple in self.candidates(prompt, k):
+            print(
+                f"token {repr(_tuple[0])} has probability {_tuple[1]}",
+                file=file,
+                flush=flush
+            )
+        
+        # if flush is False, then so far file is not flushed, but it should
+        # always be flushed at the end of printing
+        if not flush:
+            file.flush()
+
+
+def assert_model_is_loaded(model: Model) -> None:
+    """
+    Ensure the Model is fully constructed, such that
+    `Model.llama._model.model is not None` is guaranteed to be `True`
+
+    Raise ModelUnloadedException otherwise
+    """
+    if not hasattr(model, 'llama'):
+        raise ModelUnloadedException(
+            "webscout.Local.Model instance has no attribute 'llama'"
+        )
+    if not hasattr(model.llama, '_model'):
+        raise ModelUnloadedException(
+            "llama_cpp.Llama instance has no attribute '_model'"
+        )
+    if not hasattr(model.llama._model, 'model'):
+        raise ModelUnloadedException(
+            "llama_cpp._internals._LlamaModel instance has no attribute 'model'"
+        )
+    if model.llama._model.model is None:
+        raise ModelUnloadedException(
+            "llama_cpp._internals._LlamaModel.model is None"
+        )

webscout/Local/samplers.py

@@ -0,0 +1,161 @@
+
+from ._version import __version__, __llama_cpp_version__
+
+"""Submodule containing SamplerSettings class and some preset samplers"""
+
+from sys import maxsize
+
+
+MAX_TEMP = float(maxsize)
+
+class SamplerSettings:
+    """
+    A SamplerSettings object specifies the sampling parameters that will be
+    used to control text generation
+    """
+
+    ParamTypes: dict[str, type] = {
+        'max_len_tokens':    int,
+        'temp':              float,
+        'top_p':             float,
+        'min_p':             float,
+        'frequency_penalty': float,
+        'presence_penalty':  float,
+        'repeat_penalty':    float,
+        'top_k':             int
+    }
+
+    def __init__(
+        self,
+        max_len_tokens:    int   = -1,
+        temp:              float = 0.8,
+        top_p:             float = 0.95,
+        min_p:             float = 0.05,
+        frequency_penalty: float = 0.0,
+        presence_penalty:  float = 0.0,
+        repeat_penalty:    float = 1.0,
+        top_k:             int   = 40
+    ):
+        """
+        Construct a new SamplerSettings instance
+        """
+
+        self.max_len_tokens    = max_len_tokens
+        self.temp              = temp
+        self.top_p             = top_p
+        self.min_p             = min_p
+        self.frequency_penalty = frequency_penalty
+        self.presence_penalty  = presence_penalty
+        self.repeat_penalty    = repeat_penalty
+        self.top_k             = top_k
+
+        for sampler_param in SamplerSettings.ParamTypes:
+            expected_type = SamplerSettings.ParamTypes[sampler_param]
+            actual_type = type(getattr(self, sampler_param))
+            if actual_type != expected_type:
+                raise TypeError(
+                    f"wrong type for SamplerSettings parameter '{sampler_param}'"
+                    f" - expected {expected_type}, got {actual_type}"
+                )
+    
+    def __repr__(self) -> str:
+        repr_str = 'SamplerSettings('
+        repr_str += f'max_len_tokens={self.max_len_tokens}, '
+        repr_str += f'temp={self.temp}, '
+        repr_str += f'top_p={self.top_p}, '
+        repr_str += f'min_p={self.min_p}, '
+        repr_str += f'frequency_penalty={self.frequency_penalty}, '
+        repr_str += f'presence_penalty={self.presence_penalty}, '
+        repr_str += f'repeat_penalty={self.repeat_penalty}, '
+        repr_str += f'top_k={self.top_k})'
+        return repr_str
+
+# most likely token is always chosen
+GreedyDecoding = SamplerSettings(
+    temp = 0.0,
+)
+
+# reflects llama.cpp
+DefaultSampling = SamplerSettings()
+
+# unmodified probability distribution (i.e. what the model actually thinks)
+SimpleSampling = SamplerSettings(
+    temp = 1.0,
+    top_p = 1.0,
+    min_p = 0.0,
+    top_k = -1
+)
+
+# reflects old llama.cpp defaults
+ClassicSampling = SamplerSettings(
+    min_p=0.0,
+    repeat_penalty = 1.1
+)
+
+# halfway between DefaultSampling and SimpleSampling
+SemiSampling = SamplerSettings(
+    temp=0.9,
+    top_p=0.975,
+    min_p=0.025,
+    top_k=80
+)
+
+# for models with large vocabulary, which tend to run hot
+TikTokenSampling = SamplerSettings(
+    temp=0.6,
+    repeat_penalty=1.1
+)
+
+# use min_p as the only active sampler (more permissive)
+LowMinPSampling = SamplerSettings(
+    temp = 1.0,
+    top_p = 1.0,
+    min_p = 0.05,
+    top_k = -1
+)
+
+# use min_p as the only active sampler (moderate)
+MinPSampling = SamplerSettings(
+    temp = 1.0,
+    top_p = 1.0,
+    min_p = 0.1,
+    top_k = -1
+)
+
+# use min_p as the only active sampler (more restrictive)
+StrictMinPSampling = SamplerSettings(
+    temp = 1.0,
+    top_p = 1.0,
+    min_p = 0.2,
+    top_k = -1
+)
+
+# https://arxiv.org/abs/2210.14140
+ContrastiveSearch = SamplerSettings(
+    temp = 0.0,
+    presence_penalty = 0.4
+)
+
+# https://arxiv.org/abs/2210.14140
+WarmContrastiveSearch = SamplerSettings(
+    temp = 0.0,
+    presence_penalty = 0.8
+)
+
+# outputs completely random tokens from vocab (useless)
+RandomSampling = SamplerSettings(
+    temp = MAX_TEMP,
+    top_p = 1.0,
+    min_p = 0.0,
+    top_k = -1
+)
+
+# default sampling with reduced temperature
+LowTempSampling = SamplerSettings(
+    temp = 0.4
+)
+
+# default sampling with increased temperature
+HighTempSampling = SamplerSettings(
+    temp = 1.2
+)

webscout/Local/thread.py

@@ -0,0 +1,690 @@
+from ._version import __version__, __llama_cpp_version__
+
+"""Submodule containing the Thread class, used for interaction with a Model"""
+
+import sys
+
+from .model    import Model, assert_model_is_loaded, _SupportsWriteAndFlush
+from .utils    import RESET_ALL, cls, print_verbose, truncate
+from .samplers import SamplerSettings, DefaultSampling
+from typing    import Optional, Literal, Union
+from .formats  import AdvancedFormat
+
+from .formats import blank as formats_blank
+
+
+class Message(dict):
+    """
+    A dictionary representing a single message within a Thread
+
+    Works just like a normal `dict`, but a new method:
+    - `.as_string` - Return the full message string
+
+    Generally, messages have these keys:
+    - `role` -  The role of the speaker: 'system', 'user', or 'bot'
+    - `prefix` - The text that prefixes the message content
+    - `content` - The actual content of the message
+    - `suffix` - The text that suffixes the message content
+    """
+
+    def __repr__(self) -> str:
+        return \
+            f"Message([" \
+            f"('role', {repr(self['role'])}), " \
+            f"('prefix', {repr(self['prefix'])}), " \
+            f"('content', {repr(self['content'])}), " \
+            f"('suffix', {repr(self['suffix'])})])"
+
+    def as_string(self):
+        """Return the full message string"""
+        try:
+            return self['prefix'] + self['content'] + self['suffix']
+        except KeyError as e:
+            e.add_note(
+                "as_string: Message is missing one or more of the "
+                "required 'prefix', 'content', 'suffix' attributes - this is "
+                "unexpected"
+            )
+            raise e
+
+
+class Thread:
+    """
+    Provide functionality to facilitate easy interactions with a Model
+
+    This is just a brief overview of m.Thread.
+    To see a full description of each method and its parameters,
+    call help(Thread), or see the relevant docstring.
+
+    The following methods are available:
+    - `.add_message()` - Add a message to `Thread.messages`
+    - `.as_string()` - Return this thread's complete message history as a string
+    - `.create_message()` - Create a message using the format of this thread
+    - `.inference_str_from_messages()` - Using the list of messages, return a string suitable for inference
+    - `.interact()` - Start an interactive, terminal-based chat session
+    - `.len_messages()` - Get the total length of all messages in tokens
+    - `.print_stats()` - Print stats about the context usage in this thread
+    - `.reset()` - Clear the list of messages
+    - `.send()` - Send a message in this thread
+
+    The following attributes are available:
+    - `.format` - The format being used for messages in this thread
+    - `.messages` - The list of messages in this thread
+    - `.model` - The `m.Model` instance used by this thread
+    - `.sampler` - The SamplerSettings object used in this thread
+    """
+
+    def __init__(
+        self,
+        model: Model,
+        format: Union[dict, AdvancedFormat],
+        sampler: SamplerSettings = DefaultSampling,
+        messages: Optional[list[Message]] = None,
+    ):
+        """
+        Given a Model and a format, construct a Thread instance.
+
+        model: The Model to use for text generation
+        format: The format specifying how messages should be structured (see m.formats)
+
+        The following parameters are optional:
+        - sampler: The SamplerSettings object used to control text generation
+        - messages: A list of m.thread.Message objects to add to the Thread upon construction
+        """
+        
+        assert isinstance(model, Model), \
+            "Thread: model should be an " + \
+            f"instance of webscout.Local.Model, not {type(model)}"
+        
+        assert_model_is_loaded(model)
+
+        assert isinstance(format, (dict, AdvancedFormat)), \
+            f"Thread: format should be dict or AdvancedFormat, not {type(format)}"
+        
+        if any(k not in format.keys() for k in formats_blank.keys()):
+            raise KeyError(
+                "Thread: format is missing one or more required keys, see " + \
+                "webscout.Local.formats.blank for an example"
+            )
+
+        assert isinstance(format['stops'], list), \
+            "Thread: format['stops'] should be list, not " + \
+            f"{type(format['stops'])}"
+        
+        assert all(
+            hasattr(sampler, attr) for attr in [
+                'max_len_tokens',
+                'temp',
+                'top_p',
+                'min_p',
+                'frequency_penalty',
+                'presence_penalty',
+                'repeat_penalty',
+                'top_k'
+            ]
+        ), 'Thread: sampler is missing one or more required attributes'
+
+        self._messages: Optional[list[Message]] = messages
+        if self._messages is not None:
+            if not all(isinstance(msg, Message) for msg in self._messages):
+                raise TypeError(
+                    "Thread: one or more messages provided to __init__() is "
+                    "not an instance of m.thread.Message"
+                )
+        
+        # Thread.messages is never empty, unless `messages` param is explicity
+        # set to `[]` during construction
+
+        self.model: Model = model
+        self.format: Union[dict, AdvancedFormat] = format
+        self.messages: list[Message] = [
+            self.create_message("system", self.format['system_content'])
+        ] if self._messages is None else self._messages
+        self.sampler: SamplerSettings = sampler
+
+        if self.model.verbose:
+            print_verbose("new Thread instance with the following attributes:")
+            print_verbose(f"model                     == {self.model}")
+            print_verbose(f"format['system_prefix']   == {truncate(repr(self.format['system_prefix']))}")
+            print_verbose(f"format['system_content']  == {truncate(repr(self.format['system_content']))}")
+            print_verbose(f"format['system_suffix']   == {truncate(repr(self.format['system_suffix']))}")
+            print_verbose(f"format['user_prefix']     == {truncate(repr(self.format['user_prefix']))}")
+            print_verbose(f"format['user_content']    == {truncate(repr(self.format['user_content']))}")
+            print_verbose(f"format['user_suffix']     == {truncate(repr(self.format['user_suffix']))}")
+            print_verbose(f"format['bot_prefix']      == {truncate(repr(self.format['bot_prefix']))}")
+            print_verbose(f"format['bot_content']     == {truncate(repr(self.format['bot_content']))}")
+            print_verbose(f"format['bot_suffix']      == {truncate(repr(self.format['bot_suffix']))}")
+            print_verbose(f"format['stops']           == {truncate(repr(self.format['stops']))}")
+            print_verbose(f"sampler.temp              == {self.sampler.temp}")
+            print_verbose(f"sampler.top_p             == {self.sampler.top_p}")
+            print_verbose(f"sampler.min_p             == {self.sampler.min_p}")
+            print_verbose(f"sampler.frequency_penalty == {self.sampler.frequency_penalty}")
+            print_verbose(f"sampler.presence_penalty  == {self.sampler.presence_penalty}")
+            print_verbose(f"sampler.repeat_penalty    == {self.sampler.repeat_penalty}")
+            print_verbose(f"sampler.top_k             == {self.sampler.top_k}")
+    
+
+    def __repr__(self) -> str:
+        return \
+            f"Thread({repr(self.model)}, {repr(self.format)}, " + \
+            f"{repr(self.sampler)}, {repr(self.messages)})"
+    
+    def __str__(self) -> str:
+        return self.as_string()
+    
+    def __len__(self) -> int:
+        """
+        `len(Thread)` returns the length of the Thread in tokens
+
+        To get the number of messages in the Thread, use `len(Thread.messages)`
+        """
+        return self.len_messages()
+
+    def create_message(
+        self,
+        role: Literal['system', 'user', 'bot'],
+        content: str
+    ) -> Message:
+        """
+        Construct a message using the format of this Thread
+        """
+
+        assert role.lower() in ['system', 'user', 'bot'], \
+            f"create_message: role should be 'system', 'user', or 'bot', not '{role.lower()}'"
+
+        assert isinstance(content, str), \
+            f"create_message: content should be str, not {type(content)}"
+
+        if role.lower() == 'system':
+            return Message(
+                [
+                    ('role', 'system'),
+                    ('prefix', self.format['system_prefix']),
+                    ('content', content),
+                    ('suffix', self.format['system_suffix'])
+                ]
+            )
+        
+        elif role.lower() == 'user':
+            return Message(
+                [
+                    ('role', 'user'),
+                    ('prefix', self.format['user_prefix']),
+                    ('content', content),
+                    ('suffix', self.format['user_suffix'])
+                ]
+            )
+        
+        elif role.lower() == 'bot':
+            return Message(
+                [
+                    ('role', 'bot'),
+                    ('prefix', self.format['bot_prefix']),
+                    ('content', content),
+                    ('suffix', self.format['bot_suffix'])
+                ]
+            )
+    
+    def len_messages(self) -> int:
+        """
+        Return the total length of all messages in this thread, in tokens.
+        
+        Can also use `len(Thread)`."""
+
+        return self.model.get_length(self.as_string())
+
+    def add_message(
+        self,
+        role: Literal['system', 'user', 'bot'],
+        content: str
+    ) -> None:
+        """
+        Create a message and append it to `Thread.messages`.
+
+        `Thread.add_message(...)` is a shorthand for
+        `Thread.messages.append(Thread.create_message(...))`
+        """
+        self.messages.append(
+            self.create_message(
+                role=role,
+                content=content
+            )
+        )
+
+    def inference_str_from_messages(self) -> str:
+        """
+        Using the list of messages, construct a string suitable for inference,
+        respecting the format and context length of this thread.
+        """
+
+        inf_str = ''
+        sys_msg_str = ''
+        # whether to treat the first message as necessary to keep
+        sys_msg_flag = False
+        context_len_budget = self.model.context_length
+
+        # if at least 1 message is history
+        if len(self.messages) >= 1:
+            # if first message has system role
+            if self.messages[0]['role'] == 'system':
+                sys_msg_flag = True
+                sys_msg = self.messages[0]
+                sys_msg_str = sys_msg.as_string()
+                context_len_budget -= self.model.get_length(sys_msg_str)
+
+        if sys_msg_flag:
+            iterator = reversed(self.messages[1:])
+        else:
+            iterator = reversed(self.messages)
+        
+        for message in iterator:
+            msg_str = message.as_string()
+            context_len_budget -= self.model.get_length(msg_str)
+            if context_len_budget <= 0:
+                break
+            inf_str = msg_str + inf_str
+
+        if sys_msg_flag:
+            inf_str = sys_msg_str + inf_str
+        inf_str += self.format['bot_prefix']
+
+        return inf_str
+
+
+    def send(self, prompt: str) -> str:
+        """
+        Send a message in this thread. This adds your message and the bot's
+        response to the list of messages.
+
+        Returns a string containing the response to your message.
+        """
+
+        self.add_message("user", prompt)
+        output = self.model.generate(
+            self.inference_str_from_messages(),
+            stops=self.format['stops'],
+            sampler=self.sampler
+        )
+        self.add_message("bot", output)
+
+        return output
+    
+
+    def _interactive_update_sampler(self) -> None:
+        """Interactively update the sampler settings used in this Thread"""
+        print()
+        try:
+            new_max_len_tokens = input(f'max_len_tokens: {self.sampler.max_len_tokens} -> ')
+            new_temp = input(f'temp: {self.sampler.temp} -> ')
+            new_top_p = input(f'top_p: {self.sampler.top_p} -> ')
+            new_min_p = input(f'min_p: {self.sampler.min_p} -> ')
+            new_frequency_penalty = input(f'frequency_penalty: {self.sampler.frequency_penalty} -> ')
+            new_presence_penalty = input(f'presence_penalty: {self.sampler.presence_penalty} -> ')
+            new_repeat_penalty = input(f'repeat_penalty: {self.sampler.repeat_penalty} -> ')
+            new_top_k = input(f'top_k: {self.sampler.top_k} -> ')
+        
+        except KeyboardInterrupt:
+            print('\nwebscout.Local: sampler settings not updated\n')
+            return
+        print()
+
+        try:
+            self.sampler.max_len_tokens = int(new_max_len_tokens)
+        except ValueError:
+            pass
+        else:
+            print('webscout.Local: max_len_tokens updated')
+        
+        try:
+            self.sampler.temp = float(new_temp)
+        except ValueError:
+            pass
+        else:
+            print('webscout.Local: temp updated')
+        
+        try:
+            self.sampler.top_p = float(new_top_p)
+        except ValueError:
+            pass
+        else:
+            print('webscout.Local: top_p updated')
+
+        try:
+            self.sampler.min_p = float(new_min_p)
+        except ValueError:
+            pass
+        else:
+            print('webscout.Local: min_p updated')
+
+        try:
+            self.sampler.frequency_penalty = float(new_frequency_penalty)
+        except ValueError:
+            pass
+        else:
+            print('webscout.Local: frequency_penalty updated')
+        
+        try:
+            self.sampler.presence_penalty = float(new_presence_penalty)
+        except ValueError:
+            pass
+        else:
+            print('webscout.Local: presence_penalty updated')
+        
+        try:
+            self.sampler.repeat_penalty = float(new_repeat_penalty)
+        except ValueError:
+            pass
+        else:
+            print('webscout.Local: repeat_penalty updated')
+        
+        try:
+            self.sampler.top_k = int(new_top_k)
+        except ValueError:
+            pass
+        else:
+            print('webscout.Local: top_k updated')
+        print()
+                
+
+    def _interactive_input(
+        self,
+        prompt: str,
+        _dim_style: str,
+        _user_style: str,
+        _bot_style: str,
+        _special_style: str
+    ) -> tuple:
+        """
+        Recive input from the user, while handling multi-line input
+        and commands
+        """
+        full_user_input = '' # may become multiline
+        
+        while True:
+            user_input = input(prompt)
+            
+            if user_input.endswith('\\'):
+                full_user_input += user_input[:-1] + '\n'
+            
+            elif user_input == '!':
+
+                print()
+                try:
+                    command = input(f'{RESET_ALL}  ! {_dim_style}')
+                except KeyboardInterrupt:
+                    print('\n')
+                    continue
+
+                if command == '':
+                    print(f'\n[no command]\n')
+
+                elif command.lower() in ['reset', 'restart']:
+                    self.reset()
+                    print(f'\n[thread reset]\n')
+
+                elif command.lower() in ['cls', 'clear']:
+                    cls()
+                    print()
+
+                elif command.lower() in ['ctx', 'context']:
+                    print(f"\n{self.len_messages()}\n")
+
+                elif command.lower() in ['stats', 'print_stats']:
+                    print()
+                    self.print_stats()
+                    print()
+                
+                elif command.lower() in ['sampler', 'samplers', 'settings']:
+                    self._interactive_update_sampler()
+                
+                elif command.lower() in ['str', 'string', 'as_string']:
+                    print(f"\n{self.as_string()}\n")
+                
+                elif command.lower() in ['repr', 'save', 'backup']:
+                    print(f"\n{repr(self)}\n")
+                
+                elif command.lower() in ['remove', 'rem', 'delete', 'del']:
+                    print()
+                    old_len = len(self.messages)
+                    del self.messages[-1]
+                    assert len(self.messages) == (old_len - 1)
+                    print('[removed last message]\n')
+
+                elif command.lower() in ['last', 'repeat']:
+                    last_msg = self.messages[-1]
+                    if last_msg['role'] == 'user':
+                        print(f"\n{_user_style}{last_msg['content']}{RESET_ALL}\n")
+                    elif last_msg['role'] == 'bot':
+                        print(f"\n{_bot_style}{last_msg['content']}{RESET_ALL}\n")
+                
+                elif command.lower() in ['inf', 'inference', 'inf_str']:
+                    print(f'\n"""{self.inference_str_from_messages()}"""\n')
+                
+                elif command.lower() in ['reroll', 're-roll', 're', 'swipe']:
+                    old_len = len(self.messages)
+                    del self.messages[-1]
+                    assert len(self.messages) == (old_len - 1)
+                    return '', None
+                
+                elif command.lower() in ['exit', 'quit']:
+                    print(RESET_ALL)
+                    return None, None
+                
+                elif command.lower() in ['help', '/?', '?']:
+                    print()
+                    print('reset | restart     -- Reset the thread to its original state')
+                    print('clear | cls         -- Clear the terminal')
+                    print('context | ctx       -- Get the context usage in tokens')
+                    print('print_stats | stats -- Get the context usage stats')
+                    print('sampler | settings  -- Update the sampler settings')
+                    print('string | str        -- Print the message history as a string')
+                    print('repr | save         -- Print the representation of the thread')
+                    print('remove | delete     -- Remove the last message')
+                    print('last | repeat       -- Repeat the last message')
+                    print('inference | inf     -- Print the inference string')
+                    print('reroll | swipe      -- Regenerate the last message')
+                    print('exit | quit         -- Exit the interactive chat (can also use ^C)')
+                    print('help | ?            -- Show this screen')
+                    print()
+                    print("TIP: type < at the prompt and press ENTER to prefix the bot's next message.")
+                    print('     for example, type "Sure!" to bypass refusals')
+                    print()
+                    print("TIP: type !! at the prompt and press ENTER to insert a system message")
+                    print()
+
+                else:
+                    print(f'\n[unknown command]\n')
+            
+            # prefix the bot's next message
+            elif user_input == '<':
+
+                print()
+                try:
+                    next_message_start = input(f'{RESET_ALL}  < {_dim_style}')
+
+                except KeyboardInterrupt:
+                    print(f'{RESET_ALL}\n')
+                    continue
+
+                else:
+                    print()
+                    return '', next_message_start
+
+            # insert a system message
+            elif user_input == '!!':
+                print()
+
+                try:
+                    next_sys_msg = input(f'{RESET_ALL} !! {_special_style}')
+                
+                except KeyboardInterrupt:
+                    print(f'{RESET_ALL}\n')
+                    continue
+                
+                else:
+                    print()
+                    return next_sys_msg, -1
+
+            # concatenate multi-line input
+            else:
+                full_user_input += user_input
+                return full_user_input, None
+
+
+    def interact(
+        self,
+        color: bool = True,
+        header: Optional[str] = None,
+        stream: bool = True
+    ) -> None:
+        """
+        Start an interactive chat session using this Thread.
+
+        While text is being generated, press `^C` to interrupt the bot.
+        Then you have the option to press `ENTER` to re-roll, or to simply type
+        another message.
+
+        At the prompt, press `^C` to end the chat session.
+
+        Type `!` and press `ENTER` to enter a basic command prompt. For a list
+        of  commands, type `help` at this prompt.
+        
+        Type `<` and press `ENTER` to prefix the bot's next message, for
+        example with `Sure!`.
+
+        Type `!!` at the prompt and press `ENTER` to insert a system message.
+
+        The following parameters are optional:
+        - color: Whether to use colored text to differentiate user / bot
+        - header: Header text to print at the start of the interaction
+        - stream: Whether to stream text as it is generated
+        """
+        print()
+
+        # fresh import of color codes in case `color` param has changed
+        from .utils import SPECIAL_STYLE, USER_STYLE, BOT_STYLE, DIM_STYLE
+
+        # disable color codes if explicitly disabled by `color` param
+        if not color:
+            SPECIAL_STYLE = ''
+            USER_STYLE = ''
+            BOT_STYLE = ''
+            DIM_STYLE = ''
+        
+        if header is not None:
+            print(f"{SPECIAL_STYLE}{header}{RESET_ALL}\n")
+        
+        while True:
+
+            prompt = f"{RESET_ALL}  > {USER_STYLE}"
+            
+            try:
+                user_prompt, next_message_start = self._interactive_input(
+                    prompt,
+                    DIM_STYLE,
+                    USER_STYLE,
+                    BOT_STYLE,
+                    SPECIAL_STYLE
+                )
+            except KeyboardInterrupt:
+                print(f"{RESET_ALL}\n")
+                return
+            
+            # got 'exit' or 'quit' command
+            if user_prompt is None and next_message_start is None:
+                break
+            
+            # insert a system message via `!!` prompt
+            if next_message_start == -1:
+                self.add_message('system', user_prompt)
+                continue
+            
+            if next_message_start is not None:
+                try:
+                    if stream:
+                        print(f"{BOT_STYLE}{next_message_start}", end='', flush=True)
+                        output = next_message_start + self.model.stream_print(
+                            self.inference_str_from_messages() + next_message_start,
+                            stops=self.format['stops'],
+                            sampler=self.sampler,
+                            end=''
+                        )
+                    else:
+                        print(f"{BOT_STYLE}", end='', flush=True)
+                        output = next_message_start + self.model.generate(
+                            self.inference_str_from_messages() + next_message_start,
+                            stops=self.format['stops'],
+                            sampler=self.sampler
+                        )
+                        print(output, end='', flush=True)
+                except KeyboardInterrupt:
+                    print(f"{DIM_STYLE} [message not added to history; press ENTER to re-roll]\n")
+                    continue
+                else:
+                    self.add_message("bot", output)
+            else:
+                print(BOT_STYLE)
+                if user_prompt != "":
+                    self.add_message("user", user_prompt)
+                try:
+                    if stream:
+                        output = self.model.stream_print(
+                            self.inference_str_from_messages(),
+                            stops=self.format['stops'],
+                            sampler=self.sampler,
+                            end=''
+                        )
+                    else:
+                        output = self.model.generate(
+                            self.inference_str_from_messages(),
+                            stops=self.format['stops'],
+                            sampler=self.sampler
+                        )
+                        print(output, end='', flush=True)
+                except KeyboardInterrupt:
+                    print(f"{DIM_STYLE} [message not added to history; press ENTER to re-roll]\n")
+                    continue
+                else:
+                    self.add_message("bot", output)
+
+            if output.endswith("\n\n"):
+                print(RESET_ALL, end = '', flush=True)
+            elif output.endswith("\n"):
+                print(RESET_ALL)
+            else:
+                print(f"{RESET_ALL}\n")
+
+
+    def reset(self) -> None:
+        """
+        Clear the list of messages, which resets the thread to its original
+        state
+        """
+        self.messages: list[Message] = [
+            self.create_message("system", self.format['system_content'])
+        ] if self._messages is None else self._messages
+    
+    
+    def as_string(self) -> str:
+        """Return this thread's message history as a string"""
+        thread_string = ''
+        for msg in self.messages:
+            thread_string += msg.as_string()
+        return thread_string
+
+    
+    def print_stats(
+        self,
+        end: str = '\n',
+        file: _SupportsWriteAndFlush = sys.stdout,
+        flush: bool = True
+    ) -> None:
+        """Print stats about the context usage in this thread"""
+        thread_len_tokens = self.len_messages()
+        max_ctx_len = self.model.context_length
+        context_used_percentage = round((thread_len_tokens/max_ctx_len)*100)
+        print(f"{thread_len_tokens} / {max_ctx_len} tokens", file=file, flush=flush)
+        print(f"{context_used_percentage}% of context used", file=file, flush=flush)
+        print(f"{len(self.messages)} messages", end=end, file=file, flush=flush)
+        if not flush:
+            file.flush()

webscout/Local/utils.py

@@ -0,0 +1,185 @@
+from ._version import __version__, __llama_cpp_version__
+
+import sys
+import numpy as np
+
+from typing   import Any, Iterable, TextIO
+from time     import strftime
+from enum     import IntEnum
+from struct   import unpack
+from colorama import Fore
+from huggingface_hub import hf_hub_url, cached_download
+
+# color codes used in Thread.interact()
+RESET_ALL = Fore.RESET
+USER_STYLE = RESET_ALL + Fore.GREEN
+BOT_STYLE = RESET_ALL + Fore.CYAN
+DIM_STYLE = RESET_ALL + Fore.LIGHTBLACK_EX
+SPECIAL_STYLE = RESET_ALL + Fore.YELLOW
+
+# for typing of softmax parameter `z`
+class _ArrayLike(Iterable):
+    pass
+
+# for typing of Model.stream_print() parameter `file`
+class _SupportsWriteAndFlush(TextIO):
+    pass
+
+def download_model(repo_id: str, filename: str, cache_dir: str = ".cache") -> str:
+    """
+    Downloads a GGUF model file from Hugging Face Hub.
+
+    repo_id: The Hugging Face repository ID (e.g., 'facebook/bart-large-cnn').
+    filename: The name of the GGUF file within the repository (e.g., 'model.gguf').
+    cache_dir: The directory where the downloaded file should be stored.
+    
+    Returns: The path to the downloaded file.
+    """
+    url = hf_hub_url(repo_id, filename)
+    filepath = cached_download(url, cache_dir=cache_dir, force_filename=filename)
+    return filepath
+
+class GGUFReader:
+    """
+    Peek at file header for GGUF metadata
+
+    Raise ValueError if file is not GGUF or is outdated
+
+    Credit to oobabooga for the parts of the code in this class
+
+    Format spec: https://github.com/philpax/ggml/blob/gguf-spec/docs/gguf.md
+    """
+
+    class GGUFValueType(IntEnum):
+        UINT8 = 0
+        INT8 = 1
+        UINT16 = 2
+        INT16 = 3
+        UINT32 = 4
+        INT32 = 5
+        FLOAT32 = 6
+        BOOL = 7
+        STRING = 8
+        ARRAY = 9
+        UINT64 = 10
+        INT64 = 11
+        FLOAT64 = 12
+
+    _simple_value_packing = {
+        GGUFValueType.UINT8: "<B",
+        GGUFValueType.INT8: "<b",
+        GGUFValueType.UINT16: "<H",
+        GGUFValueType.INT16: "<h",
+        GGUFValueType.UINT32: "<I",
+        GGUFValueType.INT32: "<i",
+        GGUFValueType.FLOAT32: "<f",
+        GGUFValueType.UINT64: "<Q",
+        GGUFValueType.INT64: "<q",
+        GGUFValueType.FLOAT64: "<d",
+        GGUFValueType.BOOL: "?",
+    }
+
+    value_type_info = {
+        GGUFValueType.UINT8: 1,
+        GGUFValueType.INT8: 1,
+        GGUFValueType.UINT16: 2,
+        GGUFValueType.INT16: 2,
+        GGUFValueType.UINT32: 4,
+        GGUFValueType.INT32: 4,
+        GGUFValueType.FLOAT32: 4,
+        GGUFValueType.UINT64: 8,
+        GGUFValueType.INT64: 8,
+        GGUFValueType.FLOAT64: 8,
+        GGUFValueType.BOOL: 1,
+    }
+
+    def get_single(self, value_type, file) -> Any:
+        if value_type == GGUFReader.GGUFValueType.STRING:
+            value_length = unpack("<Q", file.read(8))[0]
+            value = file.read(value_length)
+            value = value.decode("utf-8")
+        else:
+            type_str = GGUFReader._simple_value_packing.get(value_type)
+            bytes_length = GGUFReader.value_type_info.get(value_type)
+            value = unpack(type_str, file.read(bytes_length))[0]
+
+        return value
+
+    def load_metadata(self, fname) -> dict:
+        metadata = {}
+        with open(fname, "rb") as file:
+            GGUF_MAGIC = file.read(4)
+
+            if GGUF_MAGIC != b"GGUF":
+                raise ValueError(
+                    "your model file is not a valid GGUF file "
+                    f"(magic number mismatch, got {GGUF_MAGIC}, "
+                    "expected b'GGUF')"
+                )
+
+            GGUF_VERSION = unpack("<I", file.read(4))[0]
+
+            if GGUF_VERSION == 1:
+                raise ValueError(
+                    "your model file reports GGUF version 1, "
+                    "but only versions 2 and above are supported. "
+                    "re-convert your model or download a newer version"
+                )
+
+            # ti_data_count = struct.unpack("<Q", file.read(8))[0]
+            file.read(8)
+            kv_data_count = unpack("<Q", file.read(8))[0]
+
+            for _ in range(kv_data_count):
+                key_length = unpack("<Q", file.read(8))[0]
+                key = file.read(key_length)
+
+                value_type = GGUFReader.GGUFValueType(
+                    unpack("<I", file.read(4))[0]
+                )
+                if value_type == GGUFReader.GGUFValueType.ARRAY:
+                    ltype = GGUFReader.GGUFValueType(
+                        unpack("<I", file.read(4))[0]
+                    )
+                    length = unpack("<Q", file.read(8))[0]
+                    arr = [
+                        GGUFReader.get_single(
+                            self,
+                            ltype,
+                            file
+                        ) for _ in range(length)
+                    ]
+                    metadata[key.decode()] = arr
+                else:
+                    value = GGUFReader.get_single(self, value_type, file)
+                    metadata[key.decode()] = value
+
+        return metadata
+
+def softmax(z: _ArrayLike) -> np.ndarray:
+    """
+    Compute softmax over values in z, where z is array-like
+    """
+    e_z = np.exp(z - np.max(z))
+    return e_z / e_z.sum()
+
+def cls() -> None:
+    """Clear the terminal"""
+    print("\033c\033[3J", end='', flush=True)
+
+# no longer used in this module, but left for others to use
+def get_timestamp_prefix_str() -> str:
+    # helpful: https://strftime.net
+    return strftime("[%Y, %b %e, %a %l:%M %p] ")
+
+def truncate(text: str) -> str:
+    return text if len(text) < 63 else f"{text[:60]}..."
+
+def print_verbose(text: str) -> None:
+    print("webscout.Local: verbose:", text, file=sys.stderr, flush=True)
+
+def print_info(text: str) -> None:
+    print("webscout.Local: info:", text, file=sys.stderr, flush=True)
+
+def print_warning(text: str) -> None:
+    print("webscout.Local: warning:", text, file=sys.stderr, flush=True)

webscout/Provider/BasedGPT.py

@@ -0,0 +1,226 @@
+import time
+import uuid
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+import click
+import requests
+from requests import get
+from uuid import uuid4
+from re import findall
+from requests.exceptions import RequestException
+from curl_cffi.requests import get, RequestsError
+import g4f
+from random import randint
+from PIL import Image
+import io
+import re
+import json
+import yaml
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import  Provider, AsyncProvider
+from webscout import exceptions
+from typing import Any, AsyncGenerator, Dict
+import logging
+import httpx
+
+class BasedGPT(Provider):
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        system_prompt: str = "Be Helpful and Friendly",
+    ):
+        """Instantiates BasedGPT
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True.
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+            system_prompt (str, optional): System prompt for BasedGPT. Defaults to "Be Helpful and Friendly".
+        """
+        self.session = requests.Session()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.chat_endpoint = "https://www.basedgpt.chat/api/chat"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.system_prompt = system_prompt
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(
+            {"Content-Type": "application/json"}
+        )
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session.proxies = proxies
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict : {}
+        ```json
+        {
+            "id": "chatcmpl-TaREJpBZsRVQFRFic1wIA7Q7XfnaD",
+            "object": "chat.completion",
+            "created": 1704623244,
+            "model": "gpt-3.5-turbo",
+            "usage": {
+                "prompt_tokens": 0,
+                "completion_tokens": 0,
+                "total_tokens": 0
+                },
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "Hello! How can I assist you today?"
+                },
+                "finish_reason": "stop",
+                "index": 0
+                }
+            ]
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        payload = {
+            "messages": [
+                {"role": "system", "content": self.system_prompt},
+                {"role": "user", "content": conversation_prompt},
+            ],
+        }
+
+        def for_stream():
+            response = self.session.post(
+                self.chat_endpoint, json=payload, stream=True, timeout=self.timeout
+            )
+            if not response.ok:
+                raise exceptions.FailedToGenerateResponseError(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
+
+            message_load = ""
+            for value in response.iter_lines(
+                decode_unicode=True,
+                delimiter="",
+                chunk_size=self.stream_chunk_size,
+            ):
+                try:
+                    message_load += value
+                    yield value if raw else dict(text=message_load)
+                except json.decoder.JSONDecodeError:
+                    pass
+            self.last_response.update(dict(text=message_load))
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+
+        def for_non_stream():
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]

webscout/Provider/Berlin4h.py

@@ -0,0 +1,211 @@
+import requests
+import json
+import uuid
+from typing import Any, Dict, Optional
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import Provider, AsyncProvider
+from webscout import exceptions
+
+class Berlin4h(Provider):
+    """
+    A class to interact with the Berlin4h AI API.
+    """
+
+    def __init__(
+        self,
+        api_token: str = "3bf369cd84339603f8a5361e964f9ebe",
+        api_endpoint: str = "https://ai.berlin4h.top/api/chat/completions",
+        model: str = "gpt-3.5-turbo",
+        temperature: float = 0.9,
+        presence_penalty: float = 0,
+        frequency_penalty: float = 0,
+        max_tokens: int = 4000,
+        is_conversation: bool = True,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ) -> None:
+        """
+        Initializes the Berlin4h API with given parameters.
+
+        Args:
+            api_token (str): The API token for authentication.
+            api_endpoint (str): The API endpoint to use for requests.
+            model (str): The AI model to use for text generation.
+            temperature (float): The temperature parameter for the model.
+            presence_penalty (float): The presence penalty parameter for the model.
+            frequency_penalty (float): The frequency penalty parameter for the model.
+            max_tokens (int): The maximum number of tokens to generate.
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.api_token = api_token
+        self.api_endpoint = api_endpoint
+        self.model = model
+        self.temperature = temperature
+        self.presence_penalty = presence_penalty
+        self.frequency_penalty = frequency_penalty
+        self.max_tokens = max_tokens
+        self.parent_message_id: Optional[str] = None
+        self.session = requests.Session()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.stream_chunk_size = 1
+        self.timeout = timeout
+        self.last_response = {}
+        self.headers = {"Content-Type": "application/json", "Token": self.api_token}
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(self.headers)
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session.proxies = proxies
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Dict[str, Any]:
+        """
+        Sends a prompt to the Berlin4h AI API and returns the response.
+
+        Args:
+            prompt: The text prompt to generate text from.
+            stream (bool, optional): Whether to stream the response. Defaults to False.
+            raw (bool, optional): Whether to return the raw response. Defaults to False.
+            optimizer (str, optional): The name of the optimizer to use. Defaults to None.
+            conversationally (bool, optional): Whether to chat conversationally. Defaults to False.
+
+        Returns:
+            The response from the API.
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        payload: Dict[str, any] = {
+            "prompt": conversation_prompt,
+            "parentMessageId": self.parent_message_id or str(uuid.uuid4()),
+            "options": {
+                "model": self.model,
+                "temperature": self.temperature,
+                "presence_penalty": self.presence_penalty,
+                "frequency_penalty": self.frequency_penalty,
+                "max_tokens": self.max_tokens,
+            },
+        }
+
+        def for_stream():
+            response = self.session.post(
+                self.api_endpoint, json=payload, headers=self.headers, stream=True, timeout=self.timeout
+            )
+
+            if not response.ok:
+                raise exceptions.FailedToGenerateResponseError(
+                    f"Failed to generate response - ({response.status_code}, {response.reason})"
+                )
+
+            streaming_response = ""
+            # Collect the entire line before processing
+            for line in response.iter_lines(decode_unicode=True): 
+                if line:
+                    try:
+                        json_data = json.loads(line)
+                        content = json_data['content']
+                        if ">" in content: break
+                        streaming_response += content
+                        yield content if raw else dict(text=streaming_response)  # Yield accumulated response
+                    except:
+                        continue
+            self.last_response.update(dict(text=streaming_response))
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+
+        def for_non_stream():
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]

webscout/Provider/Blackboxai.py

@@ -0,0 +1,440 @@
+import time
+import uuid
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+import click
+import requests
+from requests import get
+from uuid import uuid4
+from re import findall
+from requests.exceptions import RequestException
+from curl_cffi.requests import get, RequestsError
+import g4f
+from random import randint
+from PIL import Image
+import io
+import re
+import json
+import yaml
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import  Provider, AsyncProvider
+from Helpingai_T2 import Perplexity
+from webscout import exceptions
+from typing import Any, AsyncGenerator, Dict
+import logging
+import httpx
+
+#------------------------------------------------------BLACKBOXAI--------------------------------------------------------  
+class BLACKBOXAI:
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 8000,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        model: str = None,
+    ):
+        """Instantiates BLACKBOXAI
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+            model (str, optional): Model name. Defaults to "Phind Model".
+        """
+        self.session = requests.Session()
+        self.max_tokens_to_sample = max_tokens
+        self.is_conversation = is_conversation
+        self.chat_endpoint = "https://www.blackbox.ai/api/chat"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.model = model
+        self.previewToken: str = None
+        self.userId: str = ""
+        self.codeModelMode: bool = True
+        self.id: str = ""
+        self.agentMode: dict = {}
+        self.trendingAgentMode: dict = {}
+        self.isMicMode: bool = False
+
+        self.headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "",
+            "Accept": "*/*",
+            "Accept-Encoding": "Identity",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(self.headers)
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session.proxies = proxies
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict : {}
+        ```json
+        {
+           "text" : "print('How may I help you today?')"
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        self.session.headers.update(self.headers)
+        payload = {
+            "messages": [
+                # json.loads(prev_messages),
+                {"content": conversation_prompt, "role": "user"}
+            ],
+            "id": self.id,
+            "previewToken": self.previewToken,
+            "userId": self.userId,
+            "codeModelMode": self.codeModelMode,
+            "agentMode": self.agentMode,
+            "trendingAgentMode": self.trendingAgentMode,
+            "isMicMode": self.isMicMode,
+        }
+
+        def for_stream():
+            response = self.session.post(
+                self.chat_endpoint, json=payload, stream=True, timeout=self.timeout
+            )
+            if (
+                not response.ok
+                or not response.headers.get("Content-Type")
+                == "text/plain; charset=utf-8"
+            ):
+                raise Exception(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
+            streaming_text = ""
+            for value in response.iter_lines(
+                decode_unicode=True,
+                chunk_size=self.stream_chunk_size,
+                delimiter="\n",
+            ):
+                try:
+                    if bool(value):
+                        streaming_text += value + ("\n" if stream else "")
+
+                        resp = dict(text=streaming_text)
+                        self.last_response.update(resp)
+                        yield value if raw else resp
+                except json.decoder.JSONDecodeError:
+                    pass
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+
+        def for_non_stream():
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]
+    @staticmethod
+    def chat_cli(prompt):
+        """Sends a request to the BLACKBOXAI API and processes the response."""
+        blackbox_ai = BLACKBOXAI()  # Initialize a BLACKBOXAI instance
+        response = blackbox_ai.ask(prompt)  # Perform a chat with the given prompt
+        processed_response = blackbox_ai.get_message(response)  # Process the response
+        print(processed_response)
+class AsyncBLACKBOXAI(AsyncProvider):
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        model: str = None,
+    ):
+        """Instantiates BLACKBOXAI
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+            model (str, optional): Model name. Defaults to "Phind Model".
+        """
+        self.max_tokens_to_sample = max_tokens
+        self.is_conversation = is_conversation
+        self.chat_endpoint = "https://www.blackbox.ai/api/chat"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.model = model
+        self.previewToken: str = None
+        self.userId: str = ""
+        self.codeModelMode: bool = True
+        self.id: str = ""
+        self.agentMode: dict = {}
+        self.trendingAgentMode: dict = {}
+        self.isMicMode: bool = False
+
+        self.headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "",
+            "Accept": "*/*",
+            "Accept-Encoding": "Identity",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session = httpx.AsyncClient(headers=self.headers, proxies=proxies)
+
+    async def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict | AsyncGenerator:
+        """Chat with AI asynchronously.
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict|AsyncGenerator : ai content
+        ```json
+        {
+           "text" : "print('How may I help you today?')"
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        payload = {
+            "messages": [
+                # json.loads(prev_messages),
+                {"content": conversation_prompt, "role": "user"}
+            ],
+            "id": self.id,
+            "previewToken": self.previewToken,
+            "userId": self.userId,
+            "codeModelMode": self.codeModelMode,
+            "agentMode": self.agentMode,
+            "trendingAgentMode": self.trendingAgentMode,
+            "isMicMode": self.isMicMode,
+        }
+
+        async def for_stream():
+            async with self.session.stream(
+                "POST", self.chat_endpoint, json=payload, timeout=self.timeout
+            ) as response:
+                if (
+                    not response.is_success
+                    or not response.headers.get("Content-Type")
+                    == "text/plain; charset=utf-8"
+                ):
+                    raise exceptions.FailedToGenerateResponseError(
+                        f"Failed to generate response - ({response.status_code}, {response.reason_phrase})"
+                    )
+                streaming_text = ""
+                async for value in response.aiter_lines():
+                    try:
+                        if bool(value):
+                            streaming_text += value + ("\n" if stream else "")
+                            resp = dict(text=streaming_text)
+                            self.last_response.update(resp)
+                            yield value if raw else resp
+                    except json.decoder.JSONDecodeError:
+                        pass
+            self.conversation.update_chat_history(
+                prompt, await self.get_message(self.last_response)
+            )
+
+        async def for_non_stream():
+            async for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else await for_non_stream()
+
+    async def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str | AsyncGenerator:
+        """Generate response `str` asynchronously.
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str|AsyncGenerator: Response generated
+        """
+
+        async def for_stream():
+            async_ask = await self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            )
+            async for response in async_ask:
+                yield await self.get_message(response)
+
+        async def for_non_stream():
+            return await self.get_message(
+                await self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else await for_non_stream()
+
+    async def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]

webscout/Provider/ChatGPTUK.py

@@ -0,0 +1,214 @@
+import requests
+from typing import Any, AsyncGenerator, Dict, Optional
+import json
+import re
+
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import  Provider, AsyncProvider
+from webscout import exceptions
+
+
+class ChatGPTUK(Provider):
+    """
+    A class to interact with the ChatGPT UK API.
+    """
+
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        temperature: float = 0.9,
+        presence_penalty: float = 0,
+        frequency_penalty: float = 0,
+        top_p: float = 1,
+        model: str = "google-gemini-pro",
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ) -> None:
+        """
+        Initializes the ChatGPTUK API with given parameters.
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True.
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            temperature (float, optional): Charge of the generated text's randomness. Defaults to 0.9.
+            presence_penalty (float, optional): Chances of topic being repeated. Defaults to 0.
+            frequency_penalty (float, optional): Chances of word being repeated. Defaults to 0.
+            top_p (float, optional): Sampling threshold during inference time. Defaults to 1.
+            model (str, optional): LLM model name. Defaults to "google-gemini-pro".
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.session = requests.Session()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.api_endpoint = "https://free.chatgpt.org.uk/api/openai/v1/chat/completions"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.model = model
+        self.temperature = temperature
+        self.presence_penalty = presence_penalty
+        self.frequency_penalty = frequency_penalty
+        self.top_p = top_p
+        self.headers = {"Content-Type": "application/json"}
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(self.headers)
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session.proxies = proxies
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict : {}
+        ```json
+        {
+           "text" : "How may I assist you today?"
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        self.session.headers.update(self.headers)
+        payload = {
+            "messages": [
+                {"role": "system", "content": "Keep your responses long and detailed"},
+                {"role": "user", "content": conversation_prompt}
+            ],
+            "stream": True,
+            "model": self.model,
+            "temperature": self.temperature,
+            "presence_penalty": self.presence_penalty,
+            "frequency_penalty": self.frequency_penalty,
+            "top_p": self.top_p,
+            "max_tokens": self.max_tokens_to_sample
+        }
+
+        def for_stream():
+            response = self.session.post(
+                self.api_endpoint, json=payload, stream=True, timeout=self.timeout
+            )
+            if not response.ok:
+                raise exceptions.FailedToGenerateResponseError(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
+
+            streaming_response = ""
+            for line in response.iter_lines(decode_unicode=True, chunk_size=1):
+                if line:
+                    modified_line = re.sub("data:", "", line)
+                    try:
+                        json_data = json.loads(modified_line)
+                        content = json_data['choices'][0]['delta']['content']
+                        streaming_response += content
+                        yield content if raw else dict(text=streaming_response)
+                    except:
+                        continue
+            self.last_response.update(dict(text=streaming_response))
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+
+        def for_non_stream():
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]

webscout/Provider/Cohere.py

@@ -0,0 +1,223 @@
+import time
+import uuid
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+import click
+import requests
+from requests import get
+from uuid import uuid4
+from re import findall
+from requests.exceptions import RequestException
+from curl_cffi.requests import get, RequestsError
+import g4f
+from random import randint
+from PIL import Image
+import io
+import re
+import json
+import yaml
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import  Provider, AsyncProvider
+from Helpingai_T2 import Perplexity
+from webscout import exceptions
+from typing import Any, AsyncGenerator, Dict
+import logging
+import httpx
+#-----------------------------------------------Cohere--------------------------------------------
+class Cohere(Provider):
+    def __init__(
+        self,
+        api_key: str,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        model: str = "command-r-plus",
+        temperature: float = 0.7,
+        system_prompt: str = "You are helpful AI",
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        top_k: int = -1,
+        top_p: float = 0.999,
+    ):
+        """Initializes Cohere
+
+        Args:
+            api_key (str): Cohere API key.
+            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.
+            model (str, optional): Model to use for generating text. Defaults to "command-r-plus".
+            temperature (float, optional): Diversity of the generated text. Higher values produce more diverse outputs.
+                            Defaults to 0.7.
+            system_prompt (str, optional): A system_prompt or context to set the style or tone of the generated text. 
+                            Defaults to "You are helpful AI".
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.session = requests.Session()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.api_key = api_key
+        self.model = model
+        self.temperature = temperature
+        self.system_prompt = system_prompt
+        self.chat_endpoint = "https://production.api.os.cohere.ai/coral/v1/chat"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(self.headers)
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session.proxies = proxies
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict : {}
+        ```json
+        {
+           "text" : "How may I assist you today?"
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+        self.session.headers.update(self.headers)
+        payload = {
+            "message": conversation_prompt,
+            "model": self.model,
+            "temperature": self.temperature,
+            "preamble": self.system_prompt,
+        }
+
+        def for_stream():
+            response = self.session.post(
+                self.chat_endpoint, json=payload, stream=True, timeout=self.timeout
+            )
+            if not response.ok:
+                raise Exception(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
+
+            for value in response.iter_lines(
+                decode_unicode=True,
+                chunk_size=self.stream_chunk_size,
+            ):
+                try:
+                    resp = json.loads(value.strip().split("\n")[-1])
+                    self.last_response.update(resp)
+                    yield value if raw else resp
+                except json.decoder.JSONDecodeError:
+                    pass
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+
+        def for_non_stream():
+            # let's make use of stream
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["result"]["chatStreamEndEvent"]["response"]["text"]

webscout/Provider/Gemini.py

@@ -0,0 +1,217 @@
+import time
+import uuid
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+import click
+import requests
+from requests import get
+from uuid import uuid4
+from re import findall
+from requests.exceptions import RequestException
+from curl_cffi.requests import get, RequestsError
+import g4f
+from random import randint
+from PIL import Image
+import io
+import re
+import json
+import yaml
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import  Provider, AsyncProvider
+from Helpingai_T2 import Perplexity
+from webscout import exceptions
+from typing import Any, AsyncGenerator, Dict
+import logging
+import httpx    
+from Bard import Chatbot
+import logging
+from os import path
+from json import load
+from json import dumps
+import warnings
+logging.getLogger("httpx").setLevel(logging.ERROR)
+warnings.simplefilter("ignore", category=UserWarning)
+class GEMINI(Provider):
+    def __init__(
+        self,
+        cookie_file: str,
+        proxy: dict = {},
+        timeout: int = 30,
+    ):
+        """Initializes GEMINI
+
+        Args:
+            cookie_file (str): Path to `bard.google.com.cookies.json` file
+            proxy (dict, optional): Http request proxy. Defaults to {}.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+        """
+        self.conversation = Conversation(False)
+        self.session_auth1 = None
+        self.session_auth2 = None
+        assert isinstance(
+            cookie_file, str
+        ), f"cookie_file should be of {str} only not '{type(cookie_file)}'"
+        if path.isfile(cookie_file):
+            # let's assume auth is a path to exported .json cookie-file
+            with open(cookie_file) as fh:
+                entries = load(fh)
+            for entry in entries:
+                if entry["name"] == "__Secure-1PSID":
+                    self.session_auth1 = entry["value"]
+                elif entry["name"] == "__Secure-1PSIDTS":
+                    self.session_auth2 = entry["value"]
+
+            assert all(
+                [self.session_auth1, self.session_auth2]
+            ), f"Failed to extract the required cookie value from file '{cookie_file}'"
+        else:
+            raise Exception(f"{cookie_file} is not a valid file path")
+
+        self.session = Chatbot(self.session_auth1, self.session_auth2, proxy, timeout)
+        self.last_response = {}
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+            Args:
+                prompt (str): Prompt to be send.
+                stream (bool, optional): Flag for streaming response. Defaults to False.
+                raw (bool, optional): Stream back raw response as received. Defaults to False.
+                optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defeaults to None
+                conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+            Returns:
+               dict : {}
+            ```json
+            {
+                "content": "General Kenobi! \n\n(I couldn't help but respond with the iconic Star Wars greeting since you used it first. )\n\nIs there anything I can help you with today?\n[Image of Hello there General Kenobi]",
+                "conversation_id": "c_f13f6217f9a997aa",
+                "response_id": "r_d3665f95975c368f",
+                "factualityQueries": null,
+                "textQuery": [
+                    "hello there",
+                    1
+                    ],
+                "choices": [
+                    {
+                        "id": "rc_ea075c9671bfd8cb",
+                        "content": [
+                            "General Kenobi! \n\n(I couldn't help but respond with the iconic Star Wars greeting since you used it first. )\n\nIs there anything I can help you with today?\n[Image of Hello there General Kenobi]"
+                        ]
+                    },
+                    {
+                        "id": "rc_de6dd3fb793a5402",
+                        "content": [
+                            "General Kenobi! (or just a friendly hello, whichever you prefer!). \n\nI see you're a person of culture as well. *Star Wars* references are always appreciated.  \n\nHow can I help you today?\n"
+                            ]
+                    },
+                {
+                    "id": "rc_a672ac089caf32db",
+                    "content": [
+                        "General Kenobi! (or just a friendly hello if you're not a Star Wars fan!). \n\nHow can I help you today? Feel free to ask me anything, or tell me what you'd like to chat about. I'm here to assist in any way I can.\n[Image of Obi-Wan Kenobi saying hello there]"
+                    ]
+                }
+            ],
+
+            "images": [
+                "https://i.pinimg.com/originals/40/74/60/407460925c9e419d82b93313f0b42f71.jpg"
+            ]
+        }
+
+            ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        def for_stream():
+            response = self.session.ask(prompt)
+            self.last_response.update(response)
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+            yield dumps(response) if raw else response
+
+        def for_non_stream():
+            # let's make use of stream
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["content"]
+
+    def reset(self):
+        """Reset the current conversation"""
+        self.session.async_chatbot.conversation_id = ""
+        self.session.async_chatbot.response_id = ""
+        self.session.async_chatbot.choice_id = ""

webscout/Provider/Groq.py

@@ -0,0 +1,512 @@
+import time
+import uuid
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+import click
+import requests
+from requests import get
+from uuid import uuid4
+from re import findall
+from requests.exceptions import RequestException
+from curl_cffi.requests import get, RequestsError
+import g4f
+from random import randint
+from PIL import Image
+import io
+import re
+import json
+import yaml
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import  Provider, AsyncProvider
+from Helpingai_T2 import Perplexity
+from webscout import exceptions
+from typing import Any, AsyncGenerator, Dict
+import logging
+import httpx
+
+class GROQ(Provider):
+    def __init__(
+        self,
+        api_key: str,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        temperature: float = 1,
+        presence_penalty: int = 0,
+        frequency_penalty: int = 0,
+        top_p: float = 1,
+        model: str = "mixtral-8x7b-32768",
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ):
+        """Instantiates GROQ
+
+        Args:
+            api_key (key): GROQ's API key.
+            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.
+            temperature (float, optional): Charge of the generated text's randomness. Defaults to 1.
+            presence_penalty (int, optional): Chances of topic being repeated. Defaults to 0.
+            frequency_penalty (int, optional): Chances of word being repeated. Defaults to 0.
+            top_p (float, optional): Sampling threshold during inference time. Defaults to 0.999.
+            model (str, optional): LLM model name. Defaults to "gpt-3.5-turbo".
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.session = requests.Session()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.api_key = api_key
+        self.model = model
+        self.temperature = temperature
+        self.presence_penalty = presence_penalty
+        self.frequency_penalty = frequency_penalty
+        self.top_p = top_p
+        self.chat_endpoint = "https://api.groq.com/openai/v1/chat/completions"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(self.headers)
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session.proxies = proxies
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+                Args:
+                    prompt (str): Prompt to be send.
+                    stream (bool, optional): Flag for streaming response. Defaults to False.
+                    raw (bool, optional): Stream back raw response as received. Defaults to False.
+                    optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+                    conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+                Returns:
+                   dict : {}
+                ```json
+        {
+            "id": "c0c8d139-d2b9-9909-8aa1-14948bc28404",
+            "object": "chat.completion",
+            "created": 1710852779,
+            "model": "mixtral-8x7b-32768",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": "Hello! How can I assist you today? I'm here to help answer your questions and engage in conversation on a wide variety of topics. Feel free to ask me anything!"
+                    },
+                    "logprobs": null,
+                    "finish_reason": "stop"
+                }
+            ],
+            "usage": {
+                "prompt_tokens": 47,
+                "prompt_time": 0.03,
+                "completion_tokens": 37,
+                "completion_time": 0.069,
+                "total_tokens": 84,
+                "total_time": 0.099
+            },
+            "system_fingerprint": null
+        }
+                ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+        self.session.headers.update(self.headers)
+        payload = {
+            "frequency_penalty": self.frequency_penalty,
+            "messages": [{"content": conversation_prompt, "role": "user"}],
+            "model": self.model,
+            "presence_penalty": self.presence_penalty,
+            "stream": stream,
+            "temperature": self.temperature,
+            "top_p": self.top_p,
+        }
+
+        def for_stream():
+            response = self.session.post(
+                self.chat_endpoint, json=payload, stream=True, timeout=self.timeout
+            )
+            if not response.ok:
+                raise Exception(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
+
+            message_load = ""
+            for value in response.iter_lines(
+                decode_unicode=True,
+                delimiter="" if raw else "data:",
+                chunk_size=self.stream_chunk_size,
+            ):
+                try:
+                    resp = json.loads(value)
+                    incomplete_message = self.get_message(resp)
+                    if incomplete_message:
+                        message_load += incomplete_message
+                        resp["choices"][0]["delta"]["content"] = message_load
+                        self.last_response.update(resp)
+                        yield value if raw else resp
+                    elif raw:
+                        yield value
+                except json.decoder.JSONDecodeError:
+                    pass
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+
+        def for_non_stream():
+            response = self.session.post(
+                self.chat_endpoint, json=payload, stream=False, timeout=self.timeout
+            )
+            if not response.ok:
+                raise Exception(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
+            resp = response.json()
+            self.last_response.update(resp)
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+            return resp
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        try:
+            if response["choices"][0].get("delta"):
+                return response["choices"][0]["delta"]["content"]
+            return response["choices"][0]["message"]["content"]
+        except KeyError:
+            return ""
+class AsyncGROQ(AsyncProvider):
+    def __init__(
+        self,
+        api_key: str,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        temperature: float = 1,
+        presence_penalty: int = 0,
+        frequency_penalty: int = 0,
+        top_p: float = 1,
+        model: str = "mixtral-8x7b-32768",
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ):
+        """Instantiates GROQ
+
+        Args:
+            api_key (key): GROQ's API key.
+            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.
+            temperature (float, optional): Charge of the generated text's randomness. Defaults to 1.
+            presence_penalty (int, optional): Chances of topic being repeated. Defaults to 0.
+            frequency_penalty (int, optional): Chances of word being repeated. Defaults to 0.
+            top_p (float, optional): Sampling threshold during inference time. Defaults to 0.999.
+            model (str, optional): LLM model name. Defaults to "gpt-3.5-turbo".
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.api_key = api_key
+        self.model = model
+        self.temperature = temperature
+        self.presence_penalty = presence_penalty
+        self.frequency_penalty = frequency_penalty
+        self.top_p = top_p
+        self.chat_endpoint = "https://api.groq.com/openai/v1/chat/completions"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session = httpx.AsyncClient(headers=self.headers, proxies=proxies)
+
+    async def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict | AsyncGenerator:
+        """Chat with AI asynchronously.
+
+                Args:
+                    prompt (str): Prompt to be send.
+                    stream (bool, optional): Flag for streaming response. Defaults to False.
+                    raw (bool, optional): Stream back raw response as received. Defaults to False.
+                    optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+                    conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+                Returns:
+                   dict|AsyncGenerator : ai content
+                ```json
+        {
+            "id": "c0c8d139-d2b9-9909-8aa1-14948bc28404",
+            "object": "chat.completion",
+            "created": 1710852779,
+            "model": "mixtral-8x7b-32768",
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": "Hello! How can I assist you today? I'm here to help answer your questions and engage in conversation on a wide variety of topics. Feel free to ask me anything!"
+                    },
+                    "logprobs": null,
+                    "finish_reason": "stop"
+                }
+            ],
+            "usage": {
+                "prompt_tokens": 47,
+                "prompt_time": 0.03,
+                "completion_tokens": 37,
+                "completion_time": 0.069,
+                "total_tokens": 84,
+                "total_time": 0.099
+            },
+            "system_fingerprint": null
+        }
+                ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+        payload = {
+            "frequency_penalty": self.frequency_penalty,
+            "messages": [{"content": conversation_prompt, "role": "user"}],
+            "model": self.model,
+            "presence_penalty": self.presence_penalty,
+            "stream": stream,
+            "temperature": self.temperature,
+            "top_p": self.top_p,
+        }
+
+        async def for_stream():
+            async with self.session.stream(
+                "POST", self.chat_endpoint, json=payload, timeout=self.timeout
+            ) as response:
+                if not response.is_success:
+                    raise Exception(
+                        f"Failed to generate response - ({response.status_code}, {response.reason_phrase})"
+                    )
+
+                message_load = ""
+                intro_value = "data:"
+                async for value in response.aiter_lines():
+                    try:
+                        if value.startswith(intro_value):
+                            value = value[len(intro_value) :]
+                        resp = json.loads(value)
+                        incomplete_message = await self.get_message(resp)
+                        if incomplete_message:
+                            message_load += incomplete_message
+                            resp["choices"][0]["delta"]["content"] = message_load
+                            self.last_response.update(resp)
+                            yield value if raw else resp
+                        elif raw:
+                            yield value
+                    except json.decoder.JSONDecodeError:
+                        pass
+            self.conversation.update_chat_history(
+                prompt, await self.get_message(self.last_response)
+            )
+
+        async def for_non_stream():
+            response = httpx.post(
+                self.chat_endpoint, json=payload, timeout=self.timeout
+            )
+            if not response.is_success:
+                raise Exception(
+                    f"Failed to generate response - ({response.status_code}, {response.reason_phrase})"
+                )
+            resp = response.json()
+            self.last_response.update(resp)
+            self.conversation.update_chat_history(
+                prompt, await self.get_message(self.last_response)
+            )
+            return resp
+
+        return for_stream() if stream else await for_non_stream()
+
+    async def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str | AsyncGenerator:
+        """Generate response `str` asynchronously.
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str|AsyncGenerator: Response generated
+        """
+
+        async def for_stream():
+            async_ask = await self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            )
+            async for response in async_ask:
+                yield await self.get_message(response)
+
+        async def for_non_stream():
+            return await self.get_message(
+                await self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else await for_non_stream()
+
+    async def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        try:
+            if response["choices"][0].get("delta"):
+                return response["choices"][0]["delta"]["content"]
+            return response["choices"][0]["message"]["content"]
+        except KeyError:
+            return ""

webscout/Provider/Koboldai.py

@@ -0,0 +1,402 @@
+import time
+import uuid
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+import click
+import requests
+from requests import get
+from uuid import uuid4
+from re import findall
+from requests.exceptions import RequestException
+from curl_cffi.requests import get, RequestsError
+import g4f
+from random import randint
+from PIL import Image
+import io
+import re
+import json
+import yaml
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import  Provider, AsyncProvider
+from Helpingai_T2 import Perplexity
+from webscout import exceptions
+from typing import Any, AsyncGenerator, Dict
+import logging
+import httpx
+#------------------------------------------------------KOBOLDAI-----------------------------------------------------------
+class KOBOLDAI(Provider):
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        temperature: float = 1,
+        top_p: float = 1,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ):
+        """Instantiate TGPT
+
+        Args:
+            is_conversation (str, optional): Flag for chatting conversationally. Defaults to True.
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            temperature (float, optional): Charge of the generated text's randomness. Defaults to 0.2.
+            top_p (float, optional): Sampling threshold during inference time. Defaults to 0.999.
+            timeout (int, optional): Http requesting timeout. Defaults to 30
+            intro (str, optional): Conversation introductory prompt. Defaults to `Conversation.intro`.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional) : Http reqiuest proxies (socks). Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.session = requests.Session()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.temperature = temperature
+        self.top_p = top_p
+        self.chat_endpoint = (
+            "https://koboldai-koboldcpp-tiefighter.hf.space/api/extra/generate/stream"
+        )
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(self.headers)
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session.proxies = proxies
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict : {}
+        ```json
+        {
+           "token" : "How may I assist you today?"
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        self.session.headers.update(self.headers)
+        payload = {
+            "prompt": conversation_prompt,
+            "temperature": self.temperature,
+            "top_p": self.top_p,
+        }
+
+        def for_stream():
+            response = self.session.post(
+                self.chat_endpoint, json=payload, stream=True, timeout=self.timeout
+            )
+            if not response.ok:
+                raise Exception(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
+
+            message_load = ""
+            for value in response.iter_lines(
+                decode_unicode=True,
+                delimiter="" if raw else "event: message\ndata:",
+                chunk_size=self.stream_chunk_size,
+            ):
+                try:
+                    resp = json.loads(value)
+                    message_load += self.get_message(resp)
+                    resp["token"] = message_load
+                    self.last_response.update(resp)
+                    yield value if raw else resp
+                except json.decoder.JSONDecodeError:
+                    pass
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+
+        def for_non_stream():
+            # let's make use of stream
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response.get("token")
+class AsyncKOBOLDAI(AsyncProvider):
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        temperature: float = 1,
+        top_p: float = 1,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ):
+        """Instantiate TGPT
+
+        Args:
+            is_conversation (str, optional): Flag for chatting conversationally. Defaults to True.
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            temperature (float, optional): Charge of the generated text's randomness. Defaults to 0.2.
+            top_p (float, optional): Sampling threshold during inference time. Defaults to 0.999.
+            timeout (int, optional): Http requesting timeout. Defaults to 30
+            intro (str, optional): Conversation introductory prompt. Defaults to `Conversation.intro`.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional) : Http reqiuest proxies (socks). Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.temperature = temperature
+        self.top_p = top_p
+        self.chat_endpoint = (
+            "https://koboldai-koboldcpp-tiefighter.hf.space/api/extra/generate/stream"
+        )
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session = httpx.AsyncClient(headers=self.headers, proxies=proxies)
+
+    async def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict | AsyncGenerator:
+        """Chat with AI asynchronously.
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict|AsyncGenerator : ai content
+        ```json
+        {
+           "token" : "How may I assist you today?"
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        payload = {
+            "prompt": conversation_prompt,
+            "temperature": self.temperature,
+            "top_p": self.top_p,
+        }
+
+        async def for_stream():
+            async with self.session.stream(
+                "POST", self.chat_endpoint, json=payload, timeout=self.timeout
+            ) as response:
+                if not response.is_success:
+                    raise exceptions.FailedToGenerateResponseError(
+                        f"Failed to generate response - ({response.status_code}, {response.reason_phrase})"
+                    )
+
+                message_load = ""
+                async for value in response.aiter_lines():
+                    try:
+                        resp = sanitize_stream(value)
+                        message_load += await self.get_message(resp)
+                        resp["token"] = message_load
+                        self.last_response.update(resp)
+                        yield value if raw else resp
+                    except json.decoder.JSONDecodeError:
+                        pass
+
+            self.conversation.update_chat_history(
+                prompt, await self.get_message(self.last_response)
+            )
+
+        async def for_non_stream():
+            # let's make use of stream
+            async for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else await for_non_stream()
+
+    async def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str | AsyncGenerator:
+        """Generate response `str` asynchronously.
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        async def for_stream():
+            async_ask = await self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            )
+            async for response in async_ask:
+                yield await self.get_message(response)
+
+        async def for_non_stream():
+            return await self.get_message(
+                await self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else await for_non_stream()
+
+    async def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response.get("token")

webscout/Provider/Leo.py

@@ -0,0 +1,469 @@
+import time
+import uuid
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+import click
+import requests
+from requests import get
+from uuid import uuid4
+from re import findall
+from requests.exceptions import RequestException
+from curl_cffi.requests import get, RequestsError
+import g4f
+from random import randint
+from PIL import Image
+import io
+import re
+import json
+import yaml
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import  Provider, AsyncProvider
+from Helpingai_T2 import Perplexity
+from webscout import exceptions
+from typing import Any, AsyncGenerator, Dict
+import logging
+import httpx
+#--------------------------------------LEO-----------------------------------------
+class LEO(Provider):
+    
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        temperature: float = 0.2,
+        top_k: int = -1,
+        top_p: float = 0.999,
+        model: str = "llama-2-13b-chat",
+        brave_key: str = "qztbjzBqJueQZLFkwTTJrieu8Vw3789u",
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ):
+        """Instantiate TGPT
+
+        Args:
+            is_conversation (str, optional): Flag for chatting conversationally. Defaults to True.
+            brave_key (str, optional): Brave API access key. Defaults to "qztbjzBqJueQZLFkwTTJrieu8Vw3789u".
+            model (str, optional): Text generation model name. Defaults to "llama-2-13b-chat".
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            temperature (float, optional): Charge of the generated text's randomness. Defaults to 0.2.
+            top_k (int, optional): Chance of topic being repeated. Defaults to -1.
+            top_p (float, optional): Sampling threshold during inference time. Defaults to 0.999.
+            timeput (int, optional): Http requesting timeout. Defaults to 30
+            intro (str, optional): Conversation introductory prompt. Defaults to `Conversation.intro`.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional) : Http reqiuest proxies (socks). Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.session = requests.Session()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.model = model
+        self.stop_sequences = ["</response>", "</s>"]
+        self.temperature = temperature
+        self.top_k = top_k
+        self.top_p = top_p
+        self.chat_endpoint = "https://ai-chat.bsg.brave.com/v1/complete"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.headers = {
+            "Content-Type": "application/json",
+            "accept": "text/event-stream",
+            "x-brave-key": brave_key,
+            "accept-language": "en-US,en;q=0.9",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:99.0) Gecko/20100101 Firefox/110.0",
+        }
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(self.headers)
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session.proxies = proxies
+        self.system_prompt = (
+            "\n\nYour name is Leo, a helpful"
+            "respectful and honest AI assistant created by the company Brave. You will be replying to a user of the Brave browser. "
+            "Always respond in a neutral tone. Be polite and courteous. Answer concisely in no more than 50-80 words."
+            "\n\nPlease ensure that your responses are socially unbiased and positive in nature."
+            "If a question does not make any sense, or is not factually coherent, explain why instead of answering something not correct. "
+            "If you don't know the answer to a question, please don't share false information.\n"
+        )
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict : {}
+        ```json
+        {
+            "completion": "\nNext: domestic cat breeds with short hair >>",
+            "stop_reason": null,
+            "truncated": false,
+            "stop": null,
+            "model": "llama-2-13b-chat",
+            "log_id": "cmpl-3kYiYxSNDvgMShSzFooz6t",
+            "exception": null
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        self.session.headers.update(self.headers)
+        payload = {
+            "max_tokens_to_sample": self.max_tokens_to_sample,
+            "model": self.model,
+            "prompt": f"<s>[INST] <<SYS>>{self.system_prompt}<</SYS>>{conversation_prompt} [/INST]",
+            "self.stop_sequence": self.stop_sequences,
+            "stream": stream,
+            "top_k": self.top_k,
+            "top_p": self.top_p,
+        }
+
+        def for_stream():
+            response = self.session.post(
+                self.chat_endpoint, json=payload, stream=True, timeout=self.timeout
+            )
+            if (
+                not response.ok
+                or not response.headers.get("Content-Type")
+                == "text/event-stream; charset=utf-8"
+            ):
+                raise Exception(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
+
+            for value in response.iter_lines(
+                decode_unicode=True,
+                delimiter="" if raw else "data:",
+                chunk_size=self.stream_chunk_size,
+            ):
+                try:
+                    resp = json.loads(value)
+                    self.last_response.update(resp)
+                    yield value if raw else resp
+                except json.decoder.JSONDecodeError:
+                    pass
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+
+        def for_non_stream():
+            response = self.session.post(
+                self.chat_endpoint, json=payload, stream=False, timeout=self.timeout
+            )
+            if (
+                not response.ok
+                or not response.headers.get("Content-Type", "") == "application/json"
+            ):
+                raise Exception(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
+            resp = response.json()
+            self.last_response.update(resp)
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+            return resp
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response.get("completion")
+class AsyncLEO(AsyncProvider):
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        temperature: float = 0.2,
+        top_k: int = -1,
+        top_p: float = 0.999,
+        model: str = "llama-2-13b-chat",
+        brave_key: str = "qztbjzBqJueQZLFkwTTJrieu8Vw3789u",
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ):
+        """Instantiate TGPT
+
+        Args:
+            is_conversation (str, optional): Flag for chatting conversationally. Defaults to True.
+            brave_key (str, optional): Brave API access key. Defaults to "qztbjzBqJueQZLFkwTTJrieu8Vw3789u".
+            model (str, optional): Text generation model name. Defaults to "llama-2-13b-chat".
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            temperature (float, optional): Charge of the generated text's randomness. Defaults to 0.2.
+            top_k (int, optional): Chance of topic being repeated. Defaults to -1.
+            top_p (float, optional): Sampling threshold during inference time. Defaults to 0.999.
+            timeput (int, optional): Http requesting timeout. Defaults to 30
+            intro (str, optional): Conversation introductory prompt. Defaults to `Conversation.intro`.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional) : Http reqiuest proxies (socks). Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.model = model
+        self.stop_sequences = ["</response>", "</s>"]
+        self.temperature = temperature
+        self.top_k = top_k
+        self.top_p = top_p
+        self.chat_endpoint = "https://ai-chat.bsg.brave.com/v1/complete"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.headers = {
+            "Content-Type": "application/json",
+            "accept": "text/event-stream",
+            "x-brave-key": brave_key,
+            "accept-language": "en-US,en;q=0.9",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:99.0) Gecko/20100101 Firefox/110.0",
+        }
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.system_prompt = (
+            "\n\nYour name is Leo, a helpful"
+            "respectful and honest AI assistant created by the company Brave. You will be replying to a user of the Brave browser. "
+            "Always respond in a neutral tone. Be polite and courteous. Answer concisely in no more than 50-80 words."
+            "\n\nPlease ensure that your responses are socially unbiased and positive in nature."
+            "If a question does not make any sense, or is not factually coherent, explain why instead of answering something not correct. "
+            "If you don't know the answer to a question, please don't share false information.\n"
+        )
+        self.session = httpx.AsyncClient(headers=self.headers, proxies=proxies)
+
+    async def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict | AsyncGenerator:
+        """Chat with AI asynchronously.
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict|AsyncGenerator : ai content
+        ```json
+        {
+            "completion": "\nNext: domestic cat breeds with short hair >>",
+            "stop_reason": null,
+            "truncated": false,
+            "stop": null,
+            "model": "llama-2-13b-chat",
+            "log_id": "cmpl-3kYiYxSNDvgMShSzFooz6t",
+            "exception": null
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        payload = {
+            "max_tokens_to_sample": self.max_tokens_to_sample,
+            "model": self.model,
+            "prompt": f"<s>[INST] <<SYS>>{self.system_prompt}<</SYS>>{conversation_prompt} [/INST]",
+            "self.stop_sequence": self.stop_sequences,
+            "stream": stream,
+            "top_k": self.top_k,
+            "top_p": self.top_p,
+        }
+
+        async def for_stream():
+            async with self.session.stream(
+                "POST", self.chat_endpoint, json=payload, timeout=self.timeout
+            ) as response:
+                if (
+                    not response.is_success
+                    or not response.headers.get("Content-Type")
+                    == "text/event-stream; charset=utf-8"
+                ):
+                    raise exceptions.FailedToGenerateResponseError(
+                        f"Failed to generate response - ({response.status_code}, {response.reason_phrase})"
+                    )
+                async for value in response.aiter_lines():
+                    try:
+                        resp = sanitize_stream(value)
+                        self.last_response.update(resp)
+                        yield value if raw else resp
+                    except json.decoder.JSONDecodeError:
+                        pass
+
+            self.conversation.update_chat_history(
+                prompt, await self.get_message(self.last_response)
+            )
+
+        async def for_non_stream():
+            async for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else await for_non_stream()
+
+    async def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str | AsyncGenerator:
+        """Generate response `str` asynchronously.
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str|AsyncGenerator: Response generated
+        """
+
+        async def for_stream():
+            async_ask = await self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            )
+            async for response in async_ask:
+                yield await self.get_message(response)
+
+        async def for_non_stream():
+            return await self.get_message(
+                await self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else await for_non_stream()
+
+    async def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response.get("completion")

webscout/Provider/Llama2.py

@@ -0,0 +1,437 @@
+import time
+import uuid
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+import click
+import requests
+from requests import get
+from uuid import uuid4
+from re import findall
+from requests.exceptions import RequestException
+from curl_cffi.requests import get, RequestsError
+import g4f
+from random import randint
+from PIL import Image
+import io
+import re
+import json
+import yaml
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import  Provider, AsyncProvider
+from Helpingai_T2 import Perplexity
+from webscout import exceptions
+from typing import Any, AsyncGenerator, Dict
+import logging
+import httpx
+
+class AsyncLLAMA2(AsyncProvider):
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 800,
+        temperature: float = 0.75,
+        presence_penalty: int = 0,
+        frequency_penalty: int = 0,
+        top_p: float = 0.9,
+        model: str = "meta/meta-llama-3-70b-instruct",
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ):
+        """Instantiates LLAMA2
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True.
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 800.
+            temperature (float, optional): Charge of the generated text's randomness. Defaults to 0.75.
+            presence_penalty (int, optional): Chances of topic being repeated. Defaults to 0.
+            frequency_penalty (int, optional): Chances of word being repeated. Defaults to 0.
+            top_p (float, optional): Sampling threshold during inference time. Defaults to 0.9.
+            model (str, optional): LLM model name. Defaults to "meta/llama-2-70b-chat".
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.model = model
+        self.temperature = temperature
+        self.presence_penalty = presence_penalty
+        self.frequency_penalty = frequency_penalty
+        self.top_p = top_p
+        self.chat_endpoint = "https://www.llama2.ai/api"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.headers = {
+            "Content-Type": "application/json",
+            "Referer": "https://www.llama2.ai/",
+            "Content-Type": "text/plain;charset=UTF-8",
+            "Origin": "https://www.llama2.ai",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session = httpx.AsyncClient(
+            headers=self.headers,
+            proxies=proxies,
+        )
+
+    async def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict | AsyncGenerator:
+        """Chat with AI asynchronously.
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict|AsyncGeneraror[dict] : ai content
+        ```json
+        {
+           "text" : "How may I help you today?"
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        payload = {
+            "prompt": f"{conversation_prompt}<s>[INST] {prompt} [/INST]",
+            "model": self.model,
+            "systemPrompt": "You are a helpful assistant.",
+            "temperature": self.temperature,
+            "topP": self.top_p,
+            "maxTokens": self.max_tokens_to_sample,
+            "image": None,
+            "audio": None,
+        }
+
+        async def for_stream():
+            async with self.session.stream(
+                "POST", self.chat_endpoint, json=payload, timeout=self.timeout
+            ) as response:
+                if (
+                    not response.is_success
+                    or not response.headers.get("Content-Type")
+                    == "text/plain; charset=utf-8"
+                ):
+                    raise exceptions.FailedToGenerateResponseError(
+                        f"Failed to generate response - ({response.status_code}, {response.reason_phrase})"
+                    )
+                message_load: str = ""
+                async for value in response.aiter_lines():
+                    try:
+                        if bool(value.strip()):
+                            message_load += value + "\n"
+                            resp: dict = dict(text=message_load)
+                            yield value if raw else resp
+                            self.last_response.update(resp)
+                    except json.decoder.JSONDecodeError:
+                        pass
+            self.conversation.update_chat_history(
+                prompt, await self.get_message(self.last_response)
+            )
+
+        async def for_non_stream():
+            async for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else await for_non_stream()
+
+    async def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str | AsyncGenerator:
+        """Generate response `str` asynchronously.
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str|AsyncGenerator: Response generated
+        """
+
+        async def for_stream():
+            async_ask = await self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            )
+            async for response in async_ask:
+                yield await self.get_message(response)
+
+        async def for_non_stream():
+            return await self.get_message(
+                await self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else await for_non_stream()
+
+    async def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (str): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]
+class LLAMA2(Provider):
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 800,
+        temperature: float = 0.75,
+        presence_penalty: int = 0,
+        frequency_penalty: int = 0,
+        top_p: float = 0.9,
+        model: str = "meta/meta-llama-3-70b-instruct",
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ):
+        """Instantiates LLAMA2
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True.
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 800.
+            temperature (float, optional): Charge of the generated text's randomness. Defaults to 0.75.
+            presence_penalty (int, optional): Chances of topic being repeated. Defaults to 0.
+            frequency_penalty (int, optional): Chances of word being repeated. Defaults to 0.
+            top_p (float, optional): Sampling threshold during inference time. Defaults to 0.9.
+            model (str, optional): LLM model name. Defaults to "meta/llama-2-70b-chat".
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.session = requests.Session()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.model = model
+        self.temperature = temperature
+        self.presence_penalty = presence_penalty
+        self.frequency_penalty = frequency_penalty
+        self.top_p = top_p
+        self.chat_endpoint = "https://www.llama2.ai/api"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.headers = {
+            "Content-Type": "application/json",
+            "Referer": "https://www.llama2.ai/",
+            "Content-Type": "text/plain;charset=UTF-8",
+            "Origin": "https://www.llama2.ai",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(self.headers)
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session.proxies = proxies
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict : {}
+        ```json
+        {
+           "text" : "How may I help you today?"
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+        self.session.headers.update(self.headers)
+
+        payload = {
+            "prompt": f"{conversation_prompt}<s>[INST] {prompt} [/INST]",
+            "model": self.model,
+            "systemPrompt": "You are a helpful assistant.",
+            "temperature": self.temperature,
+            "topP": self.top_p,
+            "maxTokens": self.max_tokens_to_sample,
+            "image": None,
+            "audio": None,
+        }
+
+        def for_stream():
+            response = self.session.post(
+                self.chat_endpoint, json=payload, stream=True, timeout=self.timeout
+            )
+            if (
+                not response.ok
+                or not response.headers.get("Content-Type")
+                == "text/plain; charset=utf-8"
+            ):
+                raise exceptions.FailedToGenerateResponseError(
+                    f"Failed to generate response - ({response.status_code}, {response.reason})"
+                )
+
+            message_load: str = ""
+            for value in response.iter_lines(
+                decode_unicode=True,
+                delimiter="\n",
+                chunk_size=self.stream_chunk_size,
+            ):
+                try:
+                    if bool(value.strip()):
+                        message_load += value + "\n"
+                        resp: dict = dict(text=message_load)
+                        yield value if raw else resp
+                        self.last_response.update(resp)
+                except json.decoder.JSONDecodeError:
+                    pass
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+
+        def for_non_stream():
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (str): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]

webscout/Provider/OpenGPT.py

@@ -0,0 +1,487 @@
+import time
+import uuid
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+import click
+import requests
+from requests import get
+from uuid import uuid4
+from re import findall
+from requests.exceptions import RequestException
+from curl_cffi.requests import get, RequestsError
+import g4f
+from random import randint
+from PIL import Image
+import io
+import re
+import json
+import yaml
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import  Provider, AsyncProvider
+from Helpingai_T2 import Perplexity
+from webscout import exceptions
+from typing import Any, AsyncGenerator, Dict
+import logging
+import httpx
+#------------------------------------------------------OpenGPT-----------------------------------------------------------
+class OPENGPT:
+    def __init__(
+        self,
+        assistant_id,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ):
+        """Instantiates OPENGPT
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.session = requests.Session()
+        self.max_tokens_to_sample = max_tokens
+        self.is_conversation = is_conversation
+        self.chat_endpoint = (
+            "https://opengpts-example-vz4y4ooboq-uc.a.run.app/runs/stream"
+        )
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.assistant_id = assistant_id
+        self.authority = "opengpts-example-vz4y4ooboq-uc.a.run.app"
+
+        self.headers = {
+            "authority": self.authority,
+            "accept": "text/event-stream",
+            "accept-language": "en-US,en;q=0.7",
+            "cache-control": "no-cache",
+            "content-type": "application/json",
+            "origin": "https://opengpts-example-vz4y4ooboq-uc.a.run.app",
+            "pragma": "no-cache",
+            "referer": "https://opengpts-example-vz4y4ooboq-uc.a.run.app/",
+            "sec-fetch-site": "same-origin",
+            "sec-gpc": "1",
+            "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(self.headers)
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session.proxies = proxies
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict : {}
+        ```json
+        {
+            "messages": [
+                {
+                    "content": "Hello there",
+                    "additional_kwargs": {},
+                    "type": "human",
+                    "example": false
+                },
+                {
+                    "content": "Hello! How can I assist you today?",
+                    "additional_kwargs": {
+                    "agent": {
+                        "return_values": {
+                            "output": "Hello! How can I assist you today?"
+                            },
+                        "log": "Hello! How can I assist you today?",
+                        "type": "AgentFinish"
+                    }
+                },
+                "type": "ai",
+                "example": false
+                }]
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        self.session.headers.update(self.headers)
+        self.session.headers.update(
+            dict(
+                cookie=f"opengpts_user_id={uuid4().__str__()}",
+            )
+        )
+        payload = {
+            "input": [
+                {
+                    "content": conversation_prompt,
+                    "additional_kwargs": {},
+                    "type": "human",
+                    "example": False,
+                },
+            ],
+            "assistant_id": self.assistant_id,
+            "thread_id": "",
+        }
+
+        def for_stream():
+            response = self.session.post(
+                self.chat_endpoint, json=payload, stream=True, timeout=self.timeout
+            )
+            if (
+                not response.ok
+                or not response.headers.get("Content-Type")
+                == "text/event-stream; charset=utf-8"
+            ):
+                raise Exception(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
+
+            for value in response.iter_lines(
+                decode_unicode=True,
+                chunk_size=self.stream_chunk_size,
+            ):
+                try:
+                    modified_value = re.sub("data:", "", value)
+                    resp = json.loads(modified_value)
+                    if len(resp) == 1:
+                        continue
+                    self.last_response.update(resp[1])
+                    yield value if raw else resp[1]
+                except json.decoder.JSONDecodeError:
+                    pass
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+
+        def for_non_stream():
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["content"]
+class AsyncOPENGPT(AsyncProvider):
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ):
+        """Instantiates OPENGPT
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.max_tokens_to_sample = max_tokens
+        self.is_conversation = is_conversation
+        self.chat_endpoint = (
+            "https://opengpts-example-vz4y4ooboq-uc.a.run.app/runs/stream"
+        )
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.assistant_id = "bca37014-6f97-4f2b-8928-81ea8d478d88"
+        self.authority = "opengpts-example-vz4y4ooboq-uc.a.run.app"
+
+        self.headers = {
+            "authority": self.authority,
+            "accept": "text/event-stream",
+            "accept-language": "en-US,en;q=0.7",
+            "cache-control": "no-cache",
+            "content-type": "application/json",
+            "origin": "https://opengpts-example-vz4y4ooboq-uc.a.run.app",
+            "pragma": "no-cache",
+            "referer": "https://opengpts-example-vz4y4ooboq-uc.a.run.app/",
+            "sec-fetch-site": "same-origin",
+            "sec-gpc": "1",
+            "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session = httpx.AsyncClient(headers=self.headers, proxies=proxies)
+
+    async def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict | AsyncGenerator:
+        """Chat with AI asynchronously
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict|AsyncGenerator : ai content.
+        ```json
+        {
+            "messages": [
+                {
+                    "content": "Hello there",
+                    "additional_kwargs": {},
+                    "type": "human",
+                    "example": false
+                },
+                {
+                    "content": "Hello! How can I assist you today?",
+                    "additional_kwargs": {
+                    "agent": {
+                        "return_values": {
+                            "output": "Hello! How can I assist you today?"
+                            },
+                        "log": "Hello! How can I assist you today?",
+                        "type": "AgentFinish"
+                    }
+                },
+                "type": "ai",
+                "example": false
+                }]
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+        self.headers.update(
+            dict(
+                cookie=f"opengpts_user_id={uuid4().__str__()}",
+            )
+        )
+        payload = {
+            "input": [
+                {
+                    "content": conversation_prompt,
+                    "additional_kwargs": {},
+                    "type": "human",
+                    "example": False,
+                },
+            ],
+            "assistant_id": self.assistant_id,
+            "thread_id": "",
+        }
+
+        async def for_stream():
+            async with self.session.stream(
+                "POST",
+                self.chat_endpoint,
+                json=payload,
+                timeout=self.timeout,
+                headers=self.headers,
+            ) as response:
+                if (
+                    not response.is_success
+                    or not response.headers.get("Content-Type")
+                    == "text/event-stream; charset=utf-8"
+                ):
+                    raise exceptions.FailedToGenerateResponseError(
+                        f"Failed to generate response - ({response.status_code}, {response.reason_phrase}) - {response.text}"
+                    )
+
+                async for value in response.aiter_lines():
+                    try:
+                        modified_value = re.sub("data:", "", value)
+                        resp = json.loads(modified_value)
+                        if len(resp) == 1:
+                            continue
+                        self.last_response.update(resp[1])
+                        yield value if raw else resp[1]
+                    except json.decoder.JSONDecodeError:
+                        pass
+
+            self.conversation.update_chat_history(
+                prompt, await self.get_message(self.last_response)
+            )
+
+        async def for_non_stream():
+            async for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else await for_non_stream()
+
+    async def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str | AsyncGenerator:
+        """Generate response `str` asynchronously.
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str|AsyncGenerator: Response generated
+        """
+
+        async def for_stream():
+            async_ask = await self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            )
+            async for response in async_ask:
+                yield await self.get_message(response)
+
+        async def for_non_stream():
+            return await self.get_message(
+                await self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else await for_non_stream()
+
+    async def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["content"]

webscout/Provider/Openai.py

@@ -0,0 +1,511 @@
+import time
+import uuid
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+import click
+import requests
+from requests import get
+from uuid import uuid4
+from re import findall
+from requests.exceptions import RequestException
+from curl_cffi.requests import get, RequestsError
+import g4f
+from random import randint
+from PIL import Image
+import io
+import re
+import json
+import yaml
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import  Provider, AsyncProvider
+from Helpingai_T2 import Perplexity
+from webscout import exceptions
+from typing import Any, AsyncGenerator, Dict
+import logging
+import httpx
+#----------------------------------------------------------OpenAI-----------------------------------
+class OPENAI(Provider):
+    def __init__(
+        self,
+        api_key: str,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        temperature: float = 1,
+        presence_penalty: int = 0,
+        frequency_penalty: int = 0,
+        top_p: float = 1,
+        model: str = "gpt-3.5-turbo",
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ):
+        """Instantiates OPENAI
+
+        Args:
+            api_key (key): OpenAI's API key.
+            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.
+            temperature (float, optional): Charge of the generated text's randomness. Defaults to 1.
+            presence_penalty (int, optional): Chances of topic being repeated. Defaults to 0.
+            frequency_penalty (int, optional): Chances of word being repeated. Defaults to 0.
+            top_p (float, optional): Sampling threshold during inference time. Defaults to 0.999.
+            model (str, optional): LLM model name. Defaults to "gpt-3.5-turbo".
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.api_key = api_key
+        self.model = model
+        self.temperature = temperature
+        self.presence_penalty = presence_penalty
+        self.frequency_penalty = frequency_penalty
+        self.top_p = top_p
+        self.chat_endpoint = "https://api.openai.com/v1/chat/completions"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(self.headers)
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session.proxies = proxies
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict : {}
+        ```json
+        {
+            "id": "chatcmpl-TaREJpBZsRVQFRFic1wIA7Q7XfnaD",
+            "object": "chat.completion",
+            "created": 1704623244,
+            "model": "gpt-3.5-turbo",
+            "usage": {
+                "prompt_tokens": 0,
+                "completion_tokens": 0,
+                "total_tokens": 0
+                },
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "Hello! How can I assist you today?"
+                },
+                "finish_reason": "stop",
+                "index": 0
+                }
+            ]
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise exceptions.FailedToGenerateResponseError(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+        self.session.headers.update(self.headers)
+        payload = {
+            "frequency_penalty": self.frequency_penalty,
+            "messages": [{"content": conversation_prompt, "role": "user"}],
+            "model": self.model,
+            "presence_penalty": self.presence_penalty,
+            "stream": stream,
+            "temperature": self.temperature,
+            "top_p": self.top_p,
+        }
+
+        def for_stream():
+            response = self.session.post(
+                self.chat_endpoint, json=payload, stream=True, timeout=self.timeout
+            )
+            if not response.ok:
+                raise exceptions.FailedToGenerateResponseError(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
+
+            message_load = ""
+            for value in response.iter_lines(
+                decode_unicode=True,
+                delimiter="" if raw else "data:",
+                chunk_size=self.stream_chunk_size,
+            ):
+                try:
+                    resp = json.loads(value)
+                    incomplete_message = self.get_message(resp)
+                    if incomplete_message:
+                        message_load += incomplete_message
+                        resp["choices"][0]["delta"]["content"] = message_load
+                        self.last_response.update(resp)
+                        yield value if raw else resp
+                    elif raw:
+                        yield value
+                except json.decoder.JSONDecodeError:
+                    pass
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+
+        def for_non_stream():
+            response = self.session.post(
+                self.chat_endpoint, json=payload, stream=False, timeout=self.timeout
+            )
+            if (
+                not response.ok
+                or not response.headers.get("Content-Type", "") == "application/json"
+            ):
+                raise exceptions.FailedToGenerateResponseError(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
+            resp = response.json()
+            self.last_response.update(resp)
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+            return resp
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        try:
+            if response["choices"][0].get("delta"):
+                return response["choices"][0]["delta"]["content"]
+            return response["choices"][0]["message"]["content"]
+        except KeyError:
+            return ""
+class AsyncOPENAI(AsyncProvider):
+    def __init__(
+        self,
+        api_key: str,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        temperature: float = 1,
+        presence_penalty: int = 0,
+        frequency_penalty: int = 0,
+        top_p: float = 1,
+        model: str = "gpt-3.5-turbo",
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ):
+        """Instantiates OPENAI
+
+        Args:
+            api_key (key): OpenAI's API key.
+            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.
+            temperature (float, optional): Charge of the generated text's randomness. Defaults to 1.
+            presence_penalty (int, optional): Chances of topic being repeated. Defaults to 0.
+            frequency_penalty (int, optional): Chances of word being repeated. Defaults to 0.
+            top_p (float, optional): Sampling threshold during inference time. Defaults to 0.999.
+            model (str, optional): LLM model name. Defaults to "gpt-3.5-turbo".
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.api_key = api_key
+        self.model = model
+        self.temperature = temperature
+        self.presence_penalty = presence_penalty
+        self.frequency_penalty = frequency_penalty
+        self.top_p = top_p
+        self.chat_endpoint = "https://api.openai.com/v1/chat/completions"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session = httpx.AsyncClient(
+            headers=self.headers,
+            proxies=proxies,
+        )
+
+    async def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict | AsyncGenerator:
+        """Chat with AI asynchronously.
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict|AsyncGenerator : ai content.
+        ```json
+        {
+            "id": "chatcmpl-TaREJpBZsRVQFRFic1wIA7Q7XfnaD",
+            "object": "chat.completion",
+            "created": 1704623244,
+            "model": "gpt-3.5-turbo",
+            "usage": {
+                "prompt_tokens": 0,
+                "completion_tokens": 0,
+                "total_tokens": 0
+                },
+            "choices": [
+                {
+                    "message": {
+                        "role": "assistant",
+                        "content": "Hello! How can I assist you today?"
+                },
+                "finish_reason": "stop",
+                "index": 0
+                }
+            ]
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+        payload = {
+            "frequency_penalty": self.frequency_penalty,
+            "messages": [{"content": conversation_prompt, "role": "user"}],
+            "model": self.model,
+            "presence_penalty": self.presence_penalty,
+            "stream": stream,
+            "temperature": self.temperature,
+            "top_p": self.top_p,
+        }
+
+        async def for_stream():
+            async with self.session.stream(
+                "POST", self.chat_endpoint, json=payload, timeout=self.timeout
+            ) as response:
+                if not response.is_success:
+                    raise Exception(
+                        f"Failed to generate response - ({response.status_code}, {response.reason_phrase})"
+                    )
+
+                message_load = ""
+                async for value in response.aiter_lines():
+                    try:
+
+                        resp = sanitize_stream(value)
+                        incomplete_message = await self.get_message(resp)
+                        if incomplete_message:
+                            message_load += incomplete_message
+                            resp["choices"][0]["delta"]["content"] = message_load
+                            self.last_response.update(resp)
+                            yield value if raw else resp
+                        elif raw:
+                            yield value
+                    except json.decoder.JSONDecodeError:
+                        pass
+            self.conversation.update_chat_history(
+                prompt, await self.get_message(self.last_response)
+            )
+
+        async def for_non_stream():
+            response = httpx.post(
+                self.chat_endpoint,
+                json=payload,
+                timeout=self.timeout,
+                headers=self.headers,
+            )
+            if (
+                not response.is_success
+                or not response.headers.get("Content-Type", "") == "application/json"
+            ):
+                raise Exception(
+                    f"Failed to generate response - ({response.status_code}, {response.reason_phrase})"
+                )
+            resp = response.json()
+            self.last_response.update(resp)
+            self.conversation.update_chat_history(
+                prompt, await self.get_message(self.last_response)
+            )
+            return resp
+
+        return for_stream() if stream else await for_non_stream()
+
+    async def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str | AsyncGenerator:
+        """Generate response `str` asynchronously.
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str|AsyncGenerator: Response generated
+        """
+
+        async def for_stream():
+            async_ask = await self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            )
+            async for response in async_ask:
+                yield await self.get_message(response)
+
+        async def for_non_stream():
+            return await self.get_message(
+                await self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else await for_non_stream()
+
+    async def get_message(self, response: dict) -> str:
+        """Retrieves message only from response asynchronously.
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        try:
+            if response["choices"][0].get("delta"):
+                return response["choices"][0]["delta"]["content"]
+            return response["choices"][0]["message"]["content"]
+        except KeyError:
+            return ""

webscout/Provider/Perplexity.py

@@ -0,0 +1,230 @@
+import time
+import uuid
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+import click
+import requests
+from requests import get
+from uuid import uuid4
+from re import findall
+from requests.exceptions import RequestException
+from curl_cffi.requests import get, RequestsError
+import g4f
+from random import randint
+from PIL import Image
+import io
+import re
+import json
+import yaml
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import  Provider, AsyncProvider
+from Helpingai_T2 import Perplexity
+from webscout import exceptions
+from typing import Any, AsyncGenerator, Dict
+import logging
+import httpx
+#------------------------------------------------------PERPLEXITY--------------------------------------------------------  
+class PERPLEXITY(Provider):
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        quiet: bool = False,
+    ):
+        """Instantiates PERPLEXITY
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+            quiet (bool, optional): Ignore web search-results and yield final response only. Defaults to False.
+        """
+        self.max_tokens_to_sample = max_tokens
+        self.is_conversation = is_conversation
+        self.last_response = {}
+        self.web_results: dict = {}
+        self.quiet = quiet
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+                Args:
+                    prompt (str): Prompt to be send.
+                    stream (bool, optional): Flag for streaming response. Defaults to False.
+                    raw (bool, optional): Stream back raw response as received. Defaults to False.
+                    optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+                    conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+                Returns:
+                   dict : {}
+                ```json
+        {
+            "status": "pending",
+            "uuid": "3604dfcc-611f-4b7d-989d-edca2a7233c7",
+            "read_write_token": null,
+            "frontend_context_uuid": "f6d43119-5231-481d-b692-f52e1f52d2c6",
+            "final": false,
+            "backend_uuid": "a6d6ec9e-da69-4841-af74-0de0409267a8",
+            "media_items": [],
+            "widget_data": [],
+            "knowledge_cards": [],
+            "expect_search_results": "false",
+            "mode": "concise",
+            "search_focus": "internet",
+            "gpt4": false,
+            "display_model": "turbo",
+            "attachments": null,
+            "answer": "",
+            "web_results": [],
+            "chunks": [],
+            "extra_web_results": []
+        }
+                ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        def for_stream():
+            for response in Perplexity().generate_answer(conversation_prompt):
+                yield json.dumps(response) if raw else response
+                self.last_response.update(response)
+
+            self.conversation.update_chat_history(
+                prompt,
+                self.get_message(self.last_response),
+            )
+
+        def for_non_stream():
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        text_str: str = response.get("answer", "")
+
+        def update_web_results(web_results: list) -> None:
+            for index, results in enumerate(web_results, start=1):
+                self.web_results[str(index) + ". " + results["name"]] = dict(
+                    url=results.get("url"), snippet=results.get("snippet")
+                )
+
+        if response.get("text"):
+            # last chunk
+            target: dict[str, Any] = json.loads(response.get("text"))
+            text_str = target.get("answer")
+            web_results: list[dict] = target.get("web_results")
+            self.web_results.clear()
+            update_web_results(web_results)
+
+            return (
+                text_str
+                if self.quiet or not self.web_results
+                else text_str + "\n\n# WEB-RESULTS\n\n" + yaml.dump(self.web_results)
+            )
+
+        else:
+            if str(response.get("expect_search_results")).lower() == "true":
+                return (
+                    text_str
+                    if self.quiet
+                    else text_str
+                    + "\n\n# WEB-RESULTS\n\n"
+                    + yaml.dump(response.get("web_results"))
+                )
+            else:
+                return text_str

webscout/Provider/Phind.py

@@ -0,0 +1,518 @@
+import time
+import uuid
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+import click
+import requests
+from requests import get
+from uuid import uuid4
+from re import findall
+from requests.exceptions import RequestException
+from curl_cffi.requests import get, RequestsError
+import g4f
+from random import randint
+from PIL import Image
+import io
+import re
+import json
+import yaml
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import  Provider, AsyncProvider
+from Helpingai_T2 import Perplexity
+from webscout import exceptions
+from typing import Any, AsyncGenerator, Dict
+import logging
+import httpx
+
+#------------------------------------------------------phind-------------------------------------------------------------
+class PhindSearch:
+    # default_model = "Phind Model"
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 8000,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        model: str = "Phind Model",
+        quiet: bool = False,
+    ):
+        """Instantiates PHIND
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+            model (str, optional): Model name. Defaults to "Phind Model".
+            quiet (bool, optional): Ignore web search-results and yield final response only. Defaults to False.
+        """
+        self.session = requests.Session()
+        self.max_tokens_to_sample = max_tokens
+        self.is_conversation = is_conversation
+        self.chat_endpoint = "https://https.extension.phind.com/agent/"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.model = model
+        self.quiet = quiet
+
+        self.headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "",
+            "Accept": "*/*",
+            "Accept-Encoding": "Identity",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(self.headers)
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session.proxies = proxies
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict : {}
+        ```json
+        {
+            "id": "chatcmpl-r0wujizf2i2xb60mjiwt",
+            "object": "chat.completion.chunk",
+            "created": 1706775384,
+            "model": "trt-llm-phind-model-serving",
+            "choices": [
+                {
+                    "index": 0,
+                    "delta": {
+                        "content": "Hello! How can I assist you with your programming today?"
+                        },
+                    "finish_reason": null
+                }
+            ]
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        self.session.headers.update(self.headers)
+        payload = {
+            "additional_extension_context": "",
+            "allow_magic_buttons": True,
+            "is_vscode_extension": True,
+            "message_history": [
+                {"content": conversation_prompt, "metadata": {}, "role": "user"}
+            ],
+            "requested_model": self.model,
+            "user_input": prompt,
+        }
+
+        def for_stream():
+            response = self.session.post(
+                self.chat_endpoint, json=payload, stream=True, timeout=self.timeout
+            )
+            if (
+                not response.ok
+                or not response.headers.get("Content-Type")
+                == "text/event-stream; charset=utf-8"
+            ):
+                raise exceptions.FailedToGenerateResponseError(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
+            streaming_text = ""
+            for value in response.iter_lines(
+                decode_unicode=True,
+                chunk_size=self.stream_chunk_size,
+            ):
+                try:
+                    modified_value = re.sub("data:", "", value)
+                    json_modified_value = json.loads(modified_value)
+                    retrieved_text = self.get_message(json_modified_value)
+                    if not retrieved_text:
+                        continue
+                    streaming_text += retrieved_text
+                    json_modified_value["choices"][0]["delta"][
+                        "content"
+                    ] = streaming_text
+                    self.last_response.update(json_modified_value)
+                    yield value if raw else json_modified_value
+                except json.decoder.JSONDecodeError:
+                    pass
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+
+        def for_non_stream():
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        if response.get("type", "") == "metadata":
+            return
+
+        delta: dict = response["choices"][0]["delta"]
+
+        if not delta:
+            return ""
+
+        elif delta.get("function_call"):
+            if self.quiet:
+                return ""
+
+            function_call: dict = delta["function_call"]
+            if function_call.get("name"):
+                return function_call["name"]
+            elif function_call.get("arguments"):
+                return function_call.get("arguments")
+
+        elif delta.get("metadata"):
+            if self.quiet:
+                return ""
+            return yaml.dump(delta["metadata"])
+
+        else:
+            return (
+                response["choices"][0]["delta"].get("content")
+                if response["choices"][0].get("finish_reason") is None
+                else ""
+            )
+class AsyncPhindSearch(AsyncProvider):
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        model: str = "Phind Model",
+        quiet: bool = False,
+    ):
+        """Instantiates PHIND
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+            model (str, optional): Model name. Defaults to "Phind Model".
+            quiet (bool, optional): Ignore web search-results and yield final response only. Defaults to False.
+        """
+        self.max_tokens_to_sample = max_tokens
+        self.is_conversation = is_conversation
+        self.chat_endpoint = "https://https.extension.phind.com/agent/"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.model = model
+        self.quiet = quiet
+
+        self.headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "",
+            "Accept": "*/*",
+            "Accept-Encoding": "Identity",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session = httpx.AsyncClient(headers=self.headers, proxies=proxies)
+
+    async def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+        synchronous_generator=False,
+    ) -> dict | AsyncGenerator:
+        """Asynchronously Chat with AI
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict|AsyncGenerator : ai content.
+        ```json
+        {
+            "id": "chatcmpl-r0wujizf2i2xb60mjiwt",
+            "object": "chat.completion.chunk",
+            "created": 1706775384,
+            "model": "trt-llm-phind-model-serving",
+            "choices": [
+                {
+                    "index": 0,
+                    "delta": {
+                        "content": "Hello! How can I assist you with your programming today?"
+                        },
+                    "finish_reason": null
+                }
+            ]
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        payload = {
+            "additional_extension_context": "",
+            "allow_magic_buttons": True,
+            "is_vscode_extension": True,
+            "message_history": [
+                {"content": conversation_prompt, "metadata": {}, "role": "user"}
+            ],
+            "requested_model": self.model,
+            "user_input": prompt,
+        }
+
+        async def for_stream():
+            async with self.session.stream(
+                "POST",
+                self.chat_endpoint,
+                json=payload,
+                timeout=self.timeout,
+            ) as response:
+                if (
+                    not response.is_success
+                    or not response.headers.get("Content-Type")
+                    == "text/event-stream; charset=utf-8"
+                ):
+                    raise exceptions.FailedToGenerateResponseError(
+                        f"Failed to generate response - ({response.status_code}, {response.reason_phrase})"
+                    )
+                streaming_text = ""
+                async for value in response.aiter_lines():
+                    try:
+                        modified_value = re.sub("data:", "", value)
+                        json_modified_value = json.loads(modified_value)
+                        retrieved_text = await self.get_message(json_modified_value)
+                        if not retrieved_text:
+                            continue
+                        streaming_text += retrieved_text
+                        json_modified_value["choices"][0]["delta"][
+                            "content"
+                        ] = streaming_text
+                        self.last_response.update(json_modified_value)
+                        yield value if raw else json_modified_value
+                    except json.decoder.JSONDecodeError:
+                        pass
+                self.conversation.update_chat_history(
+                    prompt, await self.get_message(self.last_response)
+                )
+
+        async def for_non_stream():
+            async for _ in for_stream():
+                pass
+            return self.last_response
+
+        return (
+            for_stream()
+            if stream and not synchronous_generator
+            else await for_non_stream()
+        )
+
+    async def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str | AsyncGenerator:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str|AsyncGenerator: Response generated
+        """
+
+        async def for_stream():
+            ask_resp = await self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            )
+            async for response in ask_resp:
+                yield await self.get_message(response)
+
+        async def for_non_stream():
+            return await self.get_message(
+                await self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else await for_non_stream()
+
+    async def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        if response.get("type", "") == "metadata":
+            return
+
+        delta: dict = response["choices"][0]["delta"]
+
+        if not delta:
+            return ""
+
+        elif delta.get("function_call"):
+            if self.quiet:
+                return ""
+
+            function_call: dict = delta["function_call"]
+            if function_call.get("name"):
+                return function_call["name"]
+            elif function_call.get("arguments"):
+                return function_call.get("arguments")
+
+        elif delta.get("metadata"):
+            if self.quiet:
+                return ""
+            return yaml.dump(delta["metadata"])
+
+        else:
+            return (
+                response["choices"][0]["delta"].get("content")
+                if response["choices"][0].get("finish_reason") is None
+                else ""
+            )

webscout/Provider/Poe.py

@@ -0,0 +1,208 @@
+from poe_api_wrapper import PoeApi
+from poe_api_wrapper.api import BOTS_LIST
+from ..AIbase import Provider
+from ..AIutel import Conversation
+from ..AIutel  import Optimizers
+from ..AIutel  import AwesomePrompts
+from pathlib import Path
+from json import loads
+from json import dumps
+from loguru import logger
+import logging
+
+logger.remove()
+
+
+class POE(Provider):
+    def __init__(
+        self,
+        cookie: str,
+        model: str = "Assistant",
+        proxy: bool = False,
+        timeout: int = 30,
+        filepath: str = None,
+        update_file: str = True,
+        intro: str = None,
+        act: str = None,
+        init: bool = True,
+    ):
+        """Initializes POE
+
+        Args:
+            cookie (str): Path to `poe.com.cookies.json` file or 'p-b' cookie-value.
+            model (str, optional): Model name. Default to Assistant.
+            proxy (bool, optional): Flag for Httpx request proxy. Defaults to False.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            filepath (str, optional): Path to save the chat history. Defaults to None.
+            update_file (str, optional): Flag for controlling chat history updates. Defaults to True.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+            init (bool, optional): Resend the intro prompt. Defaults to True.
+        """
+        assert isinstance(
+            cookie, str
+        ), f"Cookie must be of {str} datatype only not {type(cookie)}"
+        assert (
+            model in BOTS_LIST.keys()
+        ), f"model name '{model}' is not one of {', '.join(list(BOTS_LIST.keys()))}"
+        cookie_path = Path(cookie)
+
+        if cookie_path.exists() or any(["/" in cookie, ".json" in cookie]):
+            cookie = None
+            all_cookies = loads(cookie_path.read_text())
+            for entry in all_cookies:
+                if entry["name"] == "p-b":
+                    cookie = entry["value"]
+            assert (
+                cookie
+            ), f'Required cookie value cannot be retrieved from the path  "{cookie_path.as_posix()}"'
+
+        if proxy:
+            import poe_api_wrapper.proxies as proxies
+
+            proxies.PROXY = True
+
+        self.bot = BOTS_LIST[model]
+        self.session = PoeApi(cookie)
+        self.last_response = {}
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            status=False, filepath=filepath, update_file=update_file
+        )
+        if init:
+            self.ask(self.conversation.intro)  # Init
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+            Args:
+                prompt (str): Prompt to be send.
+                stream (bool, optional): Flag for streaming response. Defaults to False.
+                raw (bool, optional): Stream back raw response as received. Defaults to False.
+                optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defeaults to None
+                conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+            Returns:
+               dict : {}
+        ```json
+        {
+            "id": "TWVzc2FnZToxMTU0MzgyNDQ1ODU=",
+            "messageId": 115438244585,
+            "creationTime": 1707777376544407,
+            "clientNonce": null,
+            "state": "complete",
+            "text": "Hello! How can I assist you today?",
+            "author": "capybara",
+            "contentType": "text_markdown",
+            "sourceType": "chat_input",
+            "attachmentTruncationState": "not_truncated",
+            "attachments": [],
+            "vote": null,
+            "suggestedReplies": [],
+            "hasCitations": false,
+            "__isNode": "Message",
+            "textLengthOnCancellation": null,
+            "chatCode": "21a2jn0yrq9phxiy478",
+            "chatId": 328236777,
+            "title": null,
+            "response": ""
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        def for_stream():
+            for response in self.session.send_message(self.bot, conversation_prompt):
+                if raw:
+                    yield dumps(response)
+                else:
+                    yield response
+
+                self.last_response.update(response)
+
+            self.conversation.update_chat_history(
+                prompt,
+                self.get_message(self.last_response),
+                force=True,
+            )
+
+        def for_non_stream():
+            # let's make use of stream
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]

webscout/Provider/Reka.py

@@ -0,0 +1,226 @@
+import time
+import uuid
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+import click
+import requests
+from requests import get
+from uuid import uuid4
+from re import findall
+from requests.exceptions import RequestException
+from curl_cffi.requests import get, RequestsError
+import g4f
+from random import randint
+from PIL import Image
+import io
+import re
+import json
+import yaml
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import  Provider, AsyncProvider
+from Helpingai_T2 import Perplexity
+from webscout import exceptions
+from typing import Any, AsyncGenerator, Dict
+import logging
+import httpx
+#-----------------------------------------------REKA-----------------------------------------------
+class REKA(Provider):
+    def __init__(
+        self,
+        api_key: str,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        model: str = "reka-core",
+        system_prompt: str = "Be Helpful and Friendly. Keep your response straightforward, short and concise",
+        use_search_engine: bool = False,
+        use_code_interpreter: bool = False,
+    ):
+        """Instantiates REKA
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+            model (str, optional): REKA model name. Defaults to "reka-core".
+            system_prompt (str, optional): System prompt for REKA. Defaults to "Be Helpful and Friendly. Keep your response straightforward, short and concise".
+            use_search_engine (bool, optional): Whether to use the search engine. Defaults to False.
+            use_code_interpreter (bool, optional): Whether to use the code interpreter. Defaults to False.
+        """
+        self.session = requests.Session()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.api_endpoint = "https://chat.reka.ai/api/chat"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.model = model
+        self.system_prompt = system_prompt
+        self.use_search_engine = use_search_engine
+        self.use_code_interpreter = use_code_interpreter
+        self.access_token = api_key
+        self.headers = {
+            "Authorization": f"Bearer {self.access_token}",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(self.headers)
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session.proxies = proxies
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict : {}
+        ```json
+        {
+           "text" : "How may I assist you today?"
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        self.session.headers.update(self.headers)
+        payload = {
+
+            "conversation_history": [
+                {"type": "human", "text": f"## SYSTEM PROMPT: {self.system_prompt}\n\n## QUERY: {conversation_prompt}"},
+            ],
+
+            "stream": stream,
+            "use_search_engine": self.use_search_engine,
+            "use_code_interpreter": self.use_code_interpreter,
+            "model_name": self.model,
+            # "model_name": "reka-flash",
+            # "model_name": "reka-edge",
+        }
+
+        def for_stream():
+            response = self.session.post(self.api_endpoint, json=payload, stream=True, timeout=self.timeout)
+            if not response.ok:
+                raise Exception(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
+
+            for value in response.iter_lines(
+                decode_unicode=True,
+                chunk_size=self.stream_chunk_size,
+            ):
+                try:
+                    resp = json.loads(value)
+                    self.last_response.update(resp)
+                    yield value if raw else resp
+                except json.decoder.JSONDecodeError:
+                    pass
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+
+        def for_non_stream():
+            # let's make use of stream
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response.get("text")

webscout/Provider/ThinkAnyAI.py

@@ -0,0 +1,280 @@
+import time
+import uuid
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+import click
+import requests
+from requests import get
+from uuid import uuid4
+from re import findall
+from requests.exceptions import RequestException
+from curl_cffi.requests import get, RequestsError
+import g4f
+from random import randint
+from PIL import Image
+import io
+import re
+import json
+import yaml
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import  Provider, AsyncProvider
+from Helpingai_T2 import Perplexity
+from webscout import exceptions
+from typing import Any, AsyncGenerator, Dict
+import logging
+import httpx
+#------------------------------------ThinkAnyAI------------
+class ThinkAnyAI(Provider):
+    def __init__(
+        self,
+        model: str = "claude-3-haiku",
+        locale: str = "en",
+        web_search: bool = False,
+        chunk_size: int = 1,
+        streaming: bool = True,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ):
+        """Initializes ThinkAnyAI
+
+        Args:
+            model (str): The AI model to be used for generating responses. Defaults to "claude-3-haiku".
+            locale (str): The language locale. Defaults to "en" (English).
+            web_search (bool): Whether to include web search results in the response. Defaults to False.
+            chunk_size (int): The size of data chunks when streaming responses. Defaults to 1.
+            streaming (bool): Whether to stream response data. Defaults to True.
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True.
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.base_url = "https://thinkany.ai/api"
+        self.model = model
+        self.locale = locale
+        self.web_search = web_search
+        self.chunk_size = chunk_size
+        self.streaming = streaming
+        self.last_response = {}
+        self.session = requests.Session()
+        self.session.proxies = proxies
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, max_tokens, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict | AsyncGenerator:
+        """Chat with AI asynchronously.
+
+            Args:
+                prompt (str): Prompt to be send.
+                stream (bool, optional): Flag for streaming response. Defaults to False.
+                raw (bool, optional): Stream back raw response as received. Defaults to False.
+                optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defeaults to None
+                conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+            Returns:
+                dict : {}
+            ```json
+            {
+                "content": "General Kenobi! \n\n(I couldn't help but respond with the iconic Star Wars greeting since you used it first. )\n\nIs there anything I can help you with today?\n[Image of Hello there General Kenobi]",
+                "conversation_id": "c_f13f6217f9a997aa",
+                "response_id": "r_d3665f95975c368f",
+                "factualityQueries": null,
+                "textQuery": [
+                    "hello there",
+                    1
+                    ],
+                "choices": [
+                    {
+                        "id": "rc_ea075c9671bfd8cb",
+                        "content": [
+                            "General Kenobi! \n\n(I couldn't help but respond with the iconic Star Wars greeting since you used it first. )\n\nIs there anything I can help you with today?\n[Image of Hello there General Kenobi]"
+                        ]
+                    },
+                    {
+                        "id": "rc_de6dd3fb793a5402",
+                        "content": [
+                            "General Kenobi! (or just a friendly hello, whichever you prefer!). \n\nI see you're a person of culture as well. *Star Wars* references are always appreciated.  \n\nHow can I help you today?\n"
+                            ]
+                    },
+                {
+                    "id": "rc_a672ac089caf32db",
+                    "content": [
+                        "General Kenobi! (or just a friendly hello if you're not a Star Wars fan!). \n\nHow can I help you today? Feel free to ask me anything, or tell me what you'd like to chat about. I'm here to assist in any way I can.\n[Image of Obi-Wan Kenobi saying hello there]"
+                    ]
+                }
+            ],
+
+            "images": [
+                "https://i.pinimg.com/originals/40/74/60/407460925c9e419d82b93313f0b42f71.jpg"
+            ]
+        }
+
+            ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        def initiate_conversation(query: str) -> str:
+            """
+            Initiates a new conversation with the ThinkAny AI API.
+
+            Args:
+                query (str): The initial query to start the conversation.
+
+            Returns:
+                str: The UUID (Unique Identifier) of the conversation.
+            """
+            url = f"{self.base_url}/new-conversation"
+            payload = {
+                "content": query,
+                "locale": self.locale,
+                "mode": "search" if self.web_search else "chat",
+                "model": self.model,
+                "source": "all",
+            }
+            response = self.session.post(url, json=payload)
+            return response.json().get("data", {}).get("uuid", "DevsDoCode")
+
+        def RAG_search(uuid: str) -> tuple[bool, list]:
+            """
+            Performs a web search using the Retrieve And Generate (RAG) model.
+
+            Args:
+                uuid (str): The UUID of the conversation.
+
+            Returns:
+                tuple: A tuple containing a boolean indicating the success of the search
+                        and a list of search result links.
+            """
+            if not self.web_search:
+                return True, []
+            url = f"{self.base_url}/rag-search"
+            payload = {"conv_uuid": uuid}
+            response = self.session.post(url, json=payload)
+            links = [source["link"] for source in response.json().get("data", [])]
+            return response.json().get("message", "").strip(), links
+
+        def for_stream():
+            conversation_uuid = initiate_conversation(conversation_prompt)
+            web_search_result, links = RAG_search(conversation_uuid)
+            if not web_search_result:
+                print("Failed to generate WEB response. Making normal Query...")
+
+            url = f"{self.base_url}/chat"
+            payload = {
+                "role": "user",
+                "content": prompt,
+                "conv_uuid": conversation_uuid,
+                "model": self.model,
+            }
+            response = self.session.post(url, json=payload, stream=True)
+            complete_content = ""
+            for content in response.iter_content(
+                decode_unicode=True, chunk_size=self.chunk_size
+            ):
+                complete_content += content
+                yield content if raw else dict(text=complete_content)
+            self.last_response.update(dict(text=complete_content, links=links))
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+
+        def for_non_stream():
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: Dict[str, Any]) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]

webscout/Provider/Xjai.py

@@ -0,0 +1,230 @@
+import time
+import uuid
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+import click
+import requests
+from requests import get
+from uuid import uuid4
+from re import findall
+from requests.exceptions import RequestException
+from curl_cffi.requests import get, RequestsError
+import g4f
+from random import randint
+from PIL import Image
+import io
+import re
+import json
+import yaml
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import  Provider, AsyncProvider
+from webscout import exceptions
+from typing import Any, AsyncGenerator, Dict
+import logging
+import httpx
+#-----------------------------------------------xjai-------------------------------------------
+class Xjai(Provider):
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        temperature: float = 0.8,
+        top_p: float = 1,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ):
+        """
+        Initializes the Xjai class for interacting with the Xjai AI chat API.
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True.
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            temperature (float, optional): The creativity level of the AI's response. Defaults to 0.8.
+            top_p (float, optional): The probability threshold for token selection. Defaults to 1.
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.session = requests.Session()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.temperature = temperature
+        self.top_p = top_p
+        self.chat_endpoint = "https://p1api.xjai.pro/freeapi/chat-process"
+        self.stream_chunk_size = 1  # Process response line by line
+        self.timeout = timeout
+        self.last_response = {}
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session.proxies = proxies
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Any:
+        """
+        Sends a chat request to the Xjai AI chat API and returns the response.
+
+        Args:
+            prompt (str): The query to send to the AI.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+
+        Returns:
+            Any: The response from the AI, either as a dictionary or a generator 
+                 depending on the `stream` and `raw` parameters.
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+                          "(KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"
+        }
+
+        payload = {
+            "prompt": conversation_prompt + "\n\nReply in English Only",
+            "systemMessage": "Reply in English Only",
+            "temperature": self.temperature,
+            "top_p": self.top_p
+        }
+
+        def generate_response():
+            response = self.session.post(
+                self.chat_endpoint, headers=headers, json=payload, stream=True, timeout=self.timeout
+            )
+            output = ""
+            print_next = False
+
+            for line in response.iter_lines(decode_unicode=True, chunk_size=self.stream_chunk_size):
+                line_content = line.decode("utf-8")
+                # Filter out irrelevant content
+                if '[ChatAI](https://srv.aiflarepro.com/#/?cid=4111)' in line_content:
+                    continue
+                if '&KFw6loC9Qvy&' in line_content:
+                    parts = line_content.split('&KFw6loC9Qvy&')
+                    if print_next:
+                        output += parts[0]
+                        print_next = False
+                    else:
+                        output += parts[1]
+                        print_next = True
+                        if len(parts) > 2:
+                            print_next = False
+                elif print_next:
+                    output += line_content + '\n'
+
+            # Update chat history
+            self.conversation.update_chat_history(prompt, output)
+
+            return output
+
+        def for_stream():
+            response = generate_response()
+            for line in response.splitlines():
+                yield line if raw else dict(text=line)
+
+        def for_non_stream():
+            response = generate_response()
+            return response if raw else dict(text=response)
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Any:
+        """
+        Generates a response from the Xjai AI chat API.
+
+        Args:
+            prompt (str): The query to send to the AI.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+
+        Returns:
+            Any: The response from the AI, either as a string or a generator 
+                 depending on the `stream` parameter. 
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: Any) -> str:
+        """
+        Retrieves the message from the AI's response. 
+
+        Args:
+            response (Any): The response from the AI, either a dictionary 
+                            or a raw string.
+
+        Returns:
+            str: The extracted message from the AI's response. 
+        """
+        if isinstance(response, dict): 
+            return response["text"]
+        else:  # Assume raw string
+            return response
+

webscout/Provider/Yepchat.py

@@ -0,0 +1,478 @@
+import time
+import uuid
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+import click
+import requests
+from requests import get
+from uuid import uuid4
+from re import findall
+from requests.exceptions import RequestException
+from curl_cffi.requests import get, RequestsError
+import g4f
+from random import randint
+from PIL import Image
+import io
+import re
+import json
+import yaml
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import  Provider, AsyncProvider
+from Helpingai_T2 import Perplexity
+from webscout import exceptions
+from typing import Any, AsyncGenerator, Dict
+import logging
+import httpx
+
+#-------------------------------------------------------yep.com--------------------------------------------------------   
+class YEPCHAT(Provider):
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        temperature: float = 0.6,
+        presence_penalty: int = 0,
+        frequency_penalty: int = 0,
+        top_p: float = 0.7,
+        model: str = "Mixtral-8x7B-Instruct-v0.1",
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ):
+        """Instantiates YEPCHAT
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True.
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            temperature (float, optional): Charge of the generated text's randomness. Defaults to 0.6.
+            presence_penalty (int, optional): Chances of topic being repeated. Defaults to 0.
+            frequency_penalty (int, optional): Chances of word being repeated. Defaults to 0.
+            top_p (float, optional): Sampling threshold during inference time. Defaults to 0.7.
+            model (str, optional): LLM model name. Defaults to "gpt-3.5-turbo".
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.session = requests.Session()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.model = model
+        self.temperature = temperature
+        self.presence_penalty = presence_penalty
+        self.frequency_penalty = frequency_penalty
+        self.top_p = top_p
+        self.chat_endpoint = "https://api.yep.com/v1/chat/completions"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.headers = {
+            "Accept": "*/*",
+            "Accept-Encoding": "gzip, deflate",
+            "Accept-Language": "en-US,en;q=0.9",
+            "Content-Type": "application/json; charset=utf-8",
+            "Origin": "https://yep.com",
+            "Referer": "https://yep.com/",
+            "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(self.headers)
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session.proxies = proxies
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict : {}
+        ```json
+        {
+            "id": "cmpl-c61c1c88de4e4ad3a79134775d17ea0c",
+            "object": "chat.completion.chunk",
+            "created": 1713876886,
+            "model": "Mixtral-8x7B-Instruct-v0.1",
+            "choices": [
+                {
+                    "index": 0,
+                    "delta": {
+                        "role": null,
+                        "content": " Sure, I can help with that. Are you looking for information on how to start coding, or do you need help with a specific coding problem? We can discuss various programming languages like Python, JavaScript, Java, C++, or others. Please provide more details so I can assist you better."
+                        },
+                    "finish_reason": null
+                }
+            ]
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+        self.session.headers.update(self.headers)
+        payload = {
+            "stream": True,
+            "max_tokens": 1280,
+            "top_p": self.top_p,
+            "temperature": self.temperature,
+            "messages": [{"content": conversation_prompt, "role": "user"}],
+            "model": self.model,
+        }
+
+        def for_stream():
+            response = self.session.post(
+                self.chat_endpoint, json=payload, stream=True, timeout=self.timeout
+            )
+            if not response.ok:
+                raise exceptions.FailedToGenerateResponseError(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
+
+            message_load = ""
+            for value in response.iter_lines(
+                decode_unicode=True,
+                delimiter="" if raw else "data:",
+                chunk_size=self.stream_chunk_size,
+            ):
+                try:
+                    resp = json.loads(value)
+                    incomplete_message = self.get_message(resp)
+                    if incomplete_message:
+                        message_load += incomplete_message
+                        resp["choices"][0]["delta"]["content"] = message_load
+                        self.last_response.update(resp)
+                        yield value if raw else resp
+                    elif raw:
+                        yield value
+                except json.decoder.JSONDecodeError:
+                    pass
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+
+        def for_non_stream():
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        try:
+            if response["choices"][0].get("delta"):
+                return response["choices"][0]["delta"]["content"]
+            return response["choices"][0]["message"]["content"]
+        except KeyError:
+            return ""
+class AsyncYEPCHAT(AsyncProvider):
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        temperature: float = 0.6,
+        presence_penalty: int = 0,
+        frequency_penalty: int = 0,
+        top_p: float = 0.7,
+        model: str = "Mixtral-8x7B-Instruct-v0.1",
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ):
+        """Instantiates YEPCHAT
+
+        Args:
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True.
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            temperature (float, optional): Charge of the generated text's randomness. Defaults to 0.6.
+            presence_penalty (int, optional): Chances of topic being repeated. Defaults to 0.
+            frequency_penalty (int, optional): Chances of word being repeated. Defaults to 0.
+            top_p (float, optional): Sampling threshold during inference time. Defaults to 0.7.
+            model (str, optional): LLM model name. Defaults to "gpt-3.5-turbo".
+            timeout (int, optional): Http request timeout. Defaults to 30.
+            intro (str, optional): Conversation introductory prompt. Defaults to None.
+            filepath (str, optional): Path to file containing conversation history. Defaults to None.
+            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
+            proxies (dict, optional): Http request proxies. Defaults to {}.
+            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
+            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
+        """
+        self.session = requests.Session()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.model = model
+        self.temperature = temperature
+        self.presence_penalty = presence_penalty
+        self.frequency_penalty = frequency_penalty
+        self.top_p = top_p
+        self.chat_endpoint = "https://api.yep.com/v1/chat/completions"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.headers = {
+            "Accept": "*/*",
+            "Accept-Encoding": "gzip, deflate",
+            "Accept-Language": "en-US,en;q=0.9",
+            "Content-Type": "application/json; charset=utf-8",
+            "Origin": "https://yep.com",
+            "Referer": "https://yep.com/",
+            "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session = httpx.AsyncClient(
+            headers=self.headers,
+            proxies=proxies,
+        )
+
+    async def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        """Chat with AI asynchronously.
+
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            raw (bool, optional): Stream back raw response as received. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+           dict : {}
+        ```json
+        {
+            "id": "cmpl-c61c1c88de4e4ad3a79134775d17ea0c",
+            "object": "chat.completion.chunk",
+            "created": 1713876886,
+            "model": "Mixtral-8x7B-Instruct-v0.1",
+            "choices": [
+                {
+                    "index": 0,
+                    "delta": {
+                        "role": null,
+                        "content": " Sure, I can help with that. Are you looking for information on how to start coding, or do you need help with a specific coding problem? We can discuss various programming languages like Python, JavaScript, Java, C++, or others. Please provide more details so I can assist you better."
+                        },
+                    "finish_reason": null
+                }
+            ]
+        }
+        ```
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+        payload = {
+            "stream": True,
+            "max_tokens": 1280,
+            "top_p": self.top_p,
+            "temperature": self.temperature,
+            "messages": [{"content": conversation_prompt, "role": "user"}],
+            "model": self.model,
+        }
+
+        async def for_stream():
+            async with self.session.stream(
+                "POST", self.chat_endpoint, json=payload, timeout=self.timeout
+            ) as response:
+                if not response.is_success:
+                    raise exceptions.FailedToGenerateResponseError(
+                        f"Failed to generate response - ({response.status_code}, {response.reason_phrase}) - {response.text}"
+                    )
+
+                message_load = ""
+                async for value in response.aiter_lines():
+                    try:
+                        resp = sanitize_stream(value)
+                        incomplete_message = await self.get_message(resp)
+                        if incomplete_message:
+                            message_load += incomplete_message
+                            resp["choices"][0]["delta"]["content"] = message_load
+                            self.last_response.update(resp)
+                            yield value if raw else resp
+                        elif raw:
+                            yield value
+                    except json.decoder.JSONDecodeError:
+                        pass
+
+            self.conversation.update_chat_history(
+                prompt, await self.get_message(self.last_response)
+            )
+
+        async def for_non_stream():
+            async for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else await for_non_stream()
+
+    async def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str` asynchronously.
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        async def for_stream():
+            async_ask = await self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            )
+
+            async for response in async_ask:
+                yield await self.get_message(response)
+
+        async def for_non_stream():
+            return await self.get_message(
+                await self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else await for_non_stream()
+
+    async def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        try:
+            if response["choices"][0].get("delta"):
+                return response["choices"][0]["delta"]["content"]
+            return response["choices"][0]["message"]["content"]
+        except KeyError:
+            return ""

webscout/Provider/Youchat.py

@@ -0,0 +1,221 @@
+import time
+import uuid
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.ui import WebDriverWait
+import click
+import requests
+from requests import get
+from uuid import uuid4
+from re import findall
+from requests.exceptions import RequestException
+from curl_cffi.requests import get, RequestsError
+import g4f
+from random import randint
+from PIL import Image
+import io
+import re
+import json
+import yaml
+from ..AIutel import Optimizers
+from ..AIutel import Conversation
+from ..AIutel import AwesomePrompts, sanitize_stream
+from ..AIbase import  Provider, AsyncProvider
+from Helpingai_T2 import Perplexity
+from webscout import exceptions
+from typing import Any, AsyncGenerator, Dict
+import logging
+import httpx
+
+#-------------------------------------------------------youchat--------------------------------------------------------   
+class YouChat(Provider):
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 600,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ):
+        self.session = requests.Session()
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.chat_endpoint = "https://you.com/api/streamingSearch"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+
+        self.payload = {
+            "q": "",
+            "page": 1,
+            "count": 10,
+            "safeSearch": "Off",
+            "onShoppingPage": False,
+            "mkt": "",
+            "responseFilter": "WebPages,Translations,TimeZone,Computation,RelatedSearches",
+            "domain": "youchat",
+            "queryTraceId": uuid.uuid4(),
+            "conversationTurnId": uuid.uuid4(),
+            "pastChatLength": 0,
+            "selectedChatMode": "default",
+            "chat": "[]",
+        }
+
+        self.headers = {
+            "cache-control": "no-cache",
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
+            'Referer': f'https://you.com/search?q={self.payload["q"]}&fromSearchBar=true&tbm=youchat&chatMode=default'
+        }
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method)) and not method.startswith("__")
+        )
+        self.session.headers.update(self.headers)
+        Conversation.intro = (
+            AwesomePrompts().get_act(
+                act, raise_not_found=True, default=None, case_insensitive=True
+            )
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file
+        )
+        self.conversation.history_offset = history_offset
+        self.session.proxies = proxies
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> dict:
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+        self.session.headers.update(self.headers)
+        self.session.headers.update(
+            dict(
+                cookie=f"safesearch_guest=Off; uuid_guest={str(uuid4())}",
+            )
+        )
+        self.payload["q"] = prompt
+
+        def for_stream():
+            response = self.session.get(
+                self.chat_endpoint,
+                params=self.payload,
+                stream=True,
+                timeout=self.timeout,
+            )
+
+            if not response.ok:
+                raise exceptions.FailedToGenerateResponseError(
+                    f"Failed to generate response - ({response.status_code}, {response.reason})"
+                )
+
+            streaming_response = ""
+            for line in response.iter_lines(decode_unicode=True, chunk_size=64):
+                if line:
+                    modified_value = re.sub("data:", "", line)
+                    try:
+                        json_modified_value = json.loads(modified_value)
+                        if "youChatToken" in json_modified_value:
+                            streaming_response += json_modified_value["youChatToken"]
+                            if print:
+                                print(json_modified_value["youChatToken"], end="")
+                    except:
+                        continue
+            self.last_response.update(dict(text=streaming_response))
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
+            return streaming_response
+
+        def for_non_stream():
+            for _ in for_stream():
+                pass
+            return self.last_response
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> str:
+        """Generate response `str`
+        Args:
+            prompt (str): Prompt to be send.
+            stream (bool, optional): Flag for streaming response. Defaults to False.
+            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
+            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+        Returns:
+            str: Response generated
+        """
+
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """Retrieves message only from response
+
+        Args:
+            response (dict): Response generated by `self.ask`
+
+        Returns:
+            str: Message extracted
+        """
+        assert isinstance(response, dict), "Response should be of dict data-type only"
+        return response["text"]

webscout/Provider/__init__.py

@@ -0,0 +1,61 @@
+# webscout/providers/__init__.py
+
+from .ThinkAnyAI import ThinkAnyAI
+from .Xjai import Xjai
+from .Llama2 import LLAMA2
+from .Llama2 import AsyncLLAMA2
+from .Cohere import Cohere
+from .Reka import REKA
+from .Groq import GROQ
+from .Groq import AsyncGROQ
+from .Openai import OPENAI
+from .Openai import AsyncOPENAI
+from .Leo import LEO
+from .Leo import AsyncLEO
+from .Koboldai import KOBOLDAI
+from .Koboldai import AsyncKOBOLDAI
+from .OpenGPT import OPENGPT 
+from .OpenGPT import AsyncOPENGPT
+from .Perplexity import PERPLEXITY
+from .Blackboxai import BLACKBOXAI 
+from .Blackboxai import AsyncBLACKBOXAI
+from .Phind import PhindSearch 
+from .Phind import AsyncPhindSearch
+from .Yepchat import YEPCHAT
+from .Yepchat import AsyncYEPCHAT
+from .Youchat import YouChat
+from .Gemini import GEMINI
+from .Berlin4h import Berlin4h
+from .ChatGPTUK import ChatGPTUK
+from .Poe import POE
+from .BasedGPT import *
+__all__ = [
+    'ThinkAnyAI',
+    'Xjai',
+    'LLAMA2', 
+    'AsyncLLAMA2',
+    'Cohere',
+    'REKA',
+    'GROQ',
+    'AsyncGROQ',
+    'OPENAI',
+    'AsyncOPENAI',
+    'LEO',
+    'AsyncLEO',
+    'KOBOLDAI',
+    'AsyncKOBOLDAI',
+    'OPENGPT', 
+    'AsyncOPENGPT',
+    'PERPLEXITY',
+    'BLACKBOXAI', 
+    'AsyncBLACKBOXAI',
+    'PhindSearch', 
+    'AsyncPhindSearch',
+    'YEPCHAT',
+    'AsyncYEPCHAT',
+    'YouChat',
+    'GEMINI',
+    'Berlin4h',
+    'ChatGPTUK',
+    'POE'
+]