webscout 8.3.2__py3-none-any.whl → 8.3.3__py3-none-any.whl

webscout/Provider/TTI/aiarta.py

@@ -24,6 +24,8 @@ import tempfile
 from webscout.litagent import LitAgent
 import time
 import json
+import random
+from pathlib import Path
 
 try:
     from PIL import Image
@@ -31,6 +33,10 @@ except ImportError:
     Image = None
 
 
+class ModelNotFoundError(Exception):
+    pass
+
+
 class Images(BaseImages):
     def __init__(self, client: "AIArta"):
         self._client = client
@@ -140,22 +146,23 @@ class Images(BaseImages):
             gen_headers = {
                 "Authorization": auth_data.get("idToken"),
             }
-            # Remove content-type header for form data
             if "content-type" in self._client.session.headers:
                 del self._client.session.headers["content-type"]
-            # get_model now returns the proper style name from model_aliases
-            style_value = self._client.get_model(model)
+            # Use the model name directly, not as 'style'
             image_payload = {
                 "prompt": str(prompt),
                 "negative_prompt": str(
                     kwargs.get("negative_prompt", "blurry, deformed hands, ugly")
                 ),
-                "style": str(style_value),
-                "images_num": str(1),  # Generate one image at a time in the loop
+                "style": str(model),  # Use 'style' key for the model name
+                "images_num": str(1),
                 "cfg_scale": str(kwargs.get("guidance_scale", 7)),
                 "steps": str(kwargs.get("num_inference_steps", 30)),
                 "aspect_ratio": str(aspect_ratio),
             }
+            # Remove 'model' from payload if present
+            if "model" in image_payload:
+                del image_payload["model"]
             # Step 2: Generate Image (send as form data, not JSON)
             image_response = self._client.session.post(
                 self._client.image_generation_url,
@@ -241,68 +248,67 @@ class Images(BaseImages):
 
 
 class AIArta(TTICompatibleProvider):
-    # Model aliases mapping from lowercase keys to proper API style names
-    model_aliases = {
-        "flux": "Flux",
-        "medieval": "Medieval",
-        "vincent_van_gogh": "Vincent Van Gogh",
-        "f_dev": "F Dev",
-        "low_poly": "Low Poly",
-        "dreamshaper_xl": "Dreamshaper-xl",
-        "anima_pencil_xl": "Anima-pencil-xl",
-        "biomech": "Biomech",
-        "trash_polka": "Trash Polka",
-        "no_style": "No Style",
-        "cheyenne_xl": "Cheyenne-xl",
-        "chicano": "Chicano",
-        "embroidery_tattoo": "Embroidery tattoo",
-        "red_and_black": "Red and Black",
-        "fantasy_art": "Fantasy Art",
-        "watercolor": "Watercolor",
-        "dotwork": "Dotwork",
-        "old_school_colored": "Old school colored",
-        "realistic_tattoo": "Realistic tattoo",
-        "japanese_2": "Japanese_2",
-        "realistic_stock_xl": "Realistic-stock-xl",
-        "f_pro": "F Pro",
-        "revanimated": "RevAnimated",
-        "katayama_mix_xl": "Katayama-mix-xl",
-        "sdxl_l": "SDXL L",
-        "cor_epica_xl": "Cor-epica-xl",
-        "anime_tattoo": "Anime tattoo",
-        "new_school": "New School",
-        "death_metal": "Death metal",
-        "old_school": "Old School",
-        "juggernaut_xl": "Juggernaut-xl",
-        "photographic": "Photographic",
-        "sdxl_1_0": "SDXL 1.0",
-        "graffiti": "Graffiti",
-        "mini_tattoo": "Mini tattoo",
-        "surrealism": "Surrealism",
-        "neo_traditional": "Neo-traditional",
-        "on_limbs_black": "On limbs black",
-        "yamers_realistic_xl": "Yamers-realistic-xl",
-        "pony_xl": "Pony-xl",
-        "playground_xl": "Playground-xl",
-        "anything_xl": "Anything-xl",
-        "flame_design": "Flame design",
-        "kawaii": "Kawaii",
-        "cinematic_art": "Cinematic Art",
-        "professional": "Professional",
-        "black_ink": "Black Ink",
-    }
-
-    AVAILABLE_MODELS = list(model_aliases.keys())
-    default_model = "Flux"
-    default_image_model = default_model
+    url = "https://ai-arta.com"
+    auth_url = "https://www.googleapis.com/identitytoolkit/v3/relyingparty/signupNewUser?key=AIzaSyB3-71wG0fIt0shj0ee4fvx1shcjJHGrrQ"
+    token_refresh_url = "https://securetoken.googleapis.com/v1/token?key=AIzaSyB3-71wG0fIt0shj0ee4fvx1shcjJHGrrQ"
+    image_generation_url = "https://img-gen-prod.ai-arta.com/api/v1/text2image"
+    status_check_url = "https://img-gen-prod.ai-arta.com/api/v1/text2image/{record_id}/status"
+    AVAILABLE_MODELS = [
+        "Anything-xl",
+        "High GPT4o",
+        "On limbs black",
+        "F Dev",
+        "SDXL 1.0",
+        "Old School",
+        "Vincent Van Gogh",
+        "Cor-epica-xl",
+        "Professional",
+        "Cheyenne-xl",
+        "Chicano",
+        "SDXL L",
+        "Black Ink",
+        "Juggernaut-xl",
+        "Cinematic Art",
+        "Dreamshaper-xl",
+        "Fantasy Art",
+        "Neo-traditional",
+        "Realistic-stock-xl",
+        "Flame design",
+        "Japanese_2",
+        "Medieval",
+        "Surrealism",
+        "Dotwork",
+        "Graffiti",
+        "RevAnimated",
+        "On limbs color",
+        "Old school colored",
+        "GPT4o Ghibli",
+        "Low Poly",
+        "GPT4o",
+        "No Style",
+        "Anime",
+        "tattoo",
+        "Embroidery tattoo",
+        "Mini tattoo",
+        "Realistic tattoo",
+        "Playground-xl",
+        "Watercolor",
+        "F Pro",
+        "Kawaii",
+        "Photographic",
+        "Katayama-mix-xl",
+        "Death metal",
+        "New School",
+        "Pony-xl",
+        "Anima-pencil-xl",
+        "Flux",
+        "Biomech",
+        "Yamers-realistic-xl",
+        "Trash Polka",
+        "Red and Black",
+    ]
 
     def __init__(self):
-        self.image_generation_url = "https://img-gen-prod.ai-arta.com/api/v1/text2image"
-        self.status_check_url = (
-            "https://img-gen-prod.ai-arta.com/api/v1/text2image/{record_id}/status"
-        )
-        self.auth_url = "https://www.googleapis.com/identitytoolkit/v3/relyingparty/signupNewUser?key=AIzaSyB3-71wG0fIt0shj0ee4fvx1shcjJHGrrQ"
-        self.token_refresh_url = "https://securetoken.googleapis.com/v1/token?key=AIzaSyB3-71wG0fIt0shj0ee4fvx1shcjJHGrrQ"
         self.session = requests.Session()
         self.user_agent = LitAgent().random()
         self.headers = {
@@ -316,11 +322,11 @@ class AIArta(TTICompatibleProvider):
         self.images = Images(self)
 
     def get_auth_file(self) -> str:
-        path = os.path.join(os.path.expanduser("~"), ".ai_arta_cookies")
-        if not os.path.exists(path):
-            os.makedirs(path)
+        import tempfile
+        # Use a temp file in the system's temp directory, unique per class
         filename = f"auth_{self.__class__.__name__}.json"
-        return os.path.join(path, filename)
+        temp_dir = tempfile.gettempdir()
+        return os.path.join(temp_dir, filename)
 
     def create_token(self, path: str) -> Dict[str, Any]:
         auth_payload = {"clientType": "CLIENT_TYPE_ANDROID"}
@@ -369,17 +375,25 @@ class AIArta(TTICompatibleProvider):
                 return auth_data
         return self.create_token(path)
 
-    def get_model(self, model_name: str) -> str:
-        # Convert to lowercase for lookup
-        model_key = model_name.lower()
-        # Return the proper style name from model_aliases, or the original if not found
-        return self.model_aliases.get(model_key, model_name)
+    def get_model(self, model: str) -> str:
+        if not model:
+            return self.default_model
+        if model in self.models:
+            return model
+        raise ModelNotFoundError(f"Model {model} not found")
 
     @property
     def models(self):
         class _ModelList:
             def list(inner_self):
                 return type(self).AVAILABLE_MODELS
+        return _ModelList()
+
+    @property
+    def models_list(self):
+        class _ModelList:
+            def list(inner_self):
+                return type(self).models
 
         return _ModelList()
 
@@ -390,10 +404,10 @@ if __name__ == "__main__":
 
     client = AIArta()
     response = client.images.create(
-        model="flux",
-        prompt="a white siamese cat",
+        model="GPT4o",
+        prompt="Chitt Robot saying 'Hello World'",
         response_format="url",
-        n=2,
-        timeout=30,
+        n=1,
+        timeout=3000,
     )
     print(response)

webscout/Provider/TTI/infip.py

@@ -0,0 +1,212 @@
+"""InfipAI TTI-Compatible Provider - Generate images with Infip AI! 🎨
+
+This module provides access to Infip's image generation API through a unified interface.
+Supports img3, img4, and uncen models with various aspect ratios and customization options.
+
+Example Usage:
+    from webscout.Provider.TTI.infip import InfipAI
+    
+    # Initialize the provider
+    client = InfipAI()
+    
+    # Generate an image
+    response = client.images.create(
+        model="img3",
+        prompt="A beautiful sunset over mountains",
+        n=1,
+        aspect_ratio="IMAGE_ASPECT_RATIO_LANDSCAPE",
+        seed=42
+    )
+    
+    # Get the image URL
+    image_url = response.data[0].url
+    print(f"Generated image: {image_url}")
+
+Available Models:
+    - img3: High-quality image generation
+    - img4: Enhanced image generation model
+    - uncen: Uncensored image generation model
+
+Supported Aspect Ratios:
+    - IMAGE_ASPECT_RATIO_LANDSCAPE: 16:9 landscape
+    - IMAGE_ASPECT_RATIO_PORTRAIT: 9:16 portrait  
+    - IMAGE_ASPECT_RATIO_SQUARE: 1:1 square
+"""
+
+import requests
+from typing import Optional
+from webscout.Provider.TTI.utils import (
+    ImageData,
+    ImageResponse
+)
+from webscout.Provider.TTI.base import TTICompatibleProvider, BaseImages
+from webscout.litagent import LitAgent
+import time
+
+
+class Images(BaseImages):
+    def __init__(self, client):
+        self._client = client
+
+    def create(
+        self,
+        *,
+        model: str,
+        prompt: str,
+        n: int = 1,
+        size: str = "1024x1024",
+        response_format: str = "url",
+        user: Optional[str] = None,
+        style: str = "none",
+        aspect_ratio: str = "IMAGE_ASPECT_RATIO_LANDSCAPE",
+        timeout: int = 60,
+        image_format: str = "png",
+        seed: Optional[int] = None,
+        **kwargs,
+    ) -> ImageResponse:
+        """
+        Create images using Infip AI API.
+
+        Args:
+            model: The model to use ("img3", "img4", or "uncen")
+            prompt: Text description of the image to generate
+            n: Number of images to generate (default: 1)
+            size: Image size (ignored, aspect_ratio is used instead)
+            response_format: "url" or "b64_json" (default: "url")
+            user: Optional user identifier (ignored)
+            style: Optional style (ignored)
+            aspect_ratio: Image aspect ratio ("IMAGE_ASPECT_RATIO_LANDSCAPE", 
+                         "IMAGE_ASPECT_RATIO_PORTRAIT", "IMAGE_ASPECT_RATIO_SQUARE")
+            timeout: Request timeout in seconds (default: 60)
+            image_format: Image format "png" or "jpeg" (ignored by API)
+            seed: Random seed for reproducibility (default: 0 for random)
+            **kwargs: Additional parameters
+
+        Returns:
+            ImageResponse: The generated images
+
+        Raises:
+            ValueError: If model is not supported
+            RuntimeError: If image generation fails
+        """
+        if model not in self._client.AVAILABLE_MODELS:
+            raise ValueError(f"Model '{model}' not supported. Available models: {self._client.AVAILABLE_MODELS}")
+
+        # Validate aspect ratio
+        valid_ratios = [
+            "IMAGE_ASPECT_RATIO_LANDSCAPE",
+            "IMAGE_ASPECT_RATIO_PORTRAIT", 
+            "IMAGE_ASPECT_RATIO_SQUARE"
+        ]
+        if aspect_ratio not in valid_ratios:
+            aspect_ratio = "IMAGE_ASPECT_RATIO_LANDSCAPE"
+
+        # Prepare request payload
+        payload = {
+            "prompt": prompt,
+            "num_images": n,
+            "seed": seed if seed is not None else 0,
+            "aspect_ratio": aspect_ratio,
+            "models": model
+        }
+
+        try:
+            # Make API request
+            response = self._client.session.post(
+                self._client.api_endpoint,
+                json=payload,
+                timeout=timeout
+            )
+            response.raise_for_status()
+            
+            # Parse response
+            result = response.json()
+            
+            if "images" not in result or not result["images"]:
+                raise RuntimeError("No images returned from Infip API")
+
+            # Process response based on format
+            result_data = []
+            
+            if response_format == "url":
+                for image_url in result["images"]:
+                    result_data.append(ImageData(url=image_url))
+            elif response_format == "b64_json":
+                # For b64_json format, we need to download and encode the images
+                import base64
+                for image_url in result["images"]:
+                    try:
+                        img_response = self._client.session.get(image_url, timeout=timeout)
+                        img_response.raise_for_status()
+                        b64_data = base64.b64encode(img_response.content).decode('utf-8')
+                        result_data.append(ImageData(b64_json=b64_data))
+                    except Exception as e:
+                        raise RuntimeError(f"Failed to download image for base64 encoding: {e}")
+            else:
+                raise ValueError("response_format must be 'url' or 'b64_json'")
+
+            return ImageResponse(created=int(time.time()), data=result_data)
+
+        except requests.RequestException as e:
+            raise RuntimeError(f"Failed to generate image with Infip API: {e}")
+        except Exception as e:
+            raise RuntimeError(f"Unexpected error during image generation: {e}")
+
+
+class InfipAI(TTICompatibleProvider):
+    """
+    Infip AI provider for text-to-image generation.
+    
+    This provider interfaces with the Infip API to generate images from text prompts.
+    It supports multiple models and aspect ratios for flexible image creation.
+    """
+    
+    AVAILABLE_MODELS = ["img3", "img4", "uncen"]
+
+    def __init__(self, **kwargs):
+        """
+        Initialize the Infip AI provider.
+        
+        Args:
+            **kwargs: Additional configuration options
+        """
+        self.api_endpoint = "https://api.infip.pro/generate"
+        self.session = requests.Session()
+        
+        # Set up headers with user agent
+        agent = LitAgent()
+        self.headers = {
+            "accept": "application/json",
+            "Content-Type": "application/json",
+            "User-Agent": agent.random()
+        }
+        self.session.headers.update(self.headers)
+        
+        # Initialize the images interface
+        self.images = Images(self)
+
+    @property
+    def models(self):
+        """
+        Get available models for the provider.
+        
+        Returns:
+            Object with list() method that returns available model names
+        """
+        class ModelList:
+            def list(self):
+                return InfipAI.AVAILABLE_MODELS
+        
+        return ModelList()
+
+
+if __name__ == "__main__":
+    client = InfipAI()
+    response = client.images.create(
+        model="img3",
+        prompt="A beautiful sunset over mountains",
+        n=1,
+        aspect_ratio="IMAGE_ASPECT_RATIO_LANDSCAPE",
+        seed=42
+    )
+    print(response.data[0].url)

webscout/Provider/TTI/monochat.py

@@ -0,0 +1,220 @@
+import requests
+import base64
+from typing import Optional, List, Dict, Any
+from webscout.Provider.TTI.utils import (
+    ImageData,
+    ImageResponse
+)
+from webscout.Provider.TTI.base import TTICompatibleProvider, BaseImages
+from webscout.litagent import LitAgent
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+import os
+import tempfile
+import time
+import json
+from io import BytesIO
+
+try:
+    from PIL import Image
+except ImportError:
+    Image = None
+
+
+class Images(BaseImages):
+    def __init__(self, client):
+        self._client = client
+
+    def create(
+        self,
+        *,
+        model: str,
+        prompt: str,
+        n: int = 1,
+        size: str = "1024x1024",
+        response_format: str = "b64_json",
+        user: Optional[str] = None,
+        style: str = None,
+        aspect_ratio: str = None,
+        timeout: int = 60,
+        image_format: str = "png",
+        **kwargs,
+    ) -> ImageResponse:
+        if not prompt:
+            raise ValueError(
+                "Describe the image you want to create (use the 'prompt' property)."
+            )
+        # Only one image is supported by MonoChat API, but keep n for compatibility
+        body = {
+            "prompt": prompt,
+            "model": model
+        }
+        session = self._client.session
+        headers = self._client.headers
+        images = []
+        urls = []
+
+        def upload_file_with_retry(img_bytes, image_format, max_retries=3):
+            ext = "jpg" if image_format.lower() == "jpeg" else "png"
+            for attempt in range(max_retries):
+                tmp_path = None
+                try:
+                    with tempfile.NamedTemporaryFile(suffix=f".{ext}", delete=False) as tmp:
+                        tmp.write(img_bytes)
+                        tmp.flush()
+                        tmp_path = tmp.name
+                    with open(tmp_path, "rb") as f:
+                        files = {"fileToUpload": (f"image.{ext}", f, f"image/{ext}")}
+                        data = {"reqtype": "fileupload", "json": "true"}
+                        headers = {"User-Agent": LitAgent().random()}
+                        if attempt > 0:
+                            headers["Connection"] = "close"
+                        resp = requests.post(
+                            "https://catbox.moe/user/api.php",
+                            files=files,
+                            data=data,
+                            headers=headers,
+                            timeout=timeout,
+                        )
+                        if resp.status_code == 200 and resp.text.strip():
+                            text = resp.text.strip()
+                            if text.startswith("http"):
+                                return text
+                            try:
+                                result = resp.json()
+                                if "url" in result:
+                                    return result["url"]
+                            except json.JSONDecodeError:
+                                if "http" in text:
+                                    return text
+                except Exception:
+                    if attempt < max_retries - 1:
+                        time.sleep(1 * (attempt + 1))
+                finally:
+                    if tmp_path and os.path.isfile(tmp_path):
+                        try:
+                            os.remove(tmp_path)
+                        except Exception:
+                            pass
+            return None
+
+        def upload_file_alternative(img_bytes, image_format):
+            try:
+                ext = "jpg" if image_format.lower() == "jpeg" else "png"
+                with tempfile.NamedTemporaryFile(suffix=f".{ext}", delete=False) as tmp:
+                    tmp.write(img_bytes)
+                    tmp.flush()
+                    tmp_path = tmp.name
+                try:
+                    if not os.path.isfile(tmp_path):
+                        return None
+                    with open(tmp_path, "rb") as img_file:
+                        files = {"file": img_file}
+                        response = requests.post("https://0x0.st", files=files)
+                        response.raise_for_status()
+                        image_url = response.text.strip()
+                        if not image_url.startswith("http"):
+                            return None
+                        return image_url
+                except Exception:
+                    return None
+                finally:
+                    try:
+                        os.remove(tmp_path)
+                    except Exception:
+                        pass
+            except Exception:
+                return None
+
+        try:
+            resp = session.post(
+                f"{self._client.api_endpoint}/image",
+                json=body,
+                headers=headers,
+                timeout=timeout,
+            )
+            resp.raise_for_status()
+            data = resp.json()
+            if not data.get("image"):
+                raise RuntimeError("Failed to process image. No image data found.")
+            # Always decode the base64 image
+            image_bytes = base64.b64decode(data.get("image"))
+            if response_format == "b64_json":
+                result_data = [ImageData(b64_json=data.get("image"))]
+            elif response_format == "url":
+                if Image is None:
+                    raise ImportError("Pillow (PIL) is required for image format conversion.")
+                # Convert to png or jpeg in memory
+                with BytesIO(image_bytes) as input_io:
+                    with Image.open(input_io) as im:
+                        out_io = BytesIO()
+                        if image_format.lower() == "jpeg":
+                            im = im.convert("RGB")
+                            im.save(out_io, format="JPEG")
+                        else:
+                            im.save(out_io, format="PNG")
+                        img_bytes = out_io.getvalue()
+                # Try primary upload method with retries
+                uploaded_url = upload_file_with_retry(img_bytes, image_format)
+                # If primary method fails, try alternative
+                if not uploaded_url:
+                    uploaded_url = upload_file_alternative(img_bytes, image_format)
+                if uploaded_url:
+                    result_data = [ImageData(url=uploaded_url)]
+                else:
+                    raise RuntimeError("Failed to upload image to catbox.moe using all available methods")
+            else:
+                raise ValueError("response_format must be 'url' or 'b64_json'")
+            from time import time as _time
+            return ImageResponse(created=int(_time()), data=result_data)
+        except Exception as e:
+            raise RuntimeError(f"An error occurred: {str(e)}")
+
+
+class MonoChatAI(TTICompatibleProvider):
+    AVAILABLE_MODELS = ["nextlm-image-1", "gpt-image-1", "dall-e-3", "dall-e-2"]
+
+    def __init__(self):
+        self.api_endpoint = "https://www.chatwithmono.xyz/api"
+        self.session = requests.Session()
+        self._setup_session_with_retries()
+        self.user_agent = LitAgent().random()
+        self.headers = {
+            "accept": "*/*",
+            "content-type": "application/json",
+            "origin": "https://www.chatwithmono.xyz",
+            "referer": "https://www.chatwithmono.xyz/",
+            "user-agent": self.user_agent,
+        }
+        self.session.headers.update(self.headers)
+        self.images = Images(self)
+
+    def _setup_session_with_retries(self):
+        retry_strategy = Retry(
+            total=3,
+            status_forcelist=[429, 500, 502, 503, 504],
+            backoff_factor=1,
+            allowed_methods=["HEAD", "GET", "OPTIONS", "POST"],
+        )
+        adapter = HTTPAdapter(max_retries=retry_strategy)
+        self.session.mount("http://", adapter)
+        self.session.mount("https://", adapter)
+
+    @property
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return type(self).AVAILABLE_MODELS
+        return _ModelList()
+
+
+if __name__ == "__main__":
+    from rich import print
+    client = MonoChatAI()
+    response = client.images.create(
+        model="dall-e-3",
+        prompt="A red car on a sunny day",
+        response_format="url",
+        timeout=60000,
+    )
+    print(response)