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

webscout/Provider/TTI/PollinationsAI.py

@@ -0,0 +1,138 @@
+import requests
+import os
+import time
+from typing import List
+from string import punctuation
+from random import choice
+from requests.exceptions import RequestException
+
+from webscout.AIbase import ImageProvider
+
+class PollinationsAI(ImageProvider):
+    """Image provider for pollinations.ai"""
+
+    def __init__(self, timeout: int = 60, proxies: dict = {}):
+        """Initializes the PollinationsAI class.
+
+        Args:
+            timeout (int, optional): HTTP request timeout in seconds. Defaults to 60.
+            proxies (dict, optional): HTTP request proxies (socks). Defaults to {}.
+        """
+        self.image_gen_endpoint = "https://image.pollinations.ai/prompt/{prompt}?width={width}&height={height}&model={model}"
+        self.headers = {
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
+            "Accept-Language": "en-US,en;q=0.5",
+            "Accept-Encoding": "gzip, deflate",
+            "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:122.0) Gecko/20100101 Firefox/122.0",
+        }
+        self.session = requests.Session()
+        self.session.headers.update(self.headers)
+        self.session.proxies.update(proxies)
+        self.timeout = timeout
+        self.prompt: str = "AI-generated image - webscout"
+        self.image_extension: str = "jpeg"
+
+    def generate(
+        self, prompt: str, amount: int = 1, additives: bool = True,
+        width: int = 768, height: int = 768, model: str = "flux",
+        max_retries: int = 3, retry_delay: int = 5
+    ) -> List[bytes]:
+        """Generate image from prompt
+
+        Args:
+            prompt (str): Image description.
+            amount (int): Total images to be generated. Defaults to 1.
+            additives (bool, optional): Try to make each prompt unique. Defaults to True.
+            width (int, optional): Width of the generated image. Defaults to 768.
+            height (int, optional): Height of the generated image. Defaults to 768.
+            model (str, optional): The model to use for image generation. Defaults to "flux".
+            max_retries (int, optional): Maximum number of retry attempts. Defaults to 3.
+            retry_delay (int, optional): Delay between retries in seconds. Defaults to 5.
+
+        Returns:
+            List[bytes]: List of generated images as bytes.
+        """
+        assert bool(prompt), "Prompt cannot be null"
+        assert isinstance(amount, int), f"Amount should be an integer only not {type(amount)}"
+        assert amount > 0, "Amount should be greater than 0"
+
+        ads = lambda: (
+            ""
+            if not additives
+            else choice(punctuation)
+            + choice(punctuation)
+            + choice(punctuation)
+            + choice(punctuation)
+            + choice(punctuation)
+        )
+
+        self.prompt = prompt
+        response = []
+        for _ in range(amount):
+            url = self.image_gen_endpoint.format(
+                prompt=prompt + ads(), width=width, height=height, model=model
+            )
+            
+            for attempt in range(max_retries):
+                try:
+                    resp = self.session.get(url, timeout=self.timeout)
+                    resp.raise_for_status()
+                    response.append(resp.content)
+                    break
+                except RequestException as e:
+                    if attempt == max_retries - 1:
+                        print(f"Failed to generate image after {max_retries} attempts: {e}")
+                        raise
+                    else:
+                        print(f"Attempt {attempt + 1} failed. Retrying in {retry_delay} seconds...")
+                        time.sleep(retry_delay)
+
+        return response
+
+    def save(
+        self,
+        response: List[bytes],
+        name: str = None,
+        dir: str = os.getcwd(),
+        filenames_prefix: str = "",
+    ) -> List[str]:
+        """Save generated images
+
+        Args:
+            response (List[bytes]): List of generated images as bytes.
+            name (str): Filename for the images. Defaults to the last prompt.
+            dir (str, optional): Directory for saving images. Defaults to os.getcwd().
+            filenames_prefix (str, optional): String to be prefixed at each filename to be returned.
+
+        Returns:
+            List[str]: List of saved filenames.
+        """
+        assert isinstance(response, list), f"Response should be of {list} not {type(response)}"
+        name = self.prompt if name is None else name
+
+        filenames = []
+        count = 0
+        for image in response:
+            def complete_path():
+                count_value = "" if count == 0 else f"_{count}"
+                return os.path.join(dir, name + count_value + "." + self.image_extension)
+
+            while os.path.isfile(complete_path()):
+                count += 1
+
+            absolute_path_to_file = complete_path()
+            filenames.append(filenames_prefix + os.path.split(absolute_path_to_file)[1])
+
+            with open(absolute_path_to_file, "wb") as fh:
+                fh.write(image)
+
+        return filenames
+
+
+if __name__ == "__main__":
+    bot = PollinationsAI()
+    try:
+        resp = bot.generate("AI-generated image - webscout", 1)
+        print(bot.save(resp))
+    except Exception as e:
+        print(f"An error occurred: {e}")

webscout/Provider/TTI/__init__.py

@@ -0,0 +1,2 @@
+from .deepinfra import *
+from .PollinationsAI import *

webscout/Provider/TTI/deepinfra.py

@@ -0,0 +1,148 @@
+import requests
+import os
+from typing import List
+from string import punctuation
+from random import choice
+from random import randint
+import base64
+
+from webscout.AIbase import ImageProvider
+
+class DeepInfraImager(ImageProvider):
+    """DeepInfra Image provider"""
+
+    def __init__(
+        self,
+        model: str = "black-forest-labs/FLUX-1-dev",
+        timeout: int = 60,
+        proxies: dict = {},
+    ):
+        """Initializes `DeepInfraImager`
+
+        Args:
+            model (str, optional): The name of the DeepInfra model to use. 
+                                        Defaults to "black-forest-labs/FLUX-1-dev".
+            timeout (int, optional): Http request timeout. Defaults to 60 seconds.
+            proxies (dict, optional): Http request proxies (socks). Defaults to {}.
+        """
+        self.image_gen_endpoint: str = f"https://api.deepinfra.com/v1/inference/{model}"
+        self.headers = {
+            "Accept": "application/json, text/plain, */*",
+            "Accept-Language": "en-US,en;q=0.9,en-IN;q=0.8",
+            "Accept-Encoding": "gzip, deflate, br, zstd",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 Edg/128.0.0.0",
+            "DNT": "1",
+            "Origin": "https://deepinfra.com",
+            "Referer": "https://deepinfra.com/",
+            "Sec-CH-UA": '"Chromium";v="128", "Not;A=Brand";v="24", "Microsoft Edge";v="128"',
+            "Sec-CH-UA-Mobile": "?0",
+            "Sec-CH-UA-Platform": '"Windows"',
+            "Sec-Fetch-Dest": "empty",
+            "Sec-Fetch-Mode": "cors",
+            "Sec-Fetch-Site": "same-site"
+        }
+        self.session = requests.Session()
+        self.session.headers.update(self.headers)
+        self.session.proxies.update(proxies)
+        self.timeout = timeout
+        self.prompt: str = "AI-generated image - webscout"
+        self.image_extension: str = "png"
+
+    def generate(
+        self, prompt: str, amount: int = 1, additives: bool = True, 
+        num_inference_steps: int = 25, guidance_scale: float = 7.5, 
+        width: int = 1024, height: int = 1024, seed: int = None
+    ) -> list[bytes]:
+        """Generate image from prompt
+
+        Args:
+            prompt (str): Image description.
+            amount (int): Total images to be generated. Defaults to 1.
+            additives (bool, optional): Try to make each prompt unique. Defaults to True.
+            num_inference_steps (int, optional): Number of inference steps. Defaults to 39.
+            guidance_scale (float, optional): Guidance scale for image generation. Defaults to 13.3.
+            width (int, optional): Width of the generated image. Defaults to 1024.
+            height (int, optional): Height of the generated image. Defaults to 1024.
+            seed (int, optional): Random seed for image generation. If None, a random seed is used. 
+                                  Defaults to None.
+
+        Returns:
+            list[bytes]: List of generated images as bytes.
+        """
+        assert bool(prompt), "Prompt cannot be null"
+        assert isinstance(amount, int), f"Amount should be an integer only not {type(amount)}"
+        assert amount > 0, "Amount should be greater than 0"
+
+        ads = lambda: (
+            ""
+            if not additives
+            else choice(punctuation)
+            + choice(punctuation)
+            + choice(punctuation)
+            + choice(punctuation)
+            + choice(punctuation)
+        )
+
+        self.prompt = prompt
+        response = []
+        for _ in range(amount):
+            payload = {
+                "prompt": prompt + ads(),
+                "num_inference_steps": num_inference_steps,
+                "guidance_scale": guidance_scale,
+                "width": width,
+                "height": height,
+                "seed": seed if seed is not None else randint(1, 10000), 
+            }
+            resp = self.session.post(url=self.image_gen_endpoint, json=payload, timeout=self.timeout)
+            resp.raise_for_status()
+            # Extract base64 encoded image data and decode it
+            image_data = resp.json()['images'][0].split(",")[1]
+            image_bytes = base64.b64decode(image_data)
+            response.append(image_bytes)
+
+        return response
+
+    def save(
+        self,
+        response: list[bytes],
+        name: str = None,
+        dir: str = os.getcwd(),
+        filenames_prefix: str = "",
+    ) -> list[str]:
+        """Save generated images
+
+        Args:
+            response (list[bytes]): List of generated images as bytes.
+            name (str):  Filename for the images. Defaults to last prompt.
+            dir (str, optional): Directory for saving images. Defaults to os.getcwd().
+            filenames_prefix (str, optional): String to be prefixed at each filename to be returned.
+        """
+        assert isinstance(response, list), f"Response should be of {list} not {type(response)}"
+        name = self.prompt if name is None else name
+
+        filenames: list = []
+        count = 0
+        for image in response:
+            def complete_path():
+                count_value = "" if count == 0 else f"_{count}"
+                return os.path.join(
+                    dir, name + count_value + "." + self.image_extension
+                )
+
+            while os.path.isfile(complete_path()):
+                count += 1
+
+            absolute_path_to_file = complete_path()
+            filenames.append(filenames_prefix + os.path.split(absolute_path_to_file)[1])
+
+            with open(absolute_path_to_file, "wb") as fh:
+                fh.write(image)
+
+        return filenames
+
+
+if __name__ == "__main__":
+    bot = DeepInfraImager()
+    resp = bot.generate("AI-generated image - webscout", 1)
+    print(bot.save(resp))

webscout/Provider/TTS/__init__.py

@@ -0,0 +1,2 @@
+from .streamElements import *
+from .voicepod import *

webscout/Provider/TTS/streamElements.py

@@ -0,0 +1,292 @@
+import time
+import pygame
+import requests
+import pathlib
+import urllib.parse
+from typing import Union, Generator
+from playsound import playsound
+from webscout import exceptions
+from webscout.AIbase import TTSProvider
+
+class StreamElements(TTSProvider): 
+    """
+    Text-to-speech provider using the StreamElements API.
+    """
+
+    # Request headers
+    headers: dict[str, str] = {
+        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36"
+    }
+    cache_dir = pathlib.Path("./audio_cache")
+    all_voices: list[str] = [
+        "Filiz",
+        "Astrid",
+        "Tatyana",
+        "Maxim",
+        "Carmen",
+        "Ines",
+        "Cristiano",
+        "Vitoria",
+        "Ricardo",
+        "Maja",
+        "Jan",
+        "Jacek",
+        "Ewa",
+        "Ruben",
+        "Lotte",
+        "Liv",
+        "Seoyeon",
+        "Takumi",
+        "Mizuki",
+        "Giorgio",
+        "Carla",
+        "Bianca",
+        "Karl",
+        "Dora",
+        "Mathieu",
+        "Celine",
+        "Chantal",
+        "Penelope",
+        "Miguel",
+        "Mia",
+        "Enrique",
+        "Conchita",
+        "Geraint",
+        "Salli",
+        "Matthew",
+        "Kimberly",
+        "Kendra",
+        "Justin",
+        "Joey",
+        "Joanna",
+        "Ivy",
+        "Raveena",
+        "Aditi",
+        "Emma",
+        "Brian",
+        "Amy",
+        "Russell",
+        "Nicole",
+        "Vicki",
+        "Marlene",
+        "Hans",
+        "Naja",
+        "Mads",
+        "Gwyneth",
+        "Zhiyu",
+        "es-ES-Standard-A",
+        "it-IT-Standard-A",
+        "it-IT-Wavenet-A",
+        "ja-JP-Standard-A",
+        "ja-JP-Wavenet-A",
+        "ko-KR-Standard-A",
+        "ko-KR-Wavenet-A",
+        "pt-BR-Standard-A",
+        "tr-TR-Standard-A",
+        "sv-SE-Standard-A",
+        "nl-NL-Standard-A",
+        "nl-NL-Wavenet-A",
+        "en-US-Wavenet-A",
+        "en-US-Wavenet-B",
+        "en-US-Wavenet-C",
+        "en-US-Wavenet-D",
+        "en-US-Wavenet-E",
+        "en-US-Wavenet-F",
+        "en-GB-Standard-A",
+        "en-GB-Standard-B",
+        "en-GB-Standard-C",
+        "en-GB-Standard-D",
+        "en-GB-Wavenet-A",
+        "en-GB-Wavenet-B",
+        "en-GB-Wavenet-C",
+        "en-GB-Wavenet-D",
+        "en-US-Standard-B",
+        "en-US-Standard-C",
+        "en-US-Standard-D",
+        "en-US-Standard-E",
+        "de-DE-Standard-A",
+        "de-DE-Standard-B",
+        "de-DE-Wavenet-A",
+        "de-DE-Wavenet-B",
+        "de-DE-Wavenet-C",
+        "de-DE-Wavenet-D",
+        "en-AU-Standard-A",
+        "en-AU-Standard-B",
+        "en-AU-Wavenet-A",
+        "en-AU-Wavenet-B",
+        "en-AU-Wavenet-C",
+        "en-AU-Wavenet-D",
+        "en-AU-Standard-C",
+        "en-AU-Standard-D",
+        "fr-CA-Standard-A",
+        "fr-CA-Standard-B",
+        "fr-CA-Standard-C",
+        "fr-CA-Standard-D",
+        "fr-FR-Standard-C",
+        "fr-FR-Standard-D",
+        "fr-FR-Wavenet-A",
+        "fr-FR-Wavenet-B",
+        "fr-FR-Wavenet-C",
+        "fr-FR-Wavenet-D",
+        "da-DK-Wavenet-A",
+        "pl-PL-Wavenet-A",
+        "pl-PL-Wavenet-B",
+        "pl-PL-Wavenet-C",
+        "pl-PL-Wavenet-D",
+        "pt-PT-Wavenet-A",
+        "pt-PT-Wavenet-B",
+        "pt-PT-Wavenet-C",
+        "pt-PT-Wavenet-D",
+        "ru-RU-Wavenet-A",
+        "ru-RU-Wavenet-B",
+        "ru-RU-Wavenet-C",
+        "ru-RU-Wavenet-D",
+        "sk-SK-Wavenet-A",
+        "tr-TR-Wavenet-A",
+        "tr-TR-Wavenet-B",
+        "tr-TR-Wavenet-C",
+        "tr-TR-Wavenet-D",
+        "tr-TR-Wavenet-E",
+        "uk-UA-Wavenet-A",
+        "ar-XA-Wavenet-A",
+        "ar-XA-Wavenet-B",
+        "ar-XA-Wavenet-C",
+        "cs-CZ-Wavenet-A",
+        "nl-NL-Wavenet-B",
+        "nl-NL-Wavenet-C",
+        "nl-NL-Wavenet-D",
+        "nl-NL-Wavenet-E",
+        "en-IN-Wavenet-A",
+        "en-IN-Wavenet-B",
+        "en-IN-Wavenet-C",
+        "fil-PH-Wavenet-A",
+        "fi-FI-Wavenet-A",
+        "el-GR-Wavenet-A",
+        "hi-IN-Wavenet-A",
+        "hi-IN-Wavenet-B",
+        "hi-IN-Wavenet-C",
+        "hu-HU-Wavenet-A",
+        "id-ID-Wavenet-A",
+        "id-ID-Wavenet-B",
+        "id-ID-Wavenet-C",
+        "it-IT-Wavenet-B",
+        "it-IT-Wavenet-C",
+        "it-IT-Wavenet-D",
+        "ja-JP-Wavenet-B",
+        "ja-JP-Wavenet-C",
+        "ja-JP-Wavenet-D",
+        "cmn-CN-Wavenet-A",
+        "cmn-CN-Wavenet-B",
+        "cmn-CN-Wavenet-C",
+        "cmn-CN-Wavenet-D",
+        "nb-no-Wavenet-E",
+        "nb-no-Wavenet-A",
+        "nb-no-Wavenet-B",
+        "nb-no-Wavenet-C",
+        "nb-no-Wavenet-D",
+        "vi-VN-Wavenet-A",
+        "vi-VN-Wavenet-B",
+        "vi-VN-Wavenet-C",
+        "vi-VN-Wavenet-D",
+        "sr-rs-Standard-A",
+        "lv-lv-Standard-A",
+        "is-is-Standard-A",
+        "bg-bg-Standard-A",
+        "af-ZA-Standard-A",
+        "Tracy",
+        "Danny",
+        "Huihui",
+        "Yaoyao",
+        "Kangkang",
+        "HanHan",
+        "Zhiwei",
+        "Asaf",
+        "An",
+        "Stefanos",
+        "Filip",
+        "Ivan",
+        "Heidi",
+        "Herena",
+        "Kalpana",
+        "Hemant",
+        "Matej",
+        "Andika",
+        "Rizwan",
+        "Lado",
+        "Valluvar",
+        "Linda",
+        "Heather",
+        "Sean",
+        "Michael",
+        "Karsten",
+        "Guillaume",
+        "Pattara",
+        "Jakub",
+        "Szabolcs",
+        "Hoda",
+        "Naayf",
+    ]
+
+    def __init__(self, timeout: int = 20, proxies: dict = None):
+        """Initializes the StreamElements TTS client."""
+        self.session = requests.Session()
+        self.session.headers.update(self.headers)
+        if proxies:
+            self.session.proxies.update(proxies)
+        self.timeout = timeout
+
+    def tts(self, text: str, voice: str = "Brian") -> str:
+        """
+        Converts text to speech using the StreamElements API and saves it to a file.
+        """
+        assert (
+            voice in self.all_voices
+        ), f"Voice '{voice}' not one of [{', '.join(self.all_voices)}]"
+
+        url = f"https://api.streamelements.com/kappa/v2/speech?voice={voice}&text={{{urllib.parse.quote(text)}}}"
+        filename = self.cache_dir / f"{int(time.time())}.mp3"  
+
+        try:
+            response = self.session.get(url=url, headers=self.headers, stream=True, timeout=self.timeout)
+            response.raise_for_status()
+
+            # Create the audio_cache directory if it doesn't exist
+            self.cache_dir.mkdir(parents=True, exist_ok=True) 
+
+            with open(filename, "wb") as f:
+                for chunk in response.iter_content(chunk_size=512):
+                    if chunk:
+                        f.write(chunk)
+
+            return filename.as_posix()
+
+        except requests.exceptions.RequestException as e:
+            raise exceptions.FailedToGenerateResponseError(
+                f"Failed to perform the operation: {e}"
+            )
+
+    def play_audio(self, filename: str):
+        """
+        Plays an audio file using playsound.
+
+        Args:
+            filename (str): The path to the audio file.
+
+        Raises:
+            RuntimeError: If there is an error playing the audio.
+        """
+        try:
+            playsound(filename)
+        except Exception as e:
+            raise RuntimeError(f"Error playing audio: {e}")
+
+# Example usage
+if __name__ == "__main__":
+    streamelements = StreamElements()
+    text = "This is a test of the StreamElements text-to-speech API."
+
+    print("Generating audio...")
+    audio_file = streamelements.tts(text, voice="Brian") 
+
+    print("Playing audio...")
+    streamelements.play_audio(audio_file)