webscout 7.6__py3-none-any.whl → 7.8__py3-none-any.whl

webscout/Provider/TTI/FreeAIPlayground/sync_freeaiplayground.py

@@ -1,6 +1,6 @@
 import requests
 import os
-from typing import List
+from typing import Union, List
 from string import punctuation
 from random import choice
 from random import randint
@@ -8,10 +8,6 @@ import base64
 
 from webscout.AIbase import ImageProvider
 from webscout.litagent import LitAgent  # Import our fire user agent generator 🔥
-from webscout.Litlogger import Logger  # For that cyberpunk logging swag ⚡
-
-# Initialize our fire logger 🚀
-logger = Logger("FreeAIPlayground")
 
 class FreeAIImager(ImageProvider):
     """
@@ -25,7 +21,8 @@ class FreeAIImager(ImageProvider):
         "Flux Pro Ultra Raw",
         "Flux Schnell",
         "Flux Realism",
-        "grok-2-aurora"
+        "grok-2-aurora",
+        "Flux Dev",
     ]
 
     def __init__(
@@ -33,7 +30,6 @@ class FreeAIImager(ImageProvider):
         model: str = "dall-e-3",  # Updated default model
         timeout: int = 60,
         proxies: dict = {},
-        logging: bool = True
     ):
         """Initialize your FreeAIPlayground provider with custom settings! ⚙️
 
@@ -48,7 +44,7 @@ class FreeAIImager(ImageProvider):
             "Accept": "application/json",
             "Accept-Language": "en-US,en;q=0.9",
             "Content-Type": "application/json",
-            "User-Agent": LitAgent().random(),  # Using our fire random agent! 🔥
+            "User-Agent": LitAgent().random(), 
             "Origin": "https://freeaichatplayground.com",
             "Referer": "https://freeaichatplayground.com/",
         }
@@ -59,14 +55,11 @@ class FreeAIImager(ImageProvider):
         self.model = model
         self.prompt: str = "AI-generated image - webscout"
         self.image_extension: str = "png"
-        self.logging = logging
-        if self.logging:
-            logger.info("FreeAIPlayground initialized! Ready to create some fire art! 🚀")
 
     def generate(
         self, prompt: str, amount: int = 1, additives: bool = True,
         size: str = "1024x1024", quality: str = "standard",
-        style: str = "vivid"
+        style: str = "vivid", max_retries: int = 3, retry_delay: int = 5
     ) -> List[bytes]:
         """Generate some fire images from your prompt! 🎨
 
@@ -77,6 +70,8 @@ class FreeAIImager(ImageProvider):
             size (str): Image size (1024x1024, 1024x1792, 1792x1024)
             quality (str): Image quality (standard, hd)
             style (str): Image style (vivid, natural)
+            max_retries (int): Max retry attempts if generation fails
+            retry_delay (int): Delay between retries in seconds
 
         Returns:
             List[bytes]: Your generated images as bytes
@@ -93,9 +88,6 @@ class FreeAIImager(ImageProvider):
             + choice(punctuation)
         )
 
-        if self.logging:
-            logger.info(f"Generating {amount} images... 🎨")
-
         self.prompt = prompt
         response = []
         for _ in range(amount):
@@ -107,27 +99,33 @@ class FreeAIImager(ImageProvider):
                 "quality": quality,
                 "style": style
             }
-            try:
-                resp = self.session.post(
-                    url=self.image_gen_endpoint,
-                    json=payload,
-                    timeout=self.timeout
-                )
-                resp.raise_for_status()
-                image_url = resp.json()['data'][0]['url']
-                # Get the image data from the URL
-                img_resp = self.session.get(image_url, timeout=self.timeout)
-                img_resp.raise_for_status()
-                response.append(img_resp.content)
-                if self.logging:
-                    logger.success(f"Generated image {len(response)}/{amount}! 🎨")
-            except Exception as e:
-                if self.logging:
-                    logger.error(f"Failed to generate image: {e} 😢")
-                raise
-
-        if self.logging:
-            logger.success("All images generated successfully! 🎉")
+            
+            for attempt in range(max_retries):
+                try:
+                    resp = self.session.post(
+                        url=self.image_gen_endpoint,
+                        json=payload,
+                        timeout=self.timeout
+                    )
+                    resp.raise_for_status()
+                    response_data = resp.json()
+                    if 'data' in response_data and len(response_data['data']) > 0:
+                        image_url = response_data['data'][0]['url']
+                        # Get the image data from the URL
+                        img_resp = self.session.get(image_url, timeout=self.timeout)
+                        img_resp.raise_for_status()
+                        response.append(img_resp.content)
+                        break
+                    else:
+                        print(f"Warning: No image data in response: {response_data}")
+                        if attempt == max_retries - 1:
+                            raise Exception("No image data received after all retries")
+                except Exception as e:
+                    print(f"Error generating image (attempt {attempt + 1}/{max_retries}): {str(e)}")
+                    if attempt == max_retries - 1:
+                        raise
+                    import time
+                    time.sleep(retry_delay)
         return response
 
     def save(
@@ -153,11 +151,6 @@ class FreeAIImager(ImageProvider):
 
         if not os.path.exists(dir):
             os.makedirs(dir)
-            if self.logging:
-                logger.info(f"Created directory: {dir} 📁")
-
-        if self.logging:
-            logger.info(f"Saving {len(response)} images... 💾")
 
         filenames = []
         count = 0
@@ -174,11 +167,6 @@ class FreeAIImager(ImageProvider):
 
             with open(absolute_path_to_file, "wb") as fh:
                 fh.write(image)
-            if self.logging:
-                logger.success(f"Saved image to: {absolute_path_to_file} 💾")
-
-        if self.logging:
-            logger.success(f"All images saved successfully! Check {dir} 🎉")
         return filenames
 
 
@@ -187,6 +175,6 @@ if __name__ == "__main__":
     try:
         resp = bot.generate("A shiny red sports car speeding down a scenic mountain road", 1)
         print(bot.save(resp))
-    except Exception as e:
-        if bot.logging:
-            logger.error(f"An error occurred: {e} 😢")
+    except Exception:
+        pass
+

webscout/Provider/TTI/ImgSys/__init__.py

@@ -0,0 +1,23 @@
+"""ImgSys Provider Package - Generate images from multiple providers! 🎨
+
+Examples:
+    >>> # Synchronous usage
+    >>> from webscout import ImgSys
+    >>> provider = ImgSys()
+    >>> images = provider.generate("A cool cyberpunk city")
+    >>> provider.save(images, dir="my_images")
+    >>> 
+    >>> # Asynchronous usage
+    >>> import asyncio
+    >>> from webscout import AsyncImgSys
+    >>> async def main():
+    ...     provider = AsyncImgSys()
+    ...     images = await provider.generate("A cool cyberpunk city")
+    ...     await provider.save(images, dir="my_images")
+    >>> asyncio.run(main())
+"""
+
+from .sync_imgsys import ImgSys
+from .async_imgsys import AsyncImgSys
+
+__all__ = ["ImgSys", "AsyncImgSys"] 

webscout/Provider/TTI/ImgSys/async_imgsys.py

@@ -0,0 +1,202 @@
+"""ImgSys Asynchronous Provider - Generate images from multiple providers! 🔥
+
+Examples:
+    >>> import asyncio
+    >>> from webscout import AsyncImgSys
+    >>> 
+    >>> async def main():
+    ...     provider = AsyncImgSys()
+    ...     # Generate images
+    ...     images = await provider.generate("A cool cyberpunk city at night")
+    ...     await provider.save(images, dir="my_images")
+    >>> asyncio.run(main())
+"""
+
+import aiohttp
+import os
+import time
+import asyncio
+from typing import List, Optional, Union
+from aiohttp import ClientError
+from pathlib import Path
+
+from webscout.AIbase import ImageProvider
+from webscout.litagent import LitAgent
+
+# Get a fresh user agent! 🔄
+agent = LitAgent()
+
+class AsyncImgSys(ImageProvider):
+    """Your homie for generating fire images using imgsys.org! 🎨
+
+    This provider generates images from multiple providers, with built-in retry logic
+    and error handling to make sure you get your images no cap! 💯
+
+    Examples:
+        >>> import asyncio
+        >>> from webscout import AsyncImgSys
+        >>> async def main():
+        ...     provider = AsyncImgSys()
+        ...     # Generate images
+        ...     images = await provider.generate("A futuristic city")
+        ...     await provider.save(images, "city.jpg")
+        >>> asyncio.run(main())
+    """
+
+    def __init__(
+        self, 
+        timeout: int = 60, 
+        proxies: Optional[dict] = None
+    ):
+        """Initialize your AsyncImgSys provider with custom settings
+
+        Examples:
+            >>> provider = AsyncImgSys(timeout=30)
+            >>> provider = AsyncImgSys(proxies={"http": "http://proxy:8080"})
+
+        Args:
+            timeout (int): HTTP request timeout in seconds (default: 60)
+            proxies (dict, optional): Proxy configuration for requests
+        """
+        self.request_id_endpoint = "https://imgsys.org/api/initiate"
+        self.image_response_endpoint = "https://imgsys.org/api/get"
+        self.image_provider_endpoint = "https://imgsys.org/api/submit"
+        
+        self.headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            "User-Agent": agent.random(),
+        }
+        self.timeout = aiohttp.ClientTimeout(total=timeout)
+        self.proxies = proxies
+        self.prompt: str = "AI-generated image - webscout"
+        self.image_extension: str = "jpeg"
+
+    async def generate(
+        self,
+        prompt: str,
+        max_retries: int = 3,
+        retry_delay: int = 5,
+    ) -> List[bytes]:
+        """Generate some fire images from your prompt! 🎨
+
+        Args:
+            prompt (str): Your image description
+            max_retries (int): Max retry attempts if something fails (default: 3)
+            retry_delay (int): Seconds to wait between retries (default: 5)
+
+        Returns:
+            List[bytes]: Your generated images as bytes
+
+        Raises:
+            ValueError: If the inputs ain't valid
+            ClientError: If the API calls fail after retries
+        """
+        # Input validation
+        if not prompt:
+            raise ValueError("Yo fam, the prompt can't be empty! 🤔")
+
+        self.prompt = prompt
+        response = []
+        
+        async with aiohttp.ClientSession(headers=self.headers, timeout=self.timeout) as session:
+            # Get request ID
+            data = {"prompt": prompt}
+            async with session.post(self.request_id_endpoint, json=data) as resp:
+                resp.raise_for_status()
+                request_id = (await resp.json())["requestId"]
+
+            # Poll for results
+            for attempt in range(max_retries):
+                try:
+                    # Get image URLs
+                    async with session.get(
+                        f"{self.image_response_endpoint}?requestId={request_id}"
+                    ) as resp:
+                        resp.raise_for_status()
+                        image_data = await resp.json()
+
+                    if "results" in image_data and len(image_data["results"]) >= 2:
+                        # Get provider names
+                        async with session.post(
+                            self.image_provider_endpoint,
+                            json={"requestId": request_id, "preference": 0}
+                        ) as resp:
+                            resp.raise_for_status()
+                            provider_data = await resp.json()
+
+                        # Download images
+                        for i, url in enumerate(image_data["results"][:2]):
+                            async with session.get(url) as resp:
+                                resp.raise_for_status()
+                                response.append(await resp.read())
+                        
+                        break
+                    else:
+                        if attempt == max_retries - 1:
+                            raise ClientError("Failed to get image results after max retries")
+                        await asyncio.sleep(retry_delay)
+
+                except ClientError as e:
+                    if attempt == max_retries - 1:
+                        raise
+                    await asyncio.sleep(retry_delay)
+
+        return response
+
+    async def save(
+        self,
+        response: List[bytes],
+        name: Optional[str] = None,
+        dir: Optional[Union[str, Path]] = None,
+        filenames_prefix: str = "",
+    ) -> List[str]:
+        """Save your fire generated images! 💾
+
+        Examples:
+            >>> import asyncio
+            >>> from webscout import AsyncImgSys
+            >>> async def main():
+            ...     provider = AsyncImgSys()
+            ...     images = await provider.generate("Cool art")
+            ...     # Save with default settings
+            ...     paths = await provider.save(images)
+            ...     # Save with custom name and directory
+            ...     paths = await provider.save(
+            ...         images,
+            ...         name="my_art",
+            ...         dir="my_images",
+            ...         filenames_prefix="test_"
+            ...     )
+            >>> asyncio.run(main())
+
+        Args:
+            response (List[bytes]): Your generated images
+            name (Optional[str]): Custom name for your images
+            dir (Optional[Union[str, Path]]): Where to save the images (default: current directory)
+            filenames_prefix (str): Prefix for your image files
+
+        Returns:
+            List[str]: Paths to your saved images
+        """
+        save_dir = dir if dir else os.getcwd()
+        if not os.path.exists(save_dir):
+            os.makedirs(save_dir)
+
+        saved_paths = []
+        timestamp = int(time.time())
+        
+        for i, image_bytes in enumerate(response):
+            if name:
+                filename = f"{filenames_prefix}{name}_{i}.{self.image_extension}"
+            else:
+                filename = f"{filenames_prefix}imgsys_{timestamp}_{i}.{self.image_extension}"
+            
+            filepath = os.path.join(save_dir, filename)
+            
+            async with aiohttp.AsyncFile(filepath, "wb") as f:
+                await f.write(image_bytes)
+            
+            saved_paths.append(filepath)
+
+        return saved_paths 

webscout/Provider/TTI/ImgSys/sync_imgsys.py

@@ -0,0 +1,195 @@
+"""ImgSys Synchronous Provider - Generate images from multiple providers! 🔥
+
+Examples:
+    >>> from webscout import ImgSys
+    >>> provider = ImgSys()
+    >>> 
+    >>> # Generate images
+    >>> images = provider.generate("A cool cyberpunk city at night")
+    >>> provider.save(images, dir="my_images")
+"""
+
+import requests
+import os
+import time
+from typing import List, Optional, Union
+from requests.exceptions import RequestException
+from pathlib import Path
+
+from webscout.AIbase import ImageProvider
+from webscout.litagent import LitAgent
+
+# Get a fresh user agent! 🔄
+agent = LitAgent()
+
+class ImgSys(ImageProvider):
+    """Your homie for generating fire images using imgsys.org! 🎨
+
+    This provider generates images from multiple providers, with built-in retry logic
+    and error handling to make sure you get your images no cap! 💯
+
+    Examples:
+        >>> provider = ImgSys()
+        >>> # Generate images
+        >>> images = provider.generate("A futuristic city")
+        >>> provider.save(images, "city.jpg")
+    """
+
+    def __init__(
+        self, 
+        timeout: int = 60, 
+        proxies: Optional[dict] = None
+    ):
+        """Initialize your ImgSys provider with custom settings
+
+        Examples:
+            >>> provider = ImgSys(timeout=30)
+            >>> provider = ImgSys(proxies={"http": "http://proxy:8080"})
+
+        Args:
+            timeout (int): HTTP request timeout in seconds (default: 60)
+            proxies (dict, optional): Proxy configuration for requests
+        """
+        self.request_id_endpoint = "https://imgsys.org/api/initiate"
+        self.image_response_endpoint = "https://imgsys.org/api/get"
+        self.image_provider_endpoint = "https://imgsys.org/api/submit"
+        
+        self.headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            "User-Agent": agent.random(),
+        }
+        self.session = requests.Session()
+        self.session.headers.update(self.headers)
+        if proxies:
+            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,
+        max_retries: int = 3,
+        retry_delay: int = 5,
+    ) -> List[bytes]:
+        """Generate some fire images from your prompt! 🎨
+
+        Args:
+            prompt (str): Your image description
+            max_retries (int): Max retry attempts if something fails (default: 3)
+            retry_delay (int): Seconds to wait between retries (default: 5)
+
+        Returns:
+            List[bytes]: Your generated images as bytes
+
+        Raises:
+            ValueError: If the inputs ain't valid
+            RequestException: If the API calls fail after retries
+        """
+        # Input validation
+        if not prompt:
+            raise ValueError("Yo fam, the prompt can't be empty! 🤔")
+
+        self.prompt = prompt
+        response = []
+        
+        # Get request ID
+        data = {"prompt": prompt}
+        resp = self.session.post(self.request_id_endpoint, json=data, timeout=self.timeout)
+        resp.raise_for_status()
+        request_id = resp.json()["requestId"]
+
+        # Poll for results
+        for attempt in range(max_retries):
+            try:
+                # Get image URLs
+                resp = self.session.get(
+                    f"{self.image_response_endpoint}?requestId={request_id}",
+                    timeout=self.timeout
+                )
+                resp.raise_for_status()
+                image_data = resp.json()
+
+                if "results" in image_data and len(image_data["results"]) >= 2:
+                    # Get provider names
+                    provider_resp = self.session.post(
+                        self.image_provider_endpoint,
+                        json={"requestId": request_id, "preference": 0},
+                        timeout=self.timeout
+                    )
+                    provider_resp.raise_for_status()
+                    provider_data = provider_resp.json()
+
+                    # Download images
+                    for i, url in enumerate(image_data["results"][:2]):
+                        img_resp = self.session.get(url, timeout=self.timeout)
+                        img_resp.raise_for_status()
+                        response.append(img_resp.content)
+                    
+                    break
+                else:
+                    if attempt == max_retries - 1:
+                        raise RequestException("Failed to get image results after max retries")
+                    time.sleep(retry_delay)
+
+            except RequestException as e:
+                if attempt == max_retries - 1:
+                    raise
+                time.sleep(retry_delay)
+
+        return response
+
+    def save(
+        self,
+        response: List[bytes],
+        name: Optional[str] = None,
+        dir: Optional[Union[str, Path]] = None,
+        filenames_prefix: str = "",
+    ) -> List[str]:
+        """Save your fire generated images! 💾
+
+        Examples:
+            >>> provider = ImgSys()
+            >>> images = provider.generate("Cool art")
+            >>> # Save with default settings
+            >>> paths = provider.save(images)
+            >>> # Save with custom name and directory
+            >>> paths = provider.save(
+            ...     images,
+            ...     name="my_art",
+            ...     dir="my_images",
+            ...     filenames_prefix="test_"
+            ... )
+
+        Args:
+            response (List[bytes]): Your generated images
+            name (Optional[str]): Custom name for your images
+            dir (Optional[Union[str, Path]]): Where to save the images (default: current directory)
+            filenames_prefix (str): Prefix for your image files
+
+        Returns:
+            List[str]: Paths to your saved images
+        """
+        save_dir = dir if dir else os.getcwd()
+        if not os.path.exists(save_dir):
+            os.makedirs(save_dir)
+
+        saved_paths = []
+        timestamp = int(time.time())
+        
+        for i, image_bytes in enumerate(response):
+            if name:
+                filename = f"{filenames_prefix}{name}_{i}.{self.image_extension}"
+            else:
+                filename = f"{filenames_prefix}imgsys_{timestamp}_{i}.{self.image_extension}"
+            
+            filepath = os.path.join(save_dir, filename)
+            
+            with open(filepath, "wb") as f:
+                f.write(image_bytes)
+            
+            saved_paths.append(filepath)
+
+        return saved_paths 

webscout/Provider/TTI/__init__.py

@@ -7,4 +7,6 @@ from .artbit import *
 from .talkai import *
 from .piclumen import *
 from .MagicStudio import *
-from .fastflux import *
+from .fastflux import *
+from .pixelmuse import *
+from .ImgSys import *