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

webscout/Provider/TTI/bing.py

@@ -0,0 +1,231 @@
+import requests
+import time
+import tempfile
+import os
+from typing import Optional
+from webscout.Provider.TTI.utils import ImageData, ImageResponse
+from webscout.Provider.TTI.base import TTICompatibleProvider, BaseImages
+from io import BytesIO
+from webscout.litagent import LitAgent
+
+try:
+    from PIL import Image
+except ImportError:
+    Image = None
+
+class Images(BaseImages):
+    def __init__(self, client):
+        self._client = client
+
+    def create(
+        self,
+        *,
+        model: str = "bing",
+        prompt: str,
+        n: int = 1,
+        size: str = "1024x1024",
+        response_format: str = "url",
+        user: Optional[str] = None,
+        style: str = "none",
+        aspect_ratio: str = "1:1",
+        timeout: int = 60,
+        image_format: str = "png",
+        seed: Optional[int] = None,
+        **kwargs
+    ) -> ImageResponse:
+        if not prompt:
+            raise ValueError("Parameter 'prompt' is required")
+        if Image is None:
+            raise ImportError("Pillow (PIL) is required for image format conversion.")
+        agent = LitAgent()
+        session = self._client.session
+        headers = self._client.headers
+        images = []
+        urls = []
+        for _ in range(n):
+            data = {
+                "q": prompt,
+                "rt": "4",
+                "FORM": "GENCRE"
+            }
+            response = session.post(
+                "https://www.bing.com/images/create",
+                data=data,
+                headers=headers,
+                allow_redirects=False,
+                timeout=timeout
+            )
+            redirect_url = response.headers.get("Location")
+            if not redirect_url:
+                raise Exception("Failed to get redirect URL")
+            from urllib.parse import urlparse, parse_qs
+            query = urlparse(redirect_url).query
+            request_id = parse_qs(query).get("id", [None])[0]
+            if not request_id:
+                raise Exception("ID not found in URL")
+            polling_url = f"https://www.bing.com/images/create/async/results/{request_id}?q={requests.utils.quote(prompt)}"
+            attempts = 0
+            img_url = None
+            while attempts < 10:
+                time.sleep(3)
+                try:
+                    poll_resp = session.get(polling_url, headers=headers, timeout=timeout)
+                    from bs4 import BeautifulSoup
+                    soup = BeautifulSoup(poll_resp.text, "html.parser")
+                    imgs = [img["src"].split("?")[0] for img in soup.select(".img_cont .mimg") if img.get("src")]
+                    if imgs:
+                        img_url = imgs[0]
+                        break
+                except Exception:
+                    pass
+                attempts += 1
+            if not img_url:
+                raise Exception("Failed to get images after polling.")
+            img_bytes = session.get(img_url, headers=headers, timeout=timeout).content
+            # Convert to png or jpeg in memory
+            with BytesIO(img_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()
+            images.append(img_bytes)
+            if response_format == "url":
+                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"}
+                                headers2 = {"User-Agent": agent.random()}
+                                if attempt > 0:
+                                    headers2["Connection"] = "close"
+                                resp2 = requests.post(
+                                    "https://catbox.moe/user/api.php",
+                                    files=files,
+                                    data=data,
+                                    headers=headers2,
+                                    timeout=timeout,
+                                )
+                                if resp2.status_code == 200 and resp2.text.strip():
+                                    text = resp2.text.strip()
+                                    if text.startswith("http"):
+                                        return text
+                                    try:
+                                        result = resp2.json()
+                                        if "url" in result:
+                                            return result["url"]
+                                    except Exception:
+                                        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}
+                                alt_resp = requests.post("https://0x0.st", files=files)
+                                alt_resp.raise_for_status()
+                                image_url = alt_resp.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
+                uploaded_url = upload_file_with_retry(img_bytes, image_format)
+                if not uploaded_url:
+                    uploaded_url = upload_file_alternative(img_bytes, image_format)
+                if uploaded_url:
+                    urls.append(uploaded_url)
+                else:
+                    raise RuntimeError(
+                        "Failed to upload image to catbox.moe using all available methods"
+                    )
+        result_data = []
+        if response_format == "url":
+            for url in urls:
+                result_data.append(ImageData(url=url))
+        elif response_format == "b64_json":
+            import base64
+            for img in images:
+                b64 = base64.b64encode(img).decode("utf-8")
+                result_data.append(ImageData(b64_json=b64))
+        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)
+
+class BingImageAI(TTICompatibleProvider):
+    AVAILABLE_MODELS = ["bing"]
+    def __init__(self, cookie: Optional[str] = None):
+        self.session = requests.Session()
+        self.user_agent = LitAgent().random()
+        self.headers = {
+            "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+            "accept-language": "id-ID,id;q=0.9",
+            "cache-control": "max-age=0",
+            "content-type": "application/x-www-form-urlencoded",
+            "origin": "https://www.bing.com",
+            "referer": "https://www.bing.com/images/create?&wlexpsignin=1",
+            "sec-ch-ua": '"Chromium";v="131", "Not_A Brand";v="24", "Microsoft Edge Simulate";v="131", "Lemur";v="131"',
+            "sec-ch-ua-mobile": "?1",
+            "sec-fetch-site": "same-origin",
+            "sec-fetch-mode": "navigate",
+            "sec-fetch-dest": "document",
+            "upgrade-insecure-requests": "1",
+            "user-agent": self.user_agent,
+        }
+        self.session.headers.update(self.headers)
+        self.cookie = cookie
+        if cookie:
+            self.session.cookies.set("_U", cookie, domain="bing.com")
+        self.images = Images(self)
+    @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 = BingImageAI(cookie="1pkdvumH1SEjFkDjFymRYKouIRoXZlh_p5RTfAttx4DaaNOSDyz8qFP2M7LbZ93fbl4f6Xm8fTGwXHNDB648Gom5jfnTU_Iz-VH47l0HTYJDS1sItbBBS-sqSISFgXR62SoqnW5eX5MFht-j2uB1gZ4uDnpR_60fLRTCdW1SIRegDvnBm1TGhRiZsi6wUPyzwFg7-PsXAs3Fq9iV9m-0FEw")
+    response = client.images.create(
+        prompt="A cat riding a bicycle",
+        response_format="url",
+        n=4,
+        timeout=30
+    )
+    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)