webscout 6.4__py3-none-any.whl → 6.5__py3-none-any.whl

webscout/webai.py

@@ -1,2590 +0,0 @@
-import webscout
-import click
-import cmd
-import logging
-import os
-import sys
-import clipman
-import re
-import rich
-import getpass
-import json
-import re
-import sys
-import datetime
-import time
-import subprocess
-from threading import Thread as thr
-from functools import wraps
-from rich.panel import Panel
-from rich.style import Style
-from rich.markdown import Markdown
-from rich.console import Console
-from rich.live import Live
-from rich.table import Table
-from rich.prompt import Prompt
-from rich.progress import Progress
-from typing import Iterator
-from .AIutel import Optimizers
-from .AIutel import default_path
-from .AIutel import AwesomePrompts
-from .AIutel import RawDog
-from .AIutel import Audio
-from .AIutel import available_providers
-from colorama import Fore
-from colorama import init as init_colorama
-from dotenv import load_dotenv
-import g4f
-import webscout
-import webscout.AIutel
-from pyfiglet import figlet_format
-
-init_colorama(autoreset=True)
-
-load_dotenv()  # loads .env variables
-
-console = Console()
-logging.basicConfig(
-    format="%(asctime)s - %(levelname)s : %(message)s ",  
-    datefmt="%H:%M:%S",
-    level=logging.INFO,
-)
-
-try:
-    clipman.init()
-except Exception as e:
-    logging.debug(f"Dropping clipman in favor of pyperclip - {(e)}")
-    import pyperclip
-
-    clipman.set = pyperclip.copy
-    clipman.get = pyperclip.paste
-
-
-class this:
-    """Console's common variables"""
-
-    rich_code_themes = ["monokai", "paraiso-dark", "igor", "vs", "fruity", "xcode"]
-
-    default_provider = "phind"
-
-    getExc = lambda e: e.args[1] if len(e.args) > 1 else str(e)
-
-    context_settings = dict(auto_envvar_prefix="Webscout")
-
-    """Console utils"""
-
-    @staticmethod
-    def run_system_command(
-        command: str, exit_on_error: bool = True, stdout_error: bool = True
-    ):
-        """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.
-
-        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")
-            sys.exit(e.returncode) if exit_on_error else None
-            return (False, e)
-
-    def g4f_providers_in_dict(
-        url=True,
-        working=True,
-        stream=False,
-        context=False,
-        gpt35=False,
-        gpt4=False,
-        selenium=False,
-    ):
-        from webscout.g4f import GPT4FREE
-        import g4f.Provider.selenium as selenium_based
-
-        selenium_based_providers: list = dir(selenium_based)
-        hunted_providers = []
-        required_attrs = (
-            "url",
-            "working",
-            "supports_gpt_35_turbo",
-            "supports_gpt_4",
-            "supports_stream",
-            "supports_message_history",
-        )
-
-        def sanitize_provider(provider: object):
-            for attr in required_attrs:
-                if not hasattr(provider, attr):
-                    setattr(provider, attr, False)
-
-            return provider
-
-        for provider_name, provider_class in g4f.Provider.__map__.items():
-            provider = sanitize_provider(provider_class)
-            provider_meta = dict(name=provider_name)
-            if url:
-                provider_meta["url"] = provider.url
-            if working:
-                provider_meta["working"] = provider.working
-            if stream:
-                provider_meta["stream"] = provider.supports_stream
-            if context:
-                provider_meta["context"] = provider.supports_message_history
-            if gpt35:
-                provider_meta["gpt35_turbo"] = provider.supports_gpt_35_turbo
-            if gpt4:
-                provider_meta["gpt4"] = provider.supports_gpt_4
-            if selenium:
-                try:
-                    selenium_based_providers.index(provider_meta["name"])
-                    value = True
-                except ValueError:
-                    value = False
-                provider_meta["non_selenium"] = value
-
-            hunted_providers.append(provider_meta)
-
-        return hunted_providers
-
-    @staticmethod
-    def stream_output(
-        iterable: Iterator,
-        title: str = "",
-        is_markdown: bool = True,
-        style: object = Style(),
-        transient: bool = False,
-        title_generator: object = None,
-        title_generator_params: dict = {},
-        code_theme: str = "monokai",
-        vertical_overflow: str = "ellipsis",
-    ) -> None:
-        """Stdout streaming response
-
-        Args:
-           iterable (Iterator): Iterator containing contents to be stdout
-           title (str, optional): Content title. Defaults to ''.
-           is_markdown (bool, optional): Flag for markdown content. Defaults to True.
-           style (object, optional): `rich.style` instance. Defaults to Style().
-           transient (bool, optional): Flag for transient. Defaults to False.
-           title_generator (object, optional): Function for generating title. Defaults to None.
-           title_generator_params (dict, optional): Kwargs for `title_generator` function. Defaults to {}.
-           code_theme (str, optional): Theme for styling codes. Defaults to `monokai`
-           vertical_overflow (str, optional): Vertical overflow behaviour on content display. Defaultss to ellipsis.
-        """
-        render_this = ""
-        with Live(
-            render_this,
-            transient=transient,
-            refresh_per_second=8,
-            vertical_overflow=vertical_overflow,
-        ) as live:
-            for entry in iterable:
-                render_this += entry
-                live.update(
-                    Panel(
-                        (
-                            Markdown(entry, code_theme=code_theme)
-                            if is_markdown
-                            else entry
-                        ),
-                        title=title,
-                        style=style,
-                    )
-                )
-        if title_generator:
-            title = title_generator(**title_generator_params)
-            live.update(
-                Panel(
-                    Markdown(entry, code_theme=code_theme) if is_markdown else entry,
-                    title=title,
-                    style=style,
-                )
-            )
-
-    @staticmethod
-    def clear_history_file(file_path, is_true):
-        """When --new flag is True"""
-        if is_true and os.path.isfile(file_path):
-            try:
-                os.remove(file_path)
-            except Exception as e:
-                logging.error(
-                    f"Failed to clear previous chat history - {this.getExc(e)}"
-                )
-
-    @staticmethod
-    def handle_exception(func):
-        """Safely handles cli-based exceptions and exit status-codes"""
-
-        @wraps(func)
-        def decorator(*args, **kwargs):
-            try:
-                exit_status = func(*args, **kwargs)
-            except Exception as e:
-                exit_status = False
-                logging.error(this.getExc(e))
-            finally:
-                sys.exit(0 if exit_status not in (False, "") else 1)
-
-        return decorator
-
-
-class busy_bar:
-    querying = None
-    __spinner = (
-        (),
-        ("-", "\\", "|", "/"),
-        (
-            "█■■■■",
-            "■█■■■",
-            "■■█■■",
-            "■■■█■",
-            "■■■■█",
-        ),
-        ("⣾ ", "⣽ ", "⣻ ", "⢿ ", "⡿ ", "⣟ ", "⣯ ", "⣷ "),
-    )
-    spin_index = 0
-    sleep_time = 0.1
-
-    @classmethod
-    def __action(
-        cls,
-    ):
-        while cls.querying:
-            for spin in cls.__spinner[cls.spin_index]:
-                print(" " + spin, end="\r", flush=True)
-                if not cls.querying:
-                    break
-                time.sleep(cls.sleep_time)
-
-    @classmethod
-    def start_spinning(
-        cls,
-    ):
-        try:
-            cls.querying = True
-            t1 = thr(
-                target=cls.__action,
-                args=(),
-            )
-            t1.start()
-        except Exception as e:
-            cls.querying = False
-            logging.debug(this.getExc(e))
-            t1.join()
-
-    @classmethod
-    def stop_spinning(cls):
-        """Stop displaying busy-bar"""
-        if cls.querying:
-            cls.querying = False
-            time.sleep(cls.sleep_time)
-
-    @classmethod
-    def run(cls, help: str = "Exception", index: int = None, immediate: bool = False):
-        """Handle function exceptions safely why showing busy bar
-
-        Args:
-            help (str, optional): Message to be shown incase of an exception. Defaults to ''.
-            index (int, optional): Busy bars spin index. Defaults to `default`.
-            immediate (bool, optional): Start the spinning immediately. Defaults to False.
-        """
-        if isinstance(index, int):
-            cls.spin_index = index
-
-        def decorator(func):
-            @wraps(func)  # Preserves function metadata
-            def main(*args, **kwargs):
-                try:
-                    if immediate:
-                        cls.start_spinning()
-                    return func(*args, **kwargs)
-                except KeyboardInterrupt:
-                    cls.stop_spinning()
-                    return
-                except EOFError:
-                    cls.querying = False
-                    sys.exit(logging.info("Stopping program"))
-                except Exception as e:
-                    logging.error(f"{help} - {this.getExc(e)}")
-                finally:
-                    cls.stop_spinning()
-
-            return main
-
-        return decorator
-
-
-class Main(cmd.Cmd):
-    intro = (
-        "Welcome to webai Chat in terminal. "
-        "Type 'help' or 'h' for usage info.\n"
-    )
-
-    def __init__(
-        self,
-        max_tokens,
-        temperature,
-        top_k,
-        top_p,
-        model,
-        auth,
-        timeout,
-        disable_conversation,
-        filepath,
-        update_file,
-        intro,
-        history_offset,
-        awesome_prompt,
-        proxy_path,
-        provider,
-        quiet=False,
-        chat_completion=False,
-        ignore_working=False,
-        rawdog=False,
-        internal_exec=False,
-        confirm_script=False,
-        interpreter="python",
-        *args,
-        **kwargs,
-    ):
-        super().__init__(*args, **kwargs)
-        if proxy_path:
-            with open(proxy_path) as fh:
-                proxies = json.load(fh)
-        else:
-            proxies = {}
-
-        try:
-            getOr = lambda option, default: option if option else default
-
-            if rawdog:
-
-                self.RawDog = RawDog(
-                    quiet=quiet,
-                    internal_exec=internal_exec,
-                    confirm_script=confirm_script,
-                    interpreter=interpreter,
-                    prettify=True,
-                )
-                intro = self.RawDog.intro_prompt
-                getpass.getuser = lambda: "RawDog"
-
-            if provider == "g4fauto":
-                from webscout.g4f import TestProviders
-
-                test = TestProviders(quiet=quiet, timeout=timeout)
-                g4fauto = test.best if ignore_working else test.auto
-                if isinstance(g4fauto, str):
-                    provider = "g4fauto+" + g4fauto
-                    from webscout.g4f import GPT4FREE
-
-                    self.bot = GPT4FREE(
-                        provider=g4fauto,
-                        auth=auth,
-                        max_tokens=max_tokens,
-                        model=model,
-                        chat_completion=chat_completion,
-                        ignore_working=ignore_working,
-                        timeout=timeout,
-                        intro=intro,
-                        filepath=filepath,
-                        update_file=update_file,
-                        proxies=proxies,
-                        history_offset=history_offset,
-                        act=awesome_prompt,
-                    )
-                else:
-                    raise Exception(
-                        "No working g4f provider found. "
-                        "Consider running 'webscout gpt4free test -y' first"
-                    )
-            elif provider == "poe":
-                assert auth, (
-                    "Path to poe.com.cookies.json file or 'p-b' cookie-value is required. "
-                    "Use the flag `--key` or `-k`"
-                )
-                from webscout import POE
-
-                self.bot = POE(
-                    cookie=auth,
-                    model=getOr(model, "Assistant"),
-                    proxy=bool(proxies),
-                    timeout=timeout,
-                    filepath=filepath,
-                    update_file=update_file,
-                    intro=intro,
-                    act=awesome_prompt,
-                )
-            elif provider == "openai":
-                assert auth, (
-                    "OpenAI's API-key is required. " "Use the flag `--key` or `-k`"
-                )
-                from webscout import OPENAI
-
-                self.bot = OPENAI(
-                    api_key=auth,
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    temperature=temperature,
-                    presence_penalty=top_p,
-                    frequency_penalty=top_k,
-                    top_p=top_p,
-                    model=getOr(model, model),
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                )
-            if provider == "auto":
-                from webscout import AUTO
-
-                self.bot = AUTO(
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                )
-            elif provider == "opengpt":
-                from webscout import OPENGPT
-
-                self.bot = OPENGPT(
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                    assistant_id="bca37014-6f97-4f2b-8928-81ea8d478d88"
-                )
-            elif provider == "thinkany":
-                from webscout import ThinkAnyAI
-
-                self.bot = ThinkAnyAI(
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                )
-            elif provider == "llama3":
-                from webscout import LLAMA3
-                self.bot = LLAMA3(
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                    model=getOr(model, "llama3-8b"),
-                )
-            elif provider == "berlin4h":
-                from webscout import Berlin4h
-
-                self.bot = Berlin4h(
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                )
-            elif provider == "yepchat":
-                from webscout import YEPCHAT
-
-                self.bot = YEPCHAT(
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    temperature=temperature,
-                    presence_penalty=top_p,
-                    frequency_penalty=top_k,
-                    top_p=top_p,
-                    model=getOr(model, "Mixtral-8x7B-Instruct-v0.1"),
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                )
-            elif provider == "groq":
-                assert auth, (
-                    "GROQ's API-key is required. " "Use the flag `--key` or `-k`"
-                )
-                from webscout import GROQ
-
-
-                self.bot = GROQ(
-                    api_key=auth,
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    temperature=temperature,
-                    presence_penalty=top_p,
-                    frequency_penalty=top_k,
-                    top_p=top_p,
-                    model=getOr(model, "mixtral-8x7b-32768"),
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                )
-            elif provider == "cohere":
-                assert auth, (
-                    "Cohere's API-key is required. Use the flag `--key` or `-k`"
-                )
-                from webscout import Cohere
-                self.bot = Cohere(
-                    api_key=auth,
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    temperature=temperature,
-                    top_k=top_k,
-                    top_p=top_p,
-                    model=getOr(model, "command-r-plus"),
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-            )
-            elif provider == "reka":
-                from webscout import REKA
-
-                self.bot = REKA(
-                    api_key=auth,
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                    model=getOr(model, "reka-core"),
-                    # quiet=quiet,
-                )
-            elif provider == "deepseek":
-                from webscout import DeepSeek
-
-                self.bot = DeepSeek(
-                    api_key=auth,
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                    model=getOr(model, "deepseek_chat"),
-                    # quiet=quiet,
-                )
-            elif provider == "koboldai":
-                from webscout import KOBOLDAI
-
-                self.bot = KOBOLDAI(
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    temperature=temperature,
-                    top_p=top_p,
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                )
-            elif provider == "deepinfra":
-                from webscout import DeepInfra
-
-                self.bot = DeepInfra(
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    model=getOr(model, "Qwen/Qwen2-72B-Instruct"),
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                )
-            elif provider == "xjai":
-                from webscout import Xjai
-
-                self.bot = Xjai(
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    temperature=temperature,
-                    top_p=top_p,
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                )
-
-            elif provider == "vtlchat":
-                from webscout import VTLchat
-
-                self.bot = VTLchat(
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    temperature=temperature,
-                    top_p=top_p,
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                )
-            elif provider == "gemini":
-                from webscout import GEMINI
-
-                assert auth, (
-                    "Path to gemini.google.com.cookies.json file is required. "
-                    "Use the flag `--key` or `-k`"
-                )
-                self.bot = GEMINI(
-                    cookie_file=auth,
-                    proxy=proxies,
-                    timeout=timeout,
-                )
-
-            elif provider == "phind":
-                from webscout import PhindSearch
-
-                self.bot = PhindSearch(
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                    model=getOr(model, "Phind Model"),
-                    quiet=quiet,
-                )
-            elif provider == "andi":
-                from webscout import AndiSearch
-
-                self.bot = AndiSearch(
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                )
-            elif provider == "blackboxai":
-
-                from webscout import BLACKBOXAI
-
-                self.bot = BLACKBOXAI(
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                )
-            elif provider == "you":
-
-                from webscout import YouChat
-
-                self.bot = YouChat(
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                )
-
-            elif provider in webscout.gpt4free_providers:
-                from webscout.g4f import GPT4FREE
-
-                self.bot = GPT4FREE(
-                    provider=provider,
-                    is_conversation=disable_conversation,
-                    auth=auth,
-                    max_tokens=max_tokens,
-                    model=model,
-                    chat_completion=chat_completion,
-                    ignore_working=ignore_working,
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                )
-
-
-            elif provider == "perplexity":
-                from webscout import Perplexity
-
-                self.bot = Perplexity(
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                    quiet=quiet,
-                )
-            elif provider == "ollama":
-                from webscout import OLLAMA
-
-                self.bot = OLLAMA(
-                    is_conversation=disable_conversation,
-                    max_tokens=max_tokens,
-                    timeout=timeout,
-                    intro=intro,
-                    filepath=filepath,
-                    update_file=update_file,
-                    proxies=proxies,
-                    history_offset=history_offset,
-                    act=awesome_prompt,
-                    model=getOr(model, "qwen2:0.5b")
-                )
-            else:
-                raise NotImplementedError(
-                    f"The provider `{provider}` is not yet implemented."
-                )
-
-        except Exception as e:
-            logging.error(this.getExc(e))
-            click.secho("Quitting", fg="red")
-            sys.exit(1)
-        self.prettify = True
-        self.color = "cyan"
-        self.code_theme = "monokai"
-        self.quiet = quiet
-        self.vertical_overflow = "ellipsis"
-        self.disable_stream = False
-        self.provider = provider
-        self.disable_coloring = False
-        self.internal_exec = internal_exec
-        self.confirm_script = confirm_script
-        self.interpreter = interpreter
-        self.rawdog = rawdog
-        self.read_aloud = False
-        self.read_aloud_voice = "Brian"
-        self.path_to_last_response_audio = None
-        self.__init_time = time.time()
-        self.__start_time = time.time()
-        self.__end_time = time.time()
-        
-    @property
-    def get_provider(self):
-        if self.provider == "auto" and self.bot.provider_name is not None:
-            return self.bot.provider_name
-        else:
-            return self.provider
-    @property
-    def prompt(self):
-        current_time = datetime.datetime.now().strftime("%H:%M:%S")
-
-        def find_range(start, end, hms: bool = False):
-            in_seconds = round(end - start, 1)
-            return (
-                str(datetime.timedelta(seconds=in_seconds)).split(".")[0].zfill(8)
-                if hms
-                else in_seconds
-            )
-        if not self.disable_coloring:
-            cmd_prompt = (
-                f"╭─[`{Fore.GREEN}{getpass.getuser().capitalize()}@webai]`"
-                f"(`{Fore.YELLOW}{self.get_provider})`"
-                f"~[`{Fore.LIGHTWHITE_EX}⏰{Fore.MAGENTA}{current_time}-`"
-                f"{Fore.LIGHTWHITE_EX}💻{Fore.BLUE}{find_range(self.__init_time, time.time(), True)}-`"
-                f"{Fore.LIGHTWHITE_EX}⚡️{Fore.RED}{find_range(self.__start_time, self.__end_time)}s]`"
-                f"\n╰─>"
-            )
-            whitelist = ["[", "]", "~", "-", "(", ")"]
-            for character in whitelist:
-                cmd_prompt = cmd_prompt.replace(character + "`", Fore.RESET + character)
-            return cmd_prompt
-
-        else:
-            return (
-                f"╭─[{getpass.getuser().capitalize()}@webscout]({self.get_provider})"
-                f"~[⏰{current_time}"
-                f"-💻{find_range(self.__init_time, time.time(), True)}"
-                f"-⚡️{find_range(self.__start_time, self.__end_time)}s]"
-                f"~[⏰{current_time}"
-                f"-💻{find_range(self.__init_time, time.time(), True)}"
-                f"-⚡️{find_range(self.__start_time, self.__end_time)}s]"
-                "\n╰─>"
-            )
-
-    def output_bond(
-        self,
-        title: str,
-        text: str,
-        color: str = "cyan",
-        frame: bool = True,
-        is_json: bool = False,
-    ):
-        """Print prettified output
-
-        Args:
-            title (str): Title
-            text (str): Info to be printed
-            color (str, optional): Output color. Defaults to "cyan".
-            frame (bool, optional): Add frame. Defaults to True.
-        """
-        if is_json:
-            text = f"""
-```json
-{json.dumps(text,indent=4)}
-```
-"""
-        rich.print(
-            Panel(
-                Markdown(text, code_theme=self.code_theme),
-                title=title.title(),
-                style=Style(
-                    color=color,
-                    frame=frame,
-                ),
-            ),
-        )
-        if is_json and click.confirm("Do you wish to save this"):
-            default_path = title + ".json"
-            save_to = click.prompt(
-                "Enter path to save to", default=default_path, type=click.STRING
-            )
-            with open(save_to, "a") as fh:
-                json.dump(text, fh, indent=4)
-            click.secho(f"Successfuly saved to `{save_to}`", fg="green")
-
-    def do_h(self, line):
-        """Show help info in tabular form"""
-        table = Table(
-            title="Help info",
-            show_lines=True,
-        )
-        table.add_column("No.", style="white", justify="center")
-        table.add_column("Command", style="yellow", justify="left")
-        table.add_column("Function", style="cyan")
-        command_methods = [
-            getattr(self, method)
-            for method in dir(self)
-            if callable(getattr(self, method)) and method.startswith("do_")
-        ]
-        command_methods.append(self.default)
-        command_methods.reverse()
-        for no, method in enumerate(command_methods):
-            table.add_row(
-                str(no + 1),
-                method.__name__[3:] if not method == self.default else method.__name__,
-                method.__doc__,
-            )
-        Console().print(table)
-
-    @busy_bar.run("Settings saved")
-    def do_settings(self, line):
-        """Configure settings"""
-        self.prettify = click.confirm(
-            "\nPrettify markdown response", default=self.prettify
-        )
-        busy_bar.spin_index = click.prompt(
-            "Spin bar index [0: None, 1:/, 2:■█■■■, 3:⣻]",
-            default=busy_bar.spin_index,
-            type=click.IntRange(0, 3),
-        )
-        self.color = click.prompt(
-            "Response stdout font color", default=self.color or "white"
-        )
-        self.code_theme = Prompt.ask(
-            "Enter code_theme", choices=this.rich_code_themes, default=self.code_theme
-        )
-        self.vertical_overflow = Prompt.ask(
-            "\nVertical overflow behaviour",
-            choices=["ellipsis", "visible", "crop"],
-            default=self.vertical_overflow,
-        )
-        self.bot.max_tokens_to_sample = click.prompt(
-            "\nMaximum tokens to sample",
-            type=click.INT,
-            default=self.bot.max_tokens_to_sample,
-        )
-        self.bot.temperature = click.prompt(
-            "Temperature", type=click.FLOAT, default=self.bot.temperature
-        )
-        self.bot.top_k = click.prompt(
-            "Chance of topic being repeated, top_k",
-            type=click.FLOAT,
-            default=self.bot.top_k,
-        )
-        self.bot.top_p = click.prompt(
-            "Sampling threshold during inference time, top_p",
-            type=click.FLOAT,
-            default=self.bot.top_p,
-        )
-        self.bot.model = click.prompt(
-            "Model name", type=click.STRING, default=self.bot.model
-        )
-
-    @busy_bar.run(help="System error")
-    def do_copy_this(self, line):
-        """Copy last response
-        Usage:
-           copy_this:
-               text-copied = {whole last-response}
-           copy_this code:
-               text-copied = {All codes in last response}
-        """
-        if self.bot.last_response:
-            global last_response
-            last_response = self.bot.get_message(self.bot.last_response)
-            if not "code" in line:
-                clipman.set(last_response)
-                click.secho("Last response copied successfully!", fg="cyan")
-                return
-
-            # Copies just code
-            sanitized_codes = []
-            code_blocks = re.findall(r"```.*?```", last_response, re.DOTALL)
-            for code_block in code_blocks:
-                new_code_block = re.sub(
-                    "^```.*$", "", code_block.strip(), flags=re.MULTILINE
-                )
-                if bool(new_code_block.strip()):
-                    sanitized_codes.append(new_code_block)
-            if sanitized_codes:
-                if len(sanitized_codes) > 1:
-                    if not click.confirm("Do you wish to copy all codes"):
-                        for index, code in enumerate(sanitized_codes):
-                            rich.print(
-                                Panel(
-                                    Markdown(
-                                        code_blocks[index], code_theme=self.code_theme
-                                    ),
-                                    title=f"Index : {index}",
-                                    title_align="left",
-                                )
-                            )
-
-                        clipman.set(
-                            sanitized_codes[
-                                click.prompt(
-                                    "Enter code index",
-                                    type=click.IntRange(0, len(sanitized_codes) - 1),
-                                )
-                            ]
-                        )
-                        click.secho("Code copied successfully", fg="cyan")
-                    else:
-                        clipman.set("\n\n".join(sanitized_codes))
-                        click.secho(
-                            f"All {len(sanitized_codes)} codes copied successfully!",
-                            fg="cyan",
-                        )
-                else:
-                    clipman.set(sanitized_codes[0])
-                    click.secho("Code copied successfully!", fg="cyan")
-            else:
-                click.secho("No code found in the last response!", fg="red")
-        else:
-            click.secho("Chat with AI first.", fg="yellow")
-
-    @busy_bar.run()
-    def do_with_copied(self, line):
-        """Attach last copied text to the prompt
-        Usage:
-            from_copied:
-                 prompt = {text-copied}
-            from_copied Debug this code:
-                 prompt = Debug this code {newline} {text-copied}
-        """
-        issued_prompt = (
-            f"{line}\n{clipman.get()}" if bool(line.strip()) else clipman.get()
-        )
-        click.secho(issued_prompt, fg="yellow")
-        if click.confirm("Do you wish to proceed"):
-            self.default(issued_prompt)
-
-    @busy_bar.run()
-    def do_code(self, line):
-        """Enhance prompt for code generation
-        usage :
-              code <Code description>
-        """
-        self.default(Optimizers.code(line))
-
-    @busy_bar.run()
-    def do_shell(self, line):
-        """Enhance prompt for system command (shell) generation
-        Usage:
-             shell <Action to be accomplished>
-        """
-        self.default(Optimizers.shell_command(line))
-        if click.confirm("Do you wish to run the command(s) generated in your system"):
-            self.do_sys(self.bot.get_message(self.bot.last_response))
-
-    @busy_bar.run("While changing directory")
-    def do_cd(self, line):
-        """Change directory
-        Usage :
-             cd <path-to-directory>
-        """
-        assert line, "File path is required"
-        os.chdir(line)
-
-    def do_clear(self, line):
-        """Clear console"""
-        sys.stdout.write("\u001b[2J\u001b[H")
-        sys.stdout.flush()
-
-    @busy_bar.run("While handling history")
-    def do_history(self, line):
-        """Show current conversation history"""
-        history = self.bot.conversation.chat_history
-        formatted_history = re.sub(
-            "\nLLM :",
-            "\n\n**LLM** :",
-            re.sub("\nUser :", "\n\n**User** :", history),
-        )
-        self.output_bond("Chat History", formatted_history, self.color)
-        if click.confirm("Do you wish to save this chat"):
-            save_to = click.prompt(
-                "Enter path/file-name", default=f"{self.provider}-chat.txt"
-            )
-            with open(save_to, "a") as fh:
-                fh.write(history)
-            click.secho(f"Conversation saved successfully to '{save_to}'", fg="cyan")
-
-    @busy_bar.run("while resetting conversation")
-    def do_reset(self, line):
-        """Start new conversation thread"""
-        self.bot.conversation.chat_history = click.prompt(
-            "Introductory prompt", default=self.bot.conversation.intro
-        )
-        if hasattr(self.bot, "reset"):
-            self.bot.reset()
-        click.secho("Conversation reset successfully. New one created.", fg="cyan")
-
-    @busy_bar.run("while loading conversation")
-    def do_load(self, line):
-        """Load conversation history from file"""
-        history_file = click.prompt("Enter path to history path", default=line)
-        if not os.path.isfile(history_file):
-            click.secho(f"Path `{history_file}` does not exist!", fg="red")
-            return
-        with open(history_file) as fh:
-            self.bot.conversation.chat_history = fh.read()
-        click.secho("Conversation loaded successfully.", fg="cyan")
-
-    def do_last_response(self, line):
-        """Show whole last response in json format"""
-        self.output_bond(
-            "Last Response",
-            self.bot.last_response,
-            is_json=True,
-        )
-    @busy_bar.run(help="While rereading aloud", index=3, immediate=True)
-    def do_reread(self, line):
-        """Reread aloud last ai response"""
-        if not self.path_to_last_response_audio:
-            raise Exception("Path to last response audio is null")
-        Audio.play(self.path_to_last_response_audio)
-
-    @busy_bar.run()
-    def do_exec(self, line):
-        """Exec python code in last response with RawDog"""
-        last_response = self.bot.get_message(self.bot.last_response)
-        assert last_response, "Last response is null"
-        assert "```python" in last_response, "Last response has no python code"
-        if self.rawdog:
-            self.RawDog.main(last_response)
-        else:
-            rawdog = RawDog(
-                quiet=self.quiet,
-                internal_exec=self.internal_exec,
-                confirm_script=self.confirm_script,
-                interpreter=self.interpreter,
-                prettify=self.prettify,
-            )
-            rawdog.main(last_response)
-
-    @busy_bar.run()
-    def do_rawdog(self, line):
-        """Repeat executing last rawdog's python code"""
-        assert self.rawdog, "Session not in rawdog mode. Restart with --rawdog"
-        self.default(self.bot.get_message(self.bot.last_response))
-
-    @busy_bar.run()
-    def default(self, line, exit_on_error: bool = False, normal_stdout: bool = False):
-        """Chat with LLM"""
-        if not bool(line):
-            return
-        if line.startswith("./"):
-            os.system(line[2:])
-
-        elif self.rawdog:
-            self.__start_time = time.time()
-            busy_bar.start_spinning()
-            ai_response = self.bot.chat(line, stream=False)
-            busy_bar.stop_spinning()
-            is_feedback = self.RawDog.main(ai_response)
-            if is_feedback:
-                return self.default(is_feedback)
-            self.__end_time = time.time()
-
-        else:
-            self.__start_time = time.time()
-            try:
-
-                def generate_response():
-                    # Ensure response is yielded
-                    def for_stream():
-                        return self.bot.chat(line, stream=True)
-
-                    def for_non_stream():
-                        yield self.bot.chat(line, stream=False)
-
-                    return for_non_stream() if self.disable_stream else for_stream()
-
-                busy_bar.start_spinning()
-                generated_response = generate_response()
-
-                if normal_stdout or not self.prettify and not self.disable_stream:
-                    cached_response: str = ""
-                    if not normal_stdout:
-                        busy_bar.stop_spinning()
-                    for response in generated_response:
-                        offset = len(cached_response)
-                        print(response[offset:], end="")
-                        cached_response = response
-                    if not normal_stdout:
-                        print("")
-                    return
-
-                if self.quiet:
-                    busy_bar.stop_spinning()
-                    console_ = Console()
-                    with Live(
-                        console=console_,
-                        refresh_per_second=16,
-                        vertical_overflow=self.vertical_overflow,
-                    ) as live:
-                        for response in generated_response:
-                            live.update(
-                                Markdown(response, code_theme=self.code_theme)
-                                if self.prettify
-                                else response
-                            )
-                else:
-                    busy_bar.stop_spinning()
-                    this.stream_output(
-                        generated_response,
-                        title="Webscout",
-                        is_markdown=self.prettify,
-                        style=Style(
-                            color=self.color,
-                        ),
-                        code_theme=self.code_theme,
-                        vertical_overflow=self.vertical_overflow,
-                    )
-            except (KeyboardInterrupt, EOFError):
-                busy_bar.stop_spinning()
-                print("")
-                return False  # Exit cmd
-
-            except Exception as e:
-                # logging.exception(e)
-                busy_bar.stop_spinning()
-                logging.error(this.getExc(e))
-                if exit_on_error:
-                    sys.exit(1)
-            
-            else:
-                self.post_default()
-
-            finally:
-                self.__end_time = time.time()
-    @busy_bar.run(help="While reading aloud", immediate=True, index=3)
-    def post_default(self):
-        """Actions to be taken after upon successfull complete response generation triggered by `default` function"""
-        last_text: str = self.bot.get_message(self.bot.last_response)
-        if self.read_aloud and last_text is not None:
-            # Talk back to user
-            self.path_to_last_response_audio = Audio.text_to_audio(
-                last_text, voice=self.read_aloud_voice, auto=True
-            )
-            Audio.play(self.path_to_last_response_audio)
-    def do_sys(self, line):
-        """Execute system commands
-        shortcut [./<command>]
-        Usage:
-            sys <System command>
-                  or
-             ./<System command>
-        """
-        os.system(line)
-
-    def do_exit(self, line):
-        """Quit this program"""
-        if click.confirm("Are you sure to exit"):
-            click.secho("Okay Goodbye!", fg="yellow")
-            return True
-
-
-class EntryGroup:
-    """Entry commands"""
-
-    # @staticmethod
-    @click.group()
-    @click.version_option(
-        webscout.__version__, "-v", "--version", package_name="webscout"
-    )
-    @click.help_option("-h", "--help")
-    def webai_():
-        pass
-
-    @staticmethod
-    @webai_.group()
-    @click.help_option("-h", "--help")
-    def utils():
-        """Utility endpoint for webscout"""
-        pass
-
-    @staticmethod
-    @webai_.group()
-    @click.help_option("-h", "--help")
-    def gpt4free():
-        """Discover gpt4free models, providers etc"""
-        pass
-
-    @staticmethod
-    @webai_.group()  
-    @click.help_option("-h", "--help")
-    def awesome():
-        """Perform CRUD operations on awesome-prompts"""
-        pass
-
-
-import webscout
-class Chatwebai:
-    """webai command"""
-
-    @staticmethod
-    @click.command(context_settings=this.context_settings)
-    @click.option(
-        "-m",
-        "--model",
-        help="Model name for text-generation",  # default="llama-2-13b-chat"
-    )
-    @click.option(
-        "-t",
-        "--temperature",
-        help="Charge of the generated text's randomness",
-        type=click.FloatRange(0, 1),
-        default=0.2,
-    )
-    @click.option(
-        "-mt",
-        "--max-tokens",
-        help="Maximum number of tokens to be generated upon completion",
-        type=click.INT,
-        default=600,
-    )
-    @click.option(
-        "-tp",
-        "--top-p",
-        help="Sampling threshold during inference time",
-        type=click.FLOAT,
-        default=0.999,
-    )
-    @click.option(
-        "-tk",
-        "--top-k",
-        help="Chance of topic being repeated",
-        type=click.FLOAT,
-        default=0,
-    )
-    @click.option(
-        "-k",
-        "--key",
-        help="LLM API access key or auth value or path to LLM with provider.",
-    )
-    @click.option(
-        "-ct",
-        "--code-theme",
-        help="Theme for displaying codes in response",
-        type=click.Choice(this.rich_code_themes),
-        default="monokai",
-    )
-    @click.option(
-        "-bi",
-        "--busy-bar-index",
-        help="Index of busy bar icon : [0: None, 1:/, 2:■█■■■, 3:⣻]",
-        type=click.IntRange(0, 3),
-        default=3,
-    )
-    @click.option("-fc", "--font-color", help="Stdout font color")
-    @click.option(
-        "-to", "--timeout", help="Http requesting timeout", type=click.INT, default=30
-    )
-    @click.argument("prompt", required=False)
-    @click.option(
-        "--prettify/--raw",
-        help="Flag for prettifying markdowned response",
-        default=True,
-    )
-    @click.option(
-        "-dc",
-        "--disable-conversation",
-        is_flag=True,
-        default=True,  # is_conversation = True
-        help="Disable chatting conversationally (Stable)",
-    )
-    @click.option(
-        "-fp",
-        "--filepath",
-        type=click.Path(),
-        default=os.path.join(default_path, "chat-history.txt"),
-        help="Path to chat history - new will be created incase doesn't exist",
-    )
-    @click.option(
-        "--update-file/--retain-file",
-        help="Controls updating chat history in file",
-        default=True,
-    )
-    @click.option(
-        "-i",
-        "--intro",
-        help="Conversation introductory prompt",
-    )
-    @click.option(
-        "-ho",
-        "--history-offset",
-        help="Limit conversation history to this number of last texts",
-        type=click.IntRange(100, 16000),
-        default=10250,
-    )
-    @click.option(
-        "-ap",
-        "--awesome-prompt",
-        default="0",
-        callback=lambda ctx, param, value: (
-            int(value) if str(value).isdigit() else value
-        ),
-        help="Awesome prompt key or index. Alt. to intro",
-    )
-    @click.option(
-        "-pp",
-        "--proxy-path",
-        type=click.Path(exists=True),
-        help="Path to .json file containing proxies",
-    )
-    @click.option(
-        "-p",
-        "--provider",
-        type=click.Choice(available_providers),
-        default=this.default_provider,
-        help="Name of LLM provider.",
-        metavar=(
-            f"[{'|'.join(webscout.webai)}] etc, "
-            "run 'webscout gpt4free list providers -w' to "
-            "view more providers and 'webscout gpt4free test -y' "
-            "for advanced g4f providers test"
-        ),
-    )
-    @click.option(
-        "-vo",
-        "--vertical-overflow",
-        help="Vertical overflow behaviour on content display",
-        type=click.Choice(["visible", "crop", "ellipsis"]),
-        default="ellipsis",
-    )
-    @click.option(
-        "-w",
-        "--whole",
-        is_flag=True,
-        default=False,
-        help="Disable streaming response",
-    )
-    @click.option(
-        "-q",
-        "--quiet",
-        is_flag=True,
-        help="Flag for controlling response-framing and response verbosity",
-        default=False,
-    )
-    @click.option(
-        "-n",
-        "--new",
-        help="Overwrite the filepath contents",
-        is_flag=True,
-    )
-    @click.option(
-        "-wc",
-        "--with-copied",
-        is_flag=True,
-        help="Postfix prompt with last copied text",
-    )
-    @click.option(
-        "-nc", "--no-coloring", is_flag=True, help="Disable intro prompt font-coloring"
-    )
-    @click.option(
-        "-cc",
-        "--chat-completion",
-        is_flag=True,
-        help="Provide native context for gpt4free providers",
-    )
-    @click.option(
-        "-iw",
-        "--ignore-working",
-        is_flag=True,
-        help="Ignore working status of the provider",
-    )
-    @click.option(
-        "-rd",
-        "--rawdog",
-        is_flag=True,
-        help="Generate and auto-execute Python scripts - (experimental)",
-    )
-    @click.option(
-        "-ix",
-        "--internal-exec",
-        is_flag=True,
-        help="RawDog : Execute scripts with exec function instead of out-of-script interpreter",
-    )
-    @click.option(
-        "-cs",
-        "--confirm-script",
-        is_flag=True,
-        help="RawDog : Give consent to generated scripts prior to execution",
-    )
-    @click.option(
-        "-int",
-        "--interpreter",
-        default="python",
-        help="RawDog : Python's interpreter name",
-    )
-    @click.option(
-        "-ttm",
-        "--talk-to-me",
-        is_flag=True,
-        help="Audiolize responses upon complete generation",
-    )
-    @click.option(
-        "-ttmv",
-        "--talk-to-me-voice",
-        help="The voice to use for speech synthesis",
-        type=click.Choice(Audio.all_voices),
-        metavar="|".join(Audio.all_voices[:8]),
-        default="Brian",
-    )
-    @click.help_option("-h", "--help")
-    def webai(
-        model,
-        temperature,
-        max_tokens,
-        top_p,
-        top_k,
-        key,
-        code_theme,
-        busy_bar_index,
-        font_color,
-        timeout,
-        prompt,
-        prettify,
-        disable_conversation,
-        filepath,
-        update_file,
-        intro,
-        history_offset,
-        awesome_prompt,
-        proxy_path,
-        provider,
-        vertical_overflow,
-        whole,
-        quiet,
-        new,
-        with_copied,
-        no_coloring,
-        chat_completion,
-        ignore_working,
-        rawdog,
-        internal_exec,
-        confirm_script,
-        interpreter,
-        talk_to_me,
-        talk_to_me_voice,
-    ):
-        """Chat with AI webaily (Default)"""
-        this.clear_history_file(filepath, new)
-        bot = Main(
-            max_tokens,
-            temperature,
-            top_k,
-            top_p,
-            model,
-            key,
-            timeout,
-            disable_conversation,
-            filepath,
-            update_file,
-            intro,
-            history_offset,
-            awesome_prompt,
-            proxy_path,
-            provider,
-            quiet,
-            chat_completion,
-            ignore_working,
-            rawdog=rawdog,
-            internal_exec=internal_exec,
-            confirm_script=confirm_script,
-            interpreter=interpreter,
-        )
-        busy_bar.spin_index = busy_bar_index
-        bot.code_theme = code_theme
-        bot.color = font_color
-        bot.disable_coloring = no_coloring
-        bot.prettify = prettify
-        bot.vertical_overflow = vertical_overflow
-        bot.disable_stream = whole
-        bot.read_aloud = talk_to_me
-        bot.read_aloud_voice = talk_to_me_voice
-        if prompt:
-            if with_copied:
-                prompt = prompt + "\n" + clipman.get()
-            bot.default(prompt)
-        bot.cmdloop()
-
-
-class ChatGenerate:
-    """Generate command"""
-
-    @staticmethod
-    @click.command(context_settings=this.context_settings)
-    @click.option(
-        "-m",
-        "--model",
-        help="Model name for text-generation",
-    )
-    @click.option(
-        "-t",
-        "--temperature",
-        help="Charge of the generated text's randomness",
-        type=click.FloatRange(0, 1),
-        default=0.2,
-    )
-    @click.option(
-        "-mt",
-        "--max-tokens",
-        help="Maximum number of tokens to be generated upon completion",
-        type=click.INT,
-        default=600,
-    )
-    @click.option(
-        "-tp",
-        "--top-p",
-        help="Sampling threshold during inference time",
-        type=click.FLOAT,
-        default=0.999,
-    )
-    @click.option(
-        "-tk",
-        "--top-k",
-        help="Chance of topic being repeated",
-        type=click.FLOAT,
-        default=0,
-    )
-    @click.option(
-        "-k",
-        "--key",
-        help="LLM API access key or auth value or path to LLM with provider.",
-    )
-    @click.option(
-        "-ct",
-        "--code-theme",
-        help="Theme for displaying codes in response",
-        type=click.Choice(this.rich_code_themes),
-        default="monokai",
-    )
-    @click.option(
-        "-bi",
-        "--busy-bar-index",
-        help="Index of busy bar icon : [0: None, 1:/, 2:■█■■■, 3:⣻]",
-        type=click.IntRange(0, 3),
-        default=3,
-    )
-    @click.option(
-        "-fc",
-        "--font-color",
-        help="Stdout font color",
-    )
-    @click.option(
-        "-to", "--timeout", help="Http requesting timeout", type=click.INT, default=30
-    )
-    @click.argument("prompt", required=False)
-    @click.option(
-        "--prettify/--raw",
-        help="Flag for prettifying markdowned response",
-        default=True,
-    )
-    @click.option(
-        "-w",
-        "--whole",
-        is_flag=True,
-        default=False,
-        help="Disable streaming response",
-    )
-    @click.option(
-        "-c",
-        "--code",
-        is_flag=True,
-        default=False,
-        help="Optimize prompt for code generation",
-    )
-    @click.option(
-        "-s",
-        "--shell",
-        is_flag=True,
-        default=False,
-        help="Optimize prompt for shell command generation",
-    )
-    @click.option(
-        "-dc",
-        "--disable-conversation",
-        is_flag=True,
-        default=True,  # is_conversation = True
-        help="Disable chatting conversationally (Stable)",
-    )
-    @click.option(
-        "-fp",
-        "--filepath",
-        type=click.Path(),
-        default=os.path.join(default_path, "chat-history.txt"),
-        help="Path to chat history - new will be created incase doesn't exist",
-    )
-    @click.option(
-        "--update-file/--retain-file",
-        help="Controls updating chat history in file",
-        default=True,
-    )
-    @click.option(
-        "-i",
-        "--intro",
-        help="Conversation introductory prompt",
-    )
-    @click.option(
-        "-ho",
-        "--history-offset",
-        help="Limit conversation history to this number of last texts",
-        type=click.IntRange(100, 16000),
-        default=10250,
-    )
-    @click.option(
-        "-ap",
-        "--awesome-prompt",
-        default="0",
-        callback=lambda ctx, param, value: (
-            int(value) if str(value).isdigit() else value
-        ),
-        help="Awesome prompt key or index. Alt. to intro",
-    )
-    @click.option(
-        "-pp",
-        "--proxy-path",
-        type=click.Path(exists=True),
-        help="Path to .json file containing proxies",
-    )
-    @click.option(
-        "-p",
-        "--provider",
-        type=click.Choice(webscout.available_providers),
-        default=this.default_provider,
-        help="Name of LLM provider.",
-        metavar=(
-            f"[{'|'.join(webscout.webai)}] etc, "
-            "run 'webscout gpt4free list providers -w' to "
-            "view more providers and 'webscout gpt4free test -y' "
-            "for advanced g4f providers test"
-        ),
-    )
-    @click.option(
-        "-vo",
-        "--vertical-overflow",
-        help="Vertical overflow behaviour on content display",
-        type=click.Choice(["visible", "crop", "ellipsis"]),
-        default="ellipsis",
-    )
-    @click.option(
-        "-q",
-        "--quiet",
-        is_flag=True,
-        help="Flag for controlling response-framing and response verbosity",
-        default=False,
-    )
-    @click.option(
-        "-n",
-        "--new",
-        help="Override the filepath contents",
-        is_flag=True,
-    )
-    @click.option(
-        "-wc",
-        "--with-copied",
-        is_flag=True,
-        help="Postfix prompt with last copied text",
-    )
-    @click.option(
-        "-iw",
-        "--ignore-working",
-        is_flag=True,
-        help="Ignore working status of the provider",
-    )
-    @click.option(
-        "-rd",
-        "--rawdog",
-        is_flag=True,
-        help="Generate and auto-execute Python scripts - (experimental)",
-    )
-    @click.option(
-        "-ix",
-        "--internal-exec",
-        is_flag=True,
-        help="RawDog : Execute scripts with exec function instead of out-of-script interpreter",
-    )
-    @click.option(
-        "-cs",
-        "--confirm-script",
-        is_flag=True,
-        help="RawDog : Give consent to generated scripts prior to execution",
-    )
-    @click.option(
-        "-int",
-        "--interpreter",
-        default="python",
-        help="RawDog : Python's interpreter name",
-    )
-    @click.option(
-        "-ttm",
-        "--talk-to-me",
-        is_flag=True,
-        help="Audiolize responses upon complete generation",
-    )
-    @click.option(
-        "-ttmv",
-        "--talk-to-me-voice",
-        help="The voice to use for speech synthesis",
-        type=click.Choice(Audio.all_voices),
-        metavar="|".join(Audio.all_voices[:8]),
-        default="Brian",
-    )
-    @click.help_option("-h", "--help")
-    def generate(
-        model,
-        temperature,
-        max_tokens,
-        top_p,
-        top_k,
-        key,
-        code_theme,
-        busy_bar_index,
-        font_color,
-        timeout,
-        prompt,
-        prettify,
-        whole,
-        code,
-        shell,
-        disable_conversation,
-        filepath,
-        update_file,
-        intro,
-        history_offset,
-        awesome_prompt,
-        proxy_path,
-        provider,
-        vertical_overflow,
-        quiet,
-        new,
-        with_copied,
-        ignore_working,
-        rawdog,
-        internal_exec,
-        confirm_script,
-        interpreter,
-        talk_to_me,
-        talk_to_me_voice,
-    ):
-        """Generate a quick response with AI"""
-        this.clear_history_file(filepath, new)
-        bot = Main(
-            max_tokens,
-            temperature,
-            top_k,
-            top_p,
-            model,
-            key,
-            timeout,
-            disable_conversation,
-            filepath,
-            update_file,
-            intro,
-            history_offset,
-            awesome_prompt,
-            proxy_path,
-            provider,
-            quiet,
-            ignore_working=ignore_working,
-            rawdog=rawdog,
-            internal_exec=internal_exec,
-            confirm_script=confirm_script,
-            interpreter=interpreter,
-        )
-        prompt = prompt if prompt else ""
-        copied_placeholder = "{{copied}}"
-        stream_placeholder = "{{stream}}"
-
-        if with_copied or copied_placeholder in prompt:
-            last_copied_text = clipman.get()
-            assert last_copied_text, "No copied text found, issue prompt"
-
-            if copied_placeholder in prompt:
-                prompt = prompt.replace(copied_placeholder, last_copied_text)
-
-            else:
-                sep = "\n" if prompt else ""
-                prompt = prompt + sep + last_copied_text
-
-        if not prompt and sys.stdin.isatty():  # No prompt issued and no piped input
-            help_info = (
-                "Usage: webscout generate [OPTIONS] PROMPT\n"
-                "Try 'webscout generate --help' for help.\n"
-                "Error: Missing argument 'PROMPT'."
-            )
-            click.secho(
-                help_info
-            )  # Let's try to mimic the click's missing argument help info
-            sys.exit(1)
-
-        if not sys.stdin.isatty():  # Piped input detected - True
-            # Let's try to read piped input
-            stream_text = click.get_text_stream("stdin").read()
-            if stream_placeholder in prompt:
-                prompt = prompt.replace(stream_placeholder, stream_text)
-            else:
-                prompt = prompt + "\n" + stream_text if prompt else stream_text
-
-        assert stream_placeholder not in prompt, (
-            "No piped input detected ~ " + stream_placeholder
-        )
-        assert copied_placeholder not in prompt, (
-            "No copied text found ~ " + copied_placeholder
-        )
-
-        prompt = Optimizers.code(prompt) if code else prompt
-        prompt = Optimizers.shell_command(prompt) if shell else prompt
-        busy_bar.spin_index = (
-            0 if any([quiet, sys.stdout.isatty() == False]) else busy_bar_index
-        )
-        bot.code_theme = code_theme
-        bot.color = font_color
-        bot.prettify = prettify
-        bot.vertical_overflow = vertical_overflow
-        bot.disable_stream = whole
-        bot.read_aloud = talk_to_me
-        bot.read_aloud_voice = talk_to_me_voice
-        bot.default(prompt, True, normal_stdout=(sys.stdout.isatty() == False))
-
-
-class Awesome:
-    """Awesome commands"""
-
-    @staticmethod
-    @click.command(context_settings=this.context_settings)
-    @click.option(
-        "-r",
-        "--remote",
-        help="Remote source to update from",
-        default=AwesomePrompts.awesome_prompt_url,
-    )
-    @click.option(
-        "-o",
-        "--output",
-        help="Path to save the prompts",
-        default=AwesomePrompts.awesome_prompt_path,
-    )
-    @click.option(
-        "-n", "--new", is_flag=True, help="Override the existing contents in path"
-    )
-    @click.help_option("-h", "--help")
-    @this.handle_exception
-    def update(remote, output, new):
-        """Update awesome-prompts from remote source."""
-        AwesomePrompts.awesome_prompt_url = remote
-        AwesomePrompts.awesome_prompt_path = output
-        AwesomePrompts().update_prompts_from_online(new)
-        click.secho(
-            f"Prompts saved to - '{AwesomePrompts.awesome_prompt_path}'", fg="cyan"
-        )
-
-    @staticmethod
-    @click.command(context_settings=this.context_settings)
-    @click.argument(
-        "key",
-        required=True,
-        type=click.STRING,
-    )
-    @click.option(
-        "-d", "--default", help="Return this value if not found", default=None
-    )
-    @click.option(
-        "-c",
-        "--case-sensitive",
-        default=True,
-        flag_value=False,
-        help="Perform case-sensitive search",
-    )
-    @click.option(
-        "-f",
-        "--file",
-        type=click.Path(exists=True),
-        help="Path to existing prompts",
-        default=AwesomePrompts.awesome_prompt_path,
-    )
-    @click.help_option("-h", "--help")
-    @this.handle_exception
-    def search(
-        key,
-        default,
-        case_sensitive,
-        file,
-    ):
-        """Search for a particular awesome-prompt by key or index"""
-        AwesomePrompts.awesome_prompt_path = file
-        resp = AwesomePrompts().get_act(
-            key,
-            default=default,
-            case_insensitive=case_sensitive,
-        )
-        if resp:
-            click.secho(resp)
-            return resp != default
-
-    @staticmethod
-    @click.command(context_settings=this.context_settings)
-    @click.option("-n", "--name", required=True, help="Prompt name")
-    @click.option("-p", "--prompt", required=True, help="Prompt value")
-    @click.option(
-        "-f",
-        "--file",
-        type=click.Path(exists=True),
-        help="Path to existing prompts",
-        default=AwesomePrompts.awesome_prompt_path,
-    )
-    @click.help_option("-h", "--help")
-    @this.handle_exception
-    def add(name, prompt, file):
-        """Add new prompt to awesome-prompt list"""
-        AwesomePrompts.awesome_prompt_path = file
-        return AwesomePrompts().add_prompt(name, prompt)
-
-    @staticmethod
-    @click.command(context_settings=this.context_settings)
-    @click.argument("name")
-    @click.option(
-        "--case-sensitive",
-        is_flag=True,
-        flag_value=False,
-        default=True,
-        help="Perform name case-sensitive search",
-    )
-    @click.option(
-        "-f",
-        "--file",
-        type=click.Path(exists=True),
-        help="Path to existing prompts",
-        default=AwesomePrompts.awesome_prompt_path,
-    )
-    @click.help_option("-h", "--help")
-    @this.handle_exception
-    def delete(name, case_sensitive, file):
-        """Delete a specific awesome-prompt"""
-        AwesomePrompts.awesome_prompt_path = file
-        return AwesomePrompts().delete_prompt(name, case_sensitive)
-
-    @staticmethod
-    @click.command(context_settings=this.context_settings)
-    @click.option(
-        "-j",
-        "--json",
-        is_flag=True,
-        help="Display prompts in json format",
-    )
-    @click.option(
-        "-i",
-        "--indent",
-        type=click.IntRange(1, 20),
-        help="Json format indentation level",
-        default=4,
-    )
-    @click.option(
-        "-x",
-        "--index",
-        is_flag=True,
-        help="Display prompts with their corresponding indexes",
-    )
-    @click.option("-c", "--color", help="Prompts stdout font color")
-    @click.option("-o", "--output", type=click.Path(), help="Path to save the prompts")
-    @click.help_option("-h", "--help")
-    def whole(json, indent, index, color, output):
-        """Stdout all awesome prompts"""
-        ap = AwesomePrompts()
-        awesome_prompts = ap.all_acts if index else ap.get_acts()
-
-        if json:
-            # click.secho(formatted_awesome_prompts, fg=color)
-            rich.print_json(data=awesome_prompts, indent=indent)
-
-        else:
-            awesome_table = Table(show_lines=True, title="All Awesome-Prompts")
-            awesome_table.add_column("index", justify="center", style="yellow")
-            awesome_table.add_column("Act Name/Index", justify="left", style="cyan")
-            awesome_table.add_column(
-                "Prompt",
-                style=color,
-            )
-            for index, key_value in enumerate(awesome_prompts.items()):
-                awesome_table.add_row(str(index), str(key_value[0]), key_value[1])
-            rich.print(awesome_table)
-
-        if output:
-            from json import dump
-
-            with open(output, "w") as fh:
-                dump(awesome_prompts, fh, indent=4)
-
-
-class Gpt4free:
-    """Commands for gpt4free"""
-
-    @staticmethod
-    @click.command(context_settings=this.context_settings)
-    @busy_bar.run(index=1, immediate=True)
-    @click.help_option("-h", "--help")
-    def version():
-        """Check current installed version of gpt4free"""
-        version_string = this.run_system_command("pip show g4f")[1].stdout.split("\n")[
-            1
-        ]
-        click.secho(version_string, fg="cyan")
-
-    @staticmethod
-    @click.command(context_settings=this.context_settings)
-    @click.help_option("-h", "--help")
-    @click.option(
-        "-e",
-        "--extra",
-        help="Extra required dependencies category",
-        multiple=True,
-        type=click.Choice(
-            ["all", "image", "webdriver", "openai", "api", "gui", "none"]
-        ),
-        default=["all"],
-    )
-    @click.option("-l", "--log", is_flag=True, help="Stdout installation logs")
-    @click.option(
-        "-s",
-        "--sudo",
-        is_flag=True,
-        flag_value="sudo ",
-        help="Install with sudo privileges",
-    )
-    @busy_bar.run(index=1, immediate=True)
-    def update(extra, log, sudo):
-        """Update GPT4FREE package (Models, Providers etc)"""
-        if "none" in extra:
-            command = f"{sudo or ''}pip install --upgrade g4f"
-        else:
-            command = f"{sudo or ''}pip install --upgrade g4f[{','.join(extra)}]"
-        is_successful, response = this.run_system_command(command)
-        if log and is_successful:
-            click.echo(response.stdout)
-        version_string = this.run_system_command("pip show g4f")[1].stdout.split("\n")[
-            1
-        ]
-        click.secho(f"GPT4FREE updated successfully - {version_string}", fg="cyan")
-
-    @staticmethod
-    @click.command("list", context_settings=this.context_settings)
-    @click.argument("target")
-    @click.option("-w", "--working", is_flag=True, help="Restrict to working providers")
-    @click.option("-u", "--url", is_flag=True, help="Restrict to providers with url")
-    @click.option(
-        "-s", "--stream", is_flag=True, help="Restrict to providers supporting stream"
-    )
-    @click.option(
-        "-c",
-        "--context",
-        is_flag=True,
-        help="Restrict to providers supporing context natively",
-    )
-    @click.option(
-        "-35",
-        "--gpt35",
-        is_flag=True,
-        help="Restrict to providers supporting gpt3.5_turbo model",
-    )
-    @click.option(
-        "-4", "--gpt4", is_flag=True, help="Restrict to providers supporting gpt4 model"
-    )
-    @click.option(
-        "-se",
-        "--selenium",
-        is_flag=True,
-        help="Restrict to selenium dependent providers",
-    )
-    @click.option("-j", "--json", is_flag=True, help="Format output in json")
-    @click.help_option("-h", "--help")
-    def show(target, working, url, stream, context, gpt35, gpt4, selenium, json):
-        """List available models and providers"""
-        available_targets = ["models", "providers"]
-        assert (
-            target in available_targets
-        ), f"Target must be one of [{', '.join(available_targets)}]"
-        if target == "providers":
-            hunted_providers = list(
-                set(
-                    map(
-                        lambda provider: (
-                            provider["name"] if all(list(provider.values())) else None
-                        ),
-                        this.g4f_providers_in_dict(
-                            url=url,
-                            working=working,
-                            stream=stream,
-                            context=context,
-                            gpt35=gpt35,
-                            gpt4=gpt4,
-                            selenium=selenium,
-                        ),
-                    )
-                )
-            )
-            while None in hunted_providers:
-                hunted_providers.remove(None)
-
-            hunted_providers.sort()
-            if json:
-                rich.print_json(data=dict(providers=hunted_providers), indent=4)
-
-            else:
-                table = Table(show_lines=True)
-                table.add_column("No.", style="yellow", justify="center")
-                table.add_column("Provider", style="cyan")
-                for no, provider in enumerate(hunted_providers):
-                    table.add_row(str(no), provider)
-                rich.print(table)
-        else:
-            models = dict(
-                Bard=[
-                    "palm",
-                ],
-                HuggingFace=[
-                    "h2ogpt-gm-oasst1-en-2048-falcon-7b-v3",
-                    "h2ogpt-gm-oasst1-en-2048-falcon-40b-v1",
-                    "h2ogpt-gm-oasst1-en-2048-open-llama-13b",
-                    "gpt-neox-20b",
-                    "oasst-sft-1-pythia-12b",
-                    "oasst-sft-4-pythia-12b-epoch-3.5",
-                    "santacoder",
-                    "bloom",
-                    "flan-t5-xxl",
-                ],
-                Anthropic=[
-                    "claude-instant-v1",
-                    "claude-v1",
-                    "claude-v2",
-                ],
-                Cohere=[
-                    "command-light-nightly",
-                    "command-nightly",
-                ],
-                OpenAI=[
-                    "code-davinci-002",
-                    "text-ada-001",
-                    "text-babbage-001",
-                    "text-curie-001",
-                    "text-davinci-002",
-                    "text-davinci-003",
-                    "gpt-3.5-turbo-16k",
-                    "gpt-3.5-turbo-16k-0613",
-                    "gpt-4-0613",
-                ],
-                Replicate=[
-                    "llama13b-v2-chat",
-                    "llama7b-v2-chat",
-                ],
-            )
-            for provider in webscout.g4f.Provider.__providers__:
-                if hasattr(provider, "models"):
-                    models[provider.__name__] = provider.models
-            if json:
-                for key, value in models.items():
-                    while None in value:
-                        value.remove(None)
-                    value.sort()
-                    models[key] = value
-
-                rich.print_json(data=models, indent=4)
-            else:
-                table = Table(show_lines=True)
-                table.add_column("No.", justify="center", style="white")
-                table.add_column("Base Provider", style="cyan")
-                table.add_column("Model(s)", style="yellow")
-                for count, provider_models in enumerate(models.items()):
-                    models = provider_models[1]
-                    models.sort()
-                    table.add_row(str(count), provider_models[0], "\n".join(models))
-                rich.print(table)
-
-    @staticmethod
-    @click.command(context_settings=this.context_settings)
-    @click.argument("port", type=click.INT, required=False)
-    @click.option(
-        "-a", "--address", help="Host on this particular address", default="127.0.0.1"
-    )
-    @click.option("-d", "--debug", is_flag=True, help="Start server in debug mode")
-    @click.option(
-        "-o", "--open", is_flag=True, help="Proceed to the interface immediately"
-    )
-    @click.help_option("-h", "--help")
-    def gui(port, address, debug, open):
-        """Launch gpt4free web interface"""
-        from g4f.gui import run_gui
-
-        port = port or 8000
-        t1 = thr(
-            target=run_gui,
-            args=(
-                address,
-                port,
-                debug,
-            ),
-        )
-        # run_gui(host=address, port=port, debug=debug)
-        t1.start()
-        if open:
-            click.launch(f"http://{address}:{port}")
-        t1.join()
-
-    @staticmethod
-    @click.command(context_settings=this.context_settings)
-    @click.option(
-        "-t",
-        "--timeout",
-        type=click.INT,
-        help="Provider's response generation timeout",
-        default=20,
-    )
-    @click.option(
-        "-r",
-        "--thread",
-        type=click.INT,
-        help="Test n amount of providers at once",
-        default=5,
-    )
-    @click.option("-q", "--quiet", is_flag=True, help="Suppress progress bar")
-    @click.option(
-        "-j", "--json", is_flag=True, help="Stdout test results in json format"
-    )
-    @click.option("-d", "--dry-test", is_flag=True, help="Return previous test results")
-    @click.option(
-        "-b", "--best", is_flag=True, help="Stdout the fastest provider <name only>"
-    )
-    @click.option(
-        "-se",
-        "--selenium",
-        help="Test even selenium dependent providers",
-        is_flag=True,
-    )
-    @click.option(
-        "-dl",
-        "--disable-logging",
-        is_flag=True,
-        help="Disable logging",
-    )
-    @click.option("-y", "--yes", is_flag=True, help="Okay to all confirmations")
-    @click.help_option("-h", "--help")
-    def test(
-        timeout, thread, quiet, json, dry_test, best, selenium, disable_logging, yes
-    ):
-        """Test and save working providers"""
-        from webscout.g4f import TestProviders
-
-        test = TestProviders(
-            test_at_once=thread,
-            quiet=quiet,
-            timeout=timeout,
-            selenium=selenium,
-            do_log=disable_logging == False,
-        )
-        if best:
-            click.secho(test.best)
-            return
-        elif dry_test:
-            results = test.get_results(
-                run=False,
-            )
-        else:
-            if (
-                yes
-                or os.path.isfile(webscout.AIutel.results_path)
-                and click.confirm("Are you sure to run new test")
-            ):
-                results = test.get_results(run=True)
-            else:
-                results = test.get_results(
-                    run=False,
-                )
-        if json:
-            rich.print_json(data=dict(results=results))
-        else:
-            table = Table(
-                title="G4f Providers Test Results",
-                show_lines=True,
-            )
-            table.add_column("No.", style="white", justify="center")
-            table.add_column("Provider", style="yellow", justify="left")
-            table.add_column("Response Time(s)", style="cyan")
-
-            for no, provider in enumerate(results, start=1):
-                table.add_row(
-                    str(no), provider["name"], str(round(provider["time"], 2))
-                )
-            rich.print(table)
-
-
-
-    @staticmethod
-    @click.command(context_settings=this.context_settings)
-    @click.argument("prompt")
-    @click.option(
-        "-d",
-        "--directory",
-        type=click.Path(exists=True),
-        help="Folder for saving the images",
-        default=os.getcwd(),
-    )
-    @click.option(
-        "-a",
-        "--amount",
-        type=click.IntRange(1, 100),
-        help="Total images to be generated",
-        default=1,
-    )
-    @click.option("-n", "--name", help="Name for the generated images")
-    @click.option(
-        "-t",
-        "--timeout",
-        type=click.IntRange(5, 300),
-        help="Http request timeout in seconds",
-    )
-    @click.option("-p", "--proxy", help="Http request proxy")
-    @click.option(
-        "-nd",
-        "--no-additives",
-        is_flag=True,
-        help="Disable prompt altering for effective image generation",
-    )
-    @click.option("-q", "--quiet", is_flag=True, help="Suppress progress bar")
-    @click.help_option("-h", "--help")
-    def generate_image(
-        prompt, directory, amount, name, timeout, proxy, no_additives, quiet
-    ):
-        """Generate images with pollinations.ai"""
-        with Progress() as progress:
-            task = progress.add_task(
-                f"[cyan]Generating ...[{amount}]",
-                total=amount,
-                visible=quiet == False,
-            )
-
-
-
-class Utils:
-    """Utilities command"""
-
-    @staticmethod
-    @click.command(context_settings=this.context_settings)
-    @click.argument("source", required=False)
-    @click.option(
-        "-d", "--dev", is_flag=True, help="Update from version control (development)"
-    )
-    @click.option(
-        "-s",
-        "--sudo",
-        is_flag=True,
-        flag_value="sudo ",
-        help="Install with sudo privileges",
-    )
-    @click.help_option("-h", "--help")
-    @busy_bar.run(index=1, immediate=True)
-    def update(source, dev, sudo):
-        """Install latest version of webscout"""
-        if dev:
-            source = "git+" + webscout.__repo__ + ".git"
-        source = "webscout" if source is None else source
-        assert (
-            "webscout" in source or source == "."
-        ), f"Cannot update webscout from the source '{source}'"
-        click.secho(
-            f"[*] Updating from '{'pip' if source=='webscout' else source}'",
-            fg="yellow",
-        )
-        this.run_system_command(f"{sudo or ''}pip install --upgrade {source}")
-        response = this.run_system_command("pip show webscout")[1]
-        click.secho(response.stdout)
-        click.secho("Congratulations! webscout updated successfully.", fg="cyan")
-
-    @staticmethod
-    @click.command(context_settings=this.context_settings)
-    @click.option("-w", "--whole", is_flag=True, help="Stdout whole json info")
-    @click.option(
-        "-v", "--version", is_flag=True, help="Stdout latest version name only"
-    )
-    @click.option("-b", "--body", is_flag=True, help="Stdout changelog info only")
-    @click.option(
-        "-e", "--executable", is_flag=True, help="Stdout url to binary for your system"
-    )
-    @click.help_option("-h", "--help")
-    def latest(whole, version, body, executable):
-        """Check webscout latest version info"""
-        from webscout.utils import Updates
-
-        update = Updates()
-        if whole:
-            rich.print_json(data=update.latest(whole=True))
-
-        elif version:
-            rich.print(update.latest_version)
-        elif body:
-            rich.print(Markdown(update.latest()["body"]))
-        elif executable:
-            rich.print(update.executable())
-        else:
-            rich.print_json(data=update.latest())
-
-
-def make_commands():
-    """Make webscout chained commands"""
-
-    # generate
-    EntryGroup.webai_.add_command(ChatGenerate.generate)
-
-    # webai
-    EntryGroup.webai_.add_command(Chatwebai.webai)
-
-    # utils
-    EntryGroup.utils.add_command(Utils.update)
-    EntryGroup.utils.add_command(Utils.latest)
-
-    # gpt4free
-    EntryGroup.gpt4free.add_command(Gpt4free.version)
-    EntryGroup.gpt4free.add_command(Gpt4free.update)
-    EntryGroup.gpt4free.add_command(Gpt4free.show)
-    EntryGroup.gpt4free.add_command(Gpt4free.gui)
-    EntryGroup.gpt4free.add_command(Gpt4free.test)
-
-    # Awesome
-    EntryGroup.awesome.add_command(Awesome.add)
-    EntryGroup.awesome.add_command(Awesome.delete)
-    EntryGroup.awesome.add_command(Awesome.search)
-    EntryGroup.awesome.add_command(Awesome.update)
-    EntryGroup.awesome.add_command(Awesome.whole)
-
-
-# @this.handle_exception
-def main(*args):
-    """Fireup console programmically"""
-    console.print(f"[bold green]{figlet_format('WebAI')}[/]\n", justify="center")
-    sys.argv += list(args)
-    args = sys.argv
-    if len(args) == 1:
-        sys.argv.insert(1, "webai")  # Just a hack to make default command
-    try:
-        make_commands()
-        return EntryGroup.webai_()
-    except Exception as e:
-        logging.error(this.getExc(e))
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()