webscout 5.1__py3-none-any.whl → 5.2__py3-none-any.whl

webscout/AIauto.py

@@ -1,36 +1,45 @@
 from webscout.AIbase import Provider, AsyncProvider
 from webscout.Provider.ThinkAnyAI import ThinkAnyAI
-from webscout.Provider.Xjai import Xjai
 from webscout.Provider.Llama import LLAMA
-from webscout.Provider.Leo import LEO
-from webscout.Provider.Leo import AsyncLEO
+
 from webscout.Provider.Koboldai import KOBOLDAI
 from webscout.Provider.Koboldai import AsyncKOBOLDAI
-from webscout.Provider.OpenGPT import OPENGPT
-from webscout.Provider.OpenGPT import OPENGPTv2
-from webscout.Provider.OpenGPT import AsyncOPENGPT
-from webscout.Provider.Perplexity import PERPLEXITY
+
+from webscout.Provider.Perplexity import Perplexity
 from webscout.Provider.Blackboxai import BLACKBOXAI
 from webscout.Provider.Blackboxai import AsyncBLACKBOXAI
 from webscout.Provider.Phind import PhindSearch
 from webscout.Provider.Phind import AsyncPhindSearch
 from webscout.Provider.Phind import Phindv2
 from webscout.Provider.Phind import AsyncPhindv2
-from webscout.Provider.Yepchat import YEPCHAT
-from webscout.Provider.Yepchat import AsyncYEPCHAT
+from webscout.Provider.yep import YEPCHAT
 from webscout.Provider.Berlin4h import Berlin4h
-from webscout.Provider.ChatGPTUK import ChatGPTUK
 from webscout.Provider.Poe import POE
 from webscout.Provider.BasedGPT import BasedGPT
 from webscout.Provider.Deepseek import DeepSeek
 from webscout.Provider.Deepinfra import DeepInfra, VLM, AsyncDeepInfra
-from webscout.Provider.VTLchat import VTLchat
-from webscout.Provider.Geminipro import GEMINIPRO
-from webscout.Provider.Geminiflash import GEMINIFLASH
+from webscout.Provider.OLLAMA import OLLAMA
+from webscout.Provider.Andi import AndiSearch
+from webscout.Provider.Llama3 import LLAMA3
+from webscout.Provider.DARKAI import DARKAI
+from webscout.Provider.koala import KOALA
+from webscout.Provider.RUBIKSAI import RUBIKSAI
+from webscout.Provider.meta import Meta
+from webscout.Provider.liaobots import LiaoBots
+from webscout.Provider.DiscordRocks import DiscordRocks
+from webscout.Provider.felo_search import Felo
+from webscout.Provider.xdash import XDASH
+from webscout.Provider.julius import Julius
+from webscout.Provider.Youchat import YouChat
+from webscout.Provider.Cloudflare import Cloudflare
+from webscout.Provider.turboseek import TurboSeek
+from webscout.Provider.NetFly import NetFly
+from webscout.Provider.EDITEE import Editee
+# from webscout.Provider.Chatify import Chatify # TODO: UNFINISHED
+from webscout.Provider.PI import PiAI 
 from webscout.g4f import GPT4FREE, AsyncGPT4FREE
 from webscout.g4f import TestProviders
 from webscout.exceptions import AllProvidersFailure
-from webscout.async_providers import mapper as async_provider_map
 from typing import AsyncGenerator
 
 from typing import Union
@@ -42,53 +51,75 @@ provider_map: dict[
     str,
     Union[
         ThinkAnyAI,
-        Xjai,
         LLAMA,
-        LEO,
         KOBOLDAI,
-        OPENGPT,
-        OPENGPTv2,
-        PERPLEXITY,
+        Perplexity,
         BLACKBOXAI,
         PhindSearch,
         Phindv2,
         YEPCHAT,
         Berlin4h,
-        ChatGPTUK,
         POE,
         BasedGPT,
         DeepSeek,
         DeepInfra,
         VLM,
-        VTLchat,
-        GEMINIPRO,
-        GEMINIFLASH,
         GPT4FREE,
+        OLLAMA,
+        AndiSearch,
+        LLAMA3,
+        DARKAI,
+        KOALA,
+        RUBIKSAI,
+        Meta,
+        LiaoBots,
+        DiscordRocks,
+        Felo,
+        XDASH,
+        Julius,
+        YouChat,
+        Cloudflare,
+        TurboSeek,
+        NetFly,
+        Editee,
+        # Chatify,
+        PiAI,
     ],
 ] = {
     "ThinkAnyAI": ThinkAnyAI,
-    "Xjai": Xjai,
     "LLAMA2": LLAMA,
-    "LEO": LEO,
     "KOBOLDAI": KOBOLDAI,
-    "OPENGPT": OPENGPT,
-    "OPENGPTv2": OPENGPTv2,
-    "PERPLEXITY": PERPLEXITY,
+    "PERPLEXITY": Perplexity,
     "BLACKBOXAI": BLACKBOXAI,
     "PhindSearch": PhindSearch,
     "Phindv2": Phindv2,
     "YEPCHAT": YEPCHAT,
     "Berlin4h": Berlin4h,
-    "ChatGPTUK": ChatGPTUK,
     "POE": POE,
     "BasedGPT": BasedGPT,
     "DeepSeek": DeepSeek,
     "DeepInfra": DeepInfra,
     "VLM": VLM,
-    "VTLchat": VTLchat,
-    "GEMINIPRO": GEMINIPRO,
-    "GEMINIFLASH": GEMINIFLASH,
     "gpt4free": GPT4FREE,
+    "ollama": OLLAMA,
+    "andi": AndiSearch,
+    "llama3": LLAMA3,
+    "darkai": DARKAI,
+    "koala": KOALA,
+    "rubiksai": RUBIKSAI,
+    "meta": Meta,
+    "liaobots": LiaoBots,
+    "discordrocks": DiscordRocks,
+    "felo": Felo,
+    "xdash": XDASH,
+    "julius": Julius,
+    "you": YouChat,
+    "cloudflare": Cloudflare,
+    "turboseek": TurboSeek,
+    "netfly": NetFly,
+    "editee": Editee,
+    # "chatify": Chatify,
+    "pi": PiAI,
 }
 
 
@@ -122,28 +153,39 @@ class AUTO(Provider):
         """
         self.provider: Union[
             ThinkAnyAI,
-            Xjai,
             LLAMA,
-            LEO,
             KOBOLDAI,
-            OPENGPT,
-            OPENGPTv2,
-            PERPLEXITY,
+            Perplexity,
             BLACKBOXAI,
             PhindSearch,
             Phindv2,
             YEPCHAT,
             Berlin4h,
-            ChatGPTUK,
             POE,
             BasedGPT,
             DeepSeek,
             DeepInfra,
             VLM,
-            VTLchat,
-            GEMINIPRO,
-            GEMINIFLASH,
             GPT4FREE,
+            OLLAMA,
+            AndiSearch,
+            LLAMA3,
+            DARKAI,
+            KOALA,
+            RUBIKSAI,
+            Meta,
+            LiaoBots,
+            DiscordRocks,
+            Felo,
+            XDASH,
+            Julius,
+            YouChat,
+            Cloudflare,
+            TurboSeek,
+            NetFly,
+            Editee,
+            # Chatify,
+            PiAI,
         ] = None
         self.provider_name: str = None
         self.is_conversation = is_conversation
@@ -318,239 +360,3 @@ class AUTO(Provider):
         """
         assert self.provider is not None, "Chat with AI first"
         return self.provider.get_message(response)
-
-
-class AsyncAUTO(AsyncProvider):
-    def __init__(
-        self,
-        is_conversation: bool = True,
-        max_tokens: int = 600,
-        timeout: int = 30,
-        intro: str = None,
-        filepath: str = None,
-        update_file: bool = True,
-        proxies: dict = {},
-        history_offset: int = 10250,
-        act: str = None,
-        exclude: list[str] = [],
-    ):
-        """Instantiates AsyncAUTO
-
-        Args:
-            is_conversation (bool, optional): Flag for chatting conversationally. Defaults to True
-            max_tokens (int, optional): Maximum number of tokens to be generated upon completion. Defaults to 600.
-            timeout (int, optional): Http request timeout. Defaults to 30.
-            intro (str, optional): Conversation introductory prompt. Defaults to None.
-            filepath (str, optional): Path to file containing conversation history. Defaults to None.
-            update_file (bool, optional): Add new prompts and responses to the file. Defaults to True.
-            proxies (dict, optional): Http request proxies. Defaults to {}.
-            history_offset (int, optional): Limit conversation history to this number of last texts. Defaults to 10250.
-            act (str|int, optional): Awesome prompt key or index. (Used as intro). Defaults to None.
-            exclude(list[str], optional): List of providers to be excluded. Defaults to [].
-        """
-        self.provider: Union[
-            AsyncOPENGPT,
-            AsyncKOBOLDAI,
-            AsyncPhindSearch,
-            AsyncBLACKBOXAI,
-            AsyncGPT4FREE,
-            AsyncLEO,
-            ThinkAnyAI,
-            Xjai,
-            LLAMA,
-            LEO,
-            KOBOLDAI,
-            OPENGPT,
-            OPENGPTv2,
-            PERPLEXITY,
-            BLACKBOXAI,
-            PhindSearch,
-            Phindv2,
-            YEPCHAT,
-            Berlin4h,
-            ChatGPTUK,
-            POE,
-            BasedGPT,
-            DeepSeek,
-            DeepInfra,
-            VLM,
-            VTLchat,
-            GEMINIPRO,
-            GEMINIFLASH,
-            GPT4FREE
-        ] = None
-        self.provider_name: str = None
-        self.is_conversation = is_conversation
-        self.max_tokens = max_tokens
-        self.timeout = timeout
-        self.intro = intro
-        self.filepath = filepath
-        self.update_file = update_file
-        self.proxies = proxies
-        self.history_offset = history_offset
-        self.act = act
-        self.exclude = exclude
-
-    @property
-    def last_response(self) -> dict[str, Any]:
-        return self.provider.last_response
-
-    @property
-    def conversation(self) -> object:
-        return self.provider.conversation
-
-    async def ask(
-        self,
-        prompt: str,
-        stream: bool = False,
-        raw: bool = False,
-        optimizer: str = None,
-        conversationally: bool = False,
-        run_new_test: bool = False,
-    ) -> dict | AsyncGenerator:
-        """Chat with AI asynchronously.
-
-        Args:
-            prompt (str): Prompt to be send.
-            stream (bool, optional): Flag for streaming response. Defaults to False.
-            raw (bool, optional): Stream back raw response as received. Defaults to False.
-            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
-            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
-            run_new_test (bool, optional): Perform new test on g4f-based providers. Defaults to False.
-        Returns:
-           dict|AsyncGenerator : ai response.
-        """
-        ask_kwargs: dict[str, Union[str, bool]] = {
-            "prompt": prompt,
-            "stream": stream,
-            "raw": raw,
-            "optimizer": optimizer,
-            "conversationally": conversationally,
-        }
-
-        # tgpt-based providers
-        for provider_name, provider_obj in async_provider_map.items():
-            if provider_name in self.exclude:
-                continue
-            try:
-                self.provider_name = f"tgpt-{provider_name}"
-                self.provider = provider_obj(
-                    is_conversation=self.is_conversation,
-                    max_tokens=self.max_tokens,
-                    timeout=self.timeout,
-                    intro=self.intro,
-                    filepath=self.filepath,
-                    update_file=self.update_file,
-                    proxies=self.proxies,
-                    history_offset=self.history_offset,
-                    act=self.act,
-                )
-
-                async def for_stream():
-                    async_ask = await self.provider.ask(**ask_kwargs)
-                    async for chunk in async_ask:
-                        yield chunk
-
-                async def for_non_stream():
-                    return await self.provider.ask(**ask_kwargs)
-
-                return for_stream() if stream else await for_non_stream()
-
-            except Exception as e:
-                logging.debug(
-                    f"Failed to generate response using provider {provider_name} - {e}"
-                )
-
-        # g4f-based providers
-
-        for provider_info in TestProviders(timeout=self.timeout).get_results(
-            run=run_new_test
-        ):
-            if provider_info["name"] in self.exclude:
-                continue
-            try:
-                self.provider_name = f"g4f-{provider_info['name']}"
-                self.provider = AsyncGPT4FREE(
-                    provider=provider_info["name"],
-                    is_conversation=self.is_conversation,
-                    max_tokens=self.max_tokens,
-                    intro=self.intro,
-                    filepath=self.filepath,
-                    update_file=self.update_file,
-                    proxies=self.proxies,
-                    history_offset=self.history_offset,
-                    act=self.act,
-                )
-
-                async def for_stream():
-                    async_ask = await self.provider.ask(**ask_kwargs)
-                    async for chunk in async_ask:
-                        yield chunk
-
-                async def for_non_stream():
-                    return await self.provider.ask(**ask_kwargs)
-
-                return for_stream() if stream else await for_non_stream()
-
-            except Exception as e:
-                logging.debug(
-                    f"Failed to generate response using GPT4FREE-base provider {provider_name} - {e}"
-                )
-
-        raise AllProvidersFailure(
-            "None of the providers generated response successfully."
-        )
-
-    async def chat(
-        self,
-        prompt: str,
-        stream: bool = False,
-        optimizer: str = None,
-        conversationally: bool = False,
-        run_new_test: bool = False,
-    ) -> str | AsyncGenerator:
-        """Generate response `str` asynchronously.
-        Args:
-            prompt (str): Prompt to be send.
-            stream (bool, optional): Flag for streaming response. Defaults to False.
-            optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
-            conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
-            run_new_test (bool, optional): Perform new test on g4f-based providers. Defaults to False.
-        Returns:
-            str|AsyncGenerator: Response generated
-        """
-
-        async def for_stream():
-            async_ask = await self.ask(
-                prompt,
-                True,
-                optimizer=optimizer,
-                conversationally=conversationally,
-                run_new_test=run_new_test,
-            )
-            async for response in async_ask:
-                yield await self.get_message(response)
-
-        async def for_non_stream():
-            ask_response = await self.ask(
-                prompt,
-                False,
-                optimizer=optimizer,
-                conversationally=conversationally,
-                run_new_test=run_new_test,
-            )
-            return await self.get_message(ask_response)
-
-        return for_stream() if stream else await for_non_stream()
-
-    async def get_message(self, response: dict) -> str:
-        """Retrieves message only from response
-
-        Args:
-            response (dict): Response generated by `self.ask`
-
-        Returns:
-            str: Message extracted
-        """
-        assert self.provider is not None, "Chat with AI first"
-        return await self.provider.get_message(response)

webscout/AIbase.py

@@ -1,9 +1,9 @@
 from abc import ABC
 from abc import abstractmethod
-
+from typing import AsyncGenerator, List, Union, Generator
 
 class Provider(ABC):
-    """Base class for providers"""
+    """Base class for text-based AI providers"""
 
     @abstractmethod
     def ask(
@@ -69,9 +69,8 @@ class Provider(ABC):
         """
         raise NotImplementedError("Method needs to be implemented in subclass")
 
-
 class AsyncProvider(ABC):
-    """Asynchronous base class for providers"""
+    """Asynchronous base class for text-based AI providers"""
 
     @abstractmethod
     async def ask(
@@ -135,4 +134,107 @@ class AsyncProvider(ABC):
         Returns:
             str: Message extracted
         """
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+class TTSProvider(ABC):
+    """Base class for text-to-speech providers"""
+
+    @abstractmethod
+    def tts(self, text: str) -> Union[bytes, str, Generator[bytes, None, None]]:
+        """
+        Converts text to speech.
+
+        Args:
+            text (str): The text to be converted to speech.
+
+        Returns:
+            Union[bytes, str, Generator[bytes, None, None]]: 
+                - The raw audio bytes if the provider supports returning audio directly.
+                - The filename of the saved audio file if the provider saves the audio to a file.
+                - A generator yielding chunks of audio bytes if the provider supports streaming audio.
+        """
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+class AsyncTTSProvider(ABC):
+    """Asynchronous base class for text-to-speech providers"""
+
+    @abstractmethod
+    async def tts(self, text: str) -> Union[bytes, str, AsyncGenerator[bytes, None]]:
+        """
+        Asynchronously converts text to speech.
+
+        Args:
+            text (str): The text to be converted to speech.
+
+        Returns:
+            Union[bytes, str, AsyncGenerator[bytes, None]]: 
+                - The raw audio bytes if the provider supports returning audio directly.
+                - The filename of the saved audio file if the provider saves the audio to a file.
+                - An asynchronous generator yielding chunks of audio bytes if the provider supports streaming audio.
+        """
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+class ImageProvider(ABC):
+    """Base class for text-to-image providers"""
+
+    @abstractmethod
+    def generate(self, prompt: str, amount: int = 1) -> List[bytes]:
+        """Generates images from a text prompt.
+
+        Args:
+            prompt (str): The text prompt describing the desired image.
+            amount (int, optional): The number of images to generate. Defaults to 1.
+
+        Returns:
+            List[bytes]: A list of generated images in bytes format.
+        """
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    def save(self, response: List[bytes], name: str = None, dir: str = None) -> List[str]:
+        """Saves the generated images to files.
+
+        Args:
+            response (List[bytes]): The list of generated images in bytes format.
+            name (str, optional): The base filename for the images. Defaults to None.
+            dir (str, optional): The directory to save the images. Defaults to None.
+
+        Returns:
+            List[str]: A list of the saved filenames.
+        """
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+class AsyncImageProvider(ABC):
+    """Base class for asynchronous text-to-image providers"""
+
+    @abstractmethod
+    async def generate(self, prompt: str, amount: int = 1) -> Union[AsyncGenerator[bytes, None], List[bytes]]:
+        """Asynchronously generates images from a text prompt.
+
+        Args:
+            prompt (str): The text prompt describing the desired image.
+            amount (int, optional): The number of images to generate. Defaults to 1.
+
+        Returns:
+            Union[AsyncGenerator[bytes, None], List[bytes]]: 
+                - An asynchronous generator yielding image bytes.
+                - A list of image bytes if not streaming.
+        """
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    async def save(self, response: Union[AsyncGenerator[bytes, None], List[bytes]], 
+                   name: str = None, dir: str = None) -> List[str]:
+        """Asynchronously saves the generated images to files.
+
+        Args:
+            response (Union[AsyncGenerator[bytes, None], List[bytes]]): 
+                - The asynchronous generator yielding images in bytes format (if streaming).
+                - The list of generated images in bytes format (if not streaming).
+            name (str, optional): The base filename for the images. Defaults to None.
+            dir (str, optional): The directory to save the images. Defaults to None.
+
+        Returns:
+            List[str]: A list of the saved filenames.
+        """
         raise NotImplementedError("Method needs to be implemented in subclass")

webscout/AIutel.py

@@ -173,6 +173,23 @@ class Optimizers:
         )
 
 
+class Proxy:
+    def __init__(self, http_proxy=None, https_proxy=None):
+        self.set_proxies(http_proxy, https_proxy)
+
+    def set_proxies(self, http_proxy=None, https_proxy=None):
+        self.proxies = {
+            "http": http_proxy,
+            "https": https_proxy
+        }
+
+    def post(self, url, headers=None, **kwargs):
+        return requests.post(url, headers=headers, proxies=self.proxies, **kwargs)
+
+    def get(self, url, headers=None, **kwargs):
+        return requests.get(url, headers=headers, proxies=self.proxies, **kwargs)
+
+
 class Conversation:
     """Handles prompt generation based on history"""
 
@@ -287,6 +304,20 @@ class Conversation:
                 with open(self.file, "a", encoding="utf-8") as fh:  # Specify UTF-8 encoding
                     fh.write(new_history)
             self.chat_history += new_history
+        else:
+            self.chat_history += new_history
+
+    def add_message(self, role: str, content: str) -> None:
+        """Appends a new message to the conversation history."""
+        if role == "user":
+            self.chat_history += f"\nUser : {content}"
+        elif role == "llm":
+            self.chat_history += f"\nLLM : {content}"
+        elif role == "tool":
+            self.chat_history += f"\nTool : {content}"
+        else:
+            logging.warning(f"Unknown role '{role}' for message: {content}")
+