webscout 1.3.0__py3-none-any.whl → 1.3.2__py3-none-any.whl

webscout/AIutel.py

@@ -224,7 +224,7 @@ class Conversation:
 
 class AwesomePrompts:
     awesome_prompt_url = (
-        "https://github.com/Simatwa/gpt-cli/blob/main/assets/all-acts.json?raw=true"
+        "https://raw.githubusercontent.com/OE-LUCIFER/prompts/main/prompt.json"
     )
     awesome_prompt_path = os.path.join(default_path, "all-acts.json")
 
@@ -363,9 +363,9 @@ class AwesomePrompts:
 
 
 class Updates:
-    """Pytgpt latest release info"""
+    """Webscout latest release info"""
 
-    url = "https://api.github.com/repos/Simatwa/python-tgpt/releases/latest"
+    url = "https://api.github.com/repos/OE-LUCIFER/Webscout/releases/latest"
 
     @property
     def latest_version(self):
@@ -385,7 +385,7 @@ class Updates:
                 return entry.get("url")
 
     def latest(self, whole: bool = False, version: bool = False) -> dict:
-        """Check pytgpt latest version info
+        """Check Webscout latest version info
 
         Args:
             whole (bool, optional): Return whole json response. Defaults to False.
@@ -508,7 +508,7 @@ print("The essay is about...")
                 f"{self.interpreter} --version",
                 exit_on_error=True,
                 stdout_error=True,
-                help="If you're using pytgpt-cli, use the flag '--internal-exec'",
+                help="If you're using Webscout-cli, use the flag '--internal-exec'",
             )[1].stdout.split(" ")[1]
         )
 
@@ -588,7 +588,7 @@ Current Datetime : {datetime.datetime.now()}
         if self.quiet:
             return
 
-        message = "[PYTGPT] - " + message
+        message = "[Webscout] - " + message
         if category == "error":
             logging.error(message)
         else:

webscout/LLM.py

@@ -8,7 +8,7 @@ class LLM:
         self.model = model
         self.conversation_history = [{"role": "system", "content": system_message}]
 
-    def mistral_chat(self, messages: List[Dict[str, str]]) -> Union[str, None]:
+    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',
@@ -43,26 +43,3 @@ class LLM:
             return result.json()['choices'][0]['message']['content']
         except:
             return None
-
-    def chat(self):
-        while True:
-            prompt = input("👦: ")
-            user_message = {"role": "user", "content": prompt}
-            self.conversation_history.append(user_message)
-            try:
-                resp = self.mistral_chat(self.conversation_history)
-                print(f"🤖: {resp}")
-                self.conversation_history.append({"role": "assistant", "content": resp})
-            except Exception as e:
-                print(f"🤖: Oops, something went wrong: {e}! Looks like even AI needs some oiling sometimes.")
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description='LLM CLI', epilog='To use a specific model, run:\n'
-                                                                     'python -m webscout.LLM model_name\n'
-                                                                     'Replace "model_name" with the name of the model you wish to use It supports ALL text generation models on deepinfra.com.')
-    parser.add_argument('model', type=str, help='Model to use for text generation. Specify the full model name, e.g., "mistralai/Mistral-7B-Instruct-v0.1".')
-    parser.add_argument('--system-message', type=str, default="You are a Helpful AI.", help='Custom system prompt for the AI.')
-    args = parser.parse_args()
-
-    LLM = LLM(args.model, args.system_message)
-    LLM.chat()

webscout/__init__.py

@@ -3,7 +3,7 @@
 Search for words, documents, images, videos, news, maps and text translation 
 using the Google, DuckDuckGo.com, yep.com, phind.com, you.com, etc Also containes AI models
 """
-
+import g4f
 import logging
 from .webscout_search import WEBS
 from .webscout_search_async import AsyncWEBS
@@ -11,7 +11,28 @@ from .version import __version__
 from .DWEBS import DeepWEBS
 from .transcriber import transcriber
 from .voice import play_audio
+from .LLM import LLM
+
+__repo__ = "https://github.com/OE-LUCIFER/Webscout"
+
+webai = [
+    "leo",
+    "openai",
+    "opengpt",
+    "koboldai",
+    "gemini",
+    "phind",
+    "blackboxai",
+    "g4fauto",
+    "perplexity",
+    "sean",
+]
+
+gpt4free_providers = [
+    provider.__name__ for provider in g4f.Provider.__providers__  # if provider.working
+]
 
+available_providers = webai + gpt4free_providers
 
 __all__ = ["WEBS", "AsyncWEBS", "__version__", "cli"]
 

webscout/g4f.py

@@ -0,0 +1,474 @@
+import g4f
+from webscout.AIutel import Optimizers
+from webscout.AIutel import Conversation
+from webscout.AIutel import AwesomePrompts
+from webscout.AIutel import Provider
+from webscout.AIutel import available_providers
+
+
+g4f.debug.version_check = False
+
+working_providers = available_providers
+
+completion_allowed_models = [
+    "code-davinci-002",
+    "text-ada-001",
+    "text-babbage-001",
+    "text-curie-001",
+    "text-davinci-002",
+    "text-davinci-003",
+]
+
+default_models = {
+    "completion": "text-davinci-003",
+    "chat_completion": "gpt-3.5-turbo",
+}
+
+default_provider = "Koala"
+
+
+class GPT4FREE(Provider):
+    def __init__(
+        self,
+        provider: str = default_provider,
+        is_conversation: bool = True,
+        auth: str = None,
+        max_tokens: int = 600,
+        model: str = None,
+        chat_completion: bool = False,
+        ignore_working: bool = False,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+    ):
+        """Initialies GPT4FREE
+
+        Args:
+            provider (str, optional): gpt4free based provider name. Defaults to Koala.
+            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True.
+            auth (str, optional): Authentication value for the provider incase it needs. Defaults to None.
+            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
+            model (str, optional): LLM model name. Defaults to text-davinci-003|gpt-3.5-turbo.
+            chat_completion(bool, optional): Provide native auto-contexting (conversationally). Defaults to False.
+            ignore_working (bool, optional): Ignore working status of the provider. Defaults to False.
+            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.
+        """
+        assert provider in available_providers, (
+            f"Provider '{provider}' is not yet supported. "
+            f"Try others like {', '.join(available_providers)}"
+        )
+        if model is None:
+            model = (
+                default_models["chat_completion"]
+                if chat_completion
+                else default_models["completion"]
+            )
+
+        elif not chat_completion:
+            assert model in completion_allowed_models, (
+                f"Model '{model}' is not yet supported for completion. "
+                f"Try other models like {', '.join(completion_allowed_models)}"
+            )
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.stream_chunk_size = 64
+        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(
+            False if chat_completion else is_conversation,
+            self.max_tokens_to_sample,
+            filepath,
+            update_file,
+        )
+        self.conversation.history_offset = history_offset
+        self.model = model
+        self.provider = provider
+        self.chat_completion = chat_completion
+        self.ignore_working = ignore_working
+        self.auth = auth
+        self.proxy = None if not proxies else list(proxies.values())[0]
+        self.__chat_class = g4f.ChatCompletion if chat_completion else g4f.Completion
+
+    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}"
+                )
+
+        def payload():
+            if self.chat_completion:
+                return dict(
+                    model=self.model,
+                    provider=self.provider,  # g4f.Provider.Aichat,
+                    messages=[{"role": "user", "content": conversation_prompt}],
+                    stream=stream,
+                    ignore_working=self.ignore_working,
+                    auth=self.auth,
+                    proxy=self.proxy,
+                    timeout=self.timeout,
+                )
+
+            else:
+                return dict(
+                    model=self.model,
+                    prompt=conversation_prompt,
+                    provider=self.provider,
+                    stream=stream,
+                    ignore_working=self.ignore_working,
+                    auth=self.auth,
+                    proxy=self.proxy,
+                    timeout=self.timeout,
+                )
+
+        def format_response(response):
+            return dict(text=response)
+
+        def for_stream():
+            previous_chunks = ""
+            response = self.__chat_class.create(**payload())
+
+            for chunk in response:
+                previous_chunks += chunk
+                formatted_resp = format_response(previous_chunks)
+                self.last_response.update(formatted_resp)
+                yield previous_chunks if raw else formatted_resp
+
+            self.conversation.update_chat_history(
+                prompt,
+                previous_chunks,
+            )
+
+        def for_non_stream():
+            response = self.__chat_class.create(**payload())
+            formatted_resp = format_response(response)
+
+            self.last_response.update(formatted_resp)
+            self.conversation.update_chat_history(prompt, response)
+
+            return response if raw else formatted_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["text"]
+from pathlib import Path
+from webscout.AIutel import default_path
+from json import dump, load
+from time import time
+from threading import Thread as thr
+from functools import wraps
+from rich.progress import Progress
+import logging
+
+results_path = Path(default_path) / "provider_test.json"
+
+
+def exception_handler(func):
+
+    @wraps(func)
+    def decorator(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except Exception as e:
+            pass
+
+    return decorator
+
+
+@exception_handler
+def is_working(provider: str) -> bool:
+    """Test working status of a provider
+
+    Args:
+        provider (str): Provider name
+
+    Returns:
+        bool: is_working status
+    """
+    bot = GPT4FREE(provider=provider, is_conversation=False)
+    text = bot.chat("hello")
+    assert isinstance(text, str)
+    assert bool(text.strip())
+    assert "</" not in text
+    assert ":" not in text
+    assert len(text) > 2
+    return True
+
+
+class TestProviders:
+
+    def __init__(
+        self,
+        test_at_once: int = 5,
+        quiet: bool = False,
+        timeout: int = 20,
+        selenium: bool = False,
+        do_log: bool = True,
+    ):
+        """Constructor
+
+        Args:
+            test_at_once (int, optional): Test n providers at once. Defaults to 5.
+            quiet (bool, optinal): Disable stdout. Defaults to False.
+            timout (int, optional): Thread timeout for each provider. Defaults to 20.
+            selenium (bool, optional): Test even selenium dependent providers. Defaults to False.
+            do_log (bool, optional): Flag to control logging. Defaults to True.
+        """
+        self.test_at_once: int = test_at_once
+        self.quiet = quiet
+        self.timeout = timeout
+        self.do_log = do_log
+        self.__logger = logging.getLogger(__name__)
+        self.working_providers: list = [
+            provider.__name__
+            for provider in g4f.Provider.__providers__
+            if provider.working
+        ]
+
+        if not selenium:
+            import g4f.Provider.selenium as selenium_based
+            from g4f import webdriver
+
+            webdriver.has_requirements = False
+            selenium_based_providers: list = dir(selenium_based)
+            for provider in self.working_providers:
+                try:
+                    selenium_based_providers.index(provider)
+                except ValueError:
+                    pass
+                else:
+                    self.__log(
+                        10, f"Dropping provider - {provider} - [Selenium dependent]"
+                    )
+                    self.working_providers.remove(provider)
+
+        self.results_path: Path = results_path
+        self.__create_empty_file(ignore_if_found=True)
+        self.results_file_is_empty: bool = False
+
+    def __log(
+        self,
+        level: int,
+        message: str,
+    ):
+        """class logger"""
+        if self.do_log:
+            self.__logger.log(level, message)
+        else:
+            pass
+
+    def __create_empty_file(self, ignore_if_found: bool = False):
+        if ignore_if_found and self.results_path.is_file():
+            return
+        with self.results_path.open("w") as fh:
+            dump({"results": []}, fh)
+        self.results_file_is_empty = True
+
+    def test_provider(self, name: str):
+        """Test each provider and save successful ones
+
+        Args:
+            name (str): Provider name
+        """
+
+        try:
+            bot = GPT4FREE(provider=name, is_conversation=False)
+            start_time = time()
+            text = bot.chat("hello there")
+            assert isinstance(text, str), "Non-string response returned"
+            assert bool(text.strip()), "Empty string"
+            assert "</" not in text, "Html code returned."
+            assert ":" not in text, "Json formatted response returned"
+            assert len(text) > 2
+        except Exception as e:
+            pass
+        else:
+            self.results_file_is_empty = False
+            with self.results_path.open() as fh:
+                current_results = load(fh)
+            new_result = dict(time=time() - start_time, name=name)
+            current_results["results"].append(new_result)
+            self.__log(20, f"Test result - {new_result['name']} - {new_result['time']}")
+
+            with self.results_path.open("w") as fh:
+                dump(current_results, fh)
+
+    @exception_handler
+    def main(
+        self,
+    ):
+        self.__create_empty_file()
+        threads = []
+        # Create a progress bar
+        total = len(self.working_providers)
+        with Progress() as progress:
+            self.__log(20, f"Testing {total} providers : {self.working_providers}")
+            task = progress.add_task(
+                f"[cyan]Testing...[{self.test_at_once}]",
+                total=total,
+                visible=self.quiet == False,
+            )
+            while not progress.finished:
+                for count, provider in enumerate(self.working_providers, start=1):
+                    t1 = thr(
+                        target=self.test_provider,
+                        args=(provider,),
+                    )
+                    t1.start()
+                    if count % self.test_at_once == 0 or count == len(provider):
+                        for t in threads:
+                            try:
+                                t.join(self.timeout)
+                            except Exception as e:
+                                pass
+                        threads.clear()
+                    else:
+                        threads.append(t1)
+                    progress.update(task, advance=1)
+
+    def get_results(self, run: bool = False, best: bool = False) -> list[dict]:
+        """Get test results
+
+        Args:
+            run (bool, optional): Run the test first. Defaults to False.
+            best (bool, optional): Return name of the best provider. Defaults to False.
+
+        Returns:
+            list[dict]|str: Test results.
+        """
+        if run or self.results_file_is_empty:
+            self.main()
+
+        with self.results_path.open() as fh:
+            results: dict = load(fh)
+
+        results = results["results"]
+        if not results:
+            if run:
+                raise Exception("Unable to find working g4f provider")
+            else:
+                self.__log(30, "Hunting down working g4f providers.")
+                return self.get_results(run=True, best=best)
+
+        time_list = []
+
+        sorted_list = []
+        for entry in results:
+            time_list.append(entry["time"])
+
+        time_list.sort()
+
+        for time_value in time_list:
+            for entry in results:
+                if entry["time"] == time_value:
+                    sorted_list.append(entry)
+        return sorted_list[0]["name"] if best else sorted_list
+
+    @property
+    def best(self):
+        """Fastest provider overally"""
+        return self.get_results(run=False, best=True)
+
+    @property
+    def auto(self):
+        """Best working provider"""
+        for result in self.get_results(run=False, best=False):
+            self.__log(20, "Confirming working status of provider : " + result["name"])
+            if is_working(result["name"]):
+                return result["name"]

webscout/version.py

@@ -1,2 +1,2 @@
-__version__ = "1.3.0"
+__version__ = "1.3.2"