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

webscout/Provider/TTI/gpt1image.py

@@ -0,0 +1,149 @@
+import requests
+import random
+import string
+from typing import Optional, List, Dict, Any
+from webscout.Provider.TTI.utils import (
+    ImageData,
+    ImageResponse
+)
+from webscout.Provider.TTI.base import TTICompatibleProvider, BaseImages
+from io import BytesIO
+import os
+import tempfile
+from webscout.litagent import LitAgent
+import time
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+
+class Images(BaseImages):
+    def __init__(self, client):
+        self._client = client
+        self.base_url = "https://gpt1image.exomlapi.com"
+        # Create a session - it will automatically get proxies from the global monkey patch!
+        self.session = requests.Session()
+        self._setup_session_with_retries()
+
+    def _setup_session_with_retries(self):
+        """Setup session with retry strategy and timeout configurations"""
+        # Configure retry strategy
+        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)
+
+        # Set timeouts
+        # self.session.timeout = (10, 30)  # (connect_timeout, read_timeout)
+        # Unlimited timeout: do not set session timeout here
+
+    def build_headers(self, extra: Optional[Dict[str, str]] = None) -> Dict[str, str]:
+        agent = LitAgent()
+        fp = agent.generate_fingerprint("chrome")
+        headers = {
+            "Content-Type": "application/json",
+            "accept": fp["accept"],
+            "accept-language": fp["accept_language"],
+            "origin": self.base_url,
+            "referer": f"{self.base_url}/",
+            "user-agent": fp["user_agent"],
+            "sec-ch-ua": fp["sec_ch_ua"],
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            "x-forwarded-for": fp["x-forwarded-for"],
+            "x-real-ip": fp["x-real-ip"],
+            "x-request-id": fp["x-request-id"],
+        }
+        if extra:
+            headers.update(extra)
+        return headers
+
+    def create(
+        self,
+        model: str = None,
+        prompt: str = None,
+        n: int = 1,
+        size: str = "1024x1024",
+        response_format: str = "url",
+        user: Optional[str] = None,
+        style: str = None,
+        aspect_ratio: str = None,
+        timeout: int = 60,
+        image_format: str = "png",
+        enhance: bool = True,
+        **kwargs,
+    ) -> ImageResponse:
+        if not prompt:
+            raise ValueError(
+                "Describe the image you want to create (use the 'prompt' property)."
+            )
+        body = {
+            "prompt": prompt,
+            "n": n,
+            "size": size,
+            "is_enhance": enhance,
+            "response_format": response_format,
+        }
+        try:
+            # Use direct session.request instead of request_with_proxy_fallback
+            resp = self.session.request(
+                "post",
+                f"{self.base_url}/v1/images/generations",
+                json=body,
+                headers=self.build_headers(),
+                timeout=timeout,
+            )
+            data = resp.json()
+            if not data.get("data") or len(data["data"]) == 0:
+                error_info = (
+                    f", server info: {data.get('error')}" if data.get("error") else ""
+                )
+                raise RuntimeError(
+                    f"Failed to process image. No data found{error_info}."
+                )
+            result = data["data"]
+            result_data = []
+            for item in result:
+                if response_format == "url":
+                    result_data.append(ImageData(url=item.get("url")))
+                else:
+                    result_data.append(ImageData(b64_json=item.get("b64_json")))
+            return ImageResponse(data=result_data)
+        except Exception as e:
+            raise RuntimeError(f"An error occurred: {str(e)}")
+
+
+class GPT1Image(TTICompatibleProvider):
+    AVAILABLE_MODELS = ["gpt1image"]
+
+    def __init__(self):
+        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 = GPT1Image()
+    response = client.images.create(
+        prompt="A futuristic robot in a neon city",
+        response_format="url",
+        n=1,
+        timeout=None,
+    )
+    print(response)

webscout/Provider/TTI/imagen.py

@@ -0,0 +1,196 @@
+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
+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 = "1:1",
+        timeout: int = 60,
+        image_format: str = "png",
+        seed: Optional[int] = None,
+        **kwargs,
+    ) -> ImageResponse:
+        """
+        Create images using the Imagen API.
+
+        Args:
+            model: The model to use (e.g., "imagen_3_5")
+            prompt: The text prompt for image generation
+            n: Number of images to generate
+            size: Image size (e.g., "1024x1024")
+            response_format: "url" or "b64_json"
+            timeout: Request timeout in seconds
+            **kwargs: Additional parameters
+
+        Returns:
+            ImageResponse: The generated images
+        """
+        if not prompt:
+            raise ValueError("Prompt is required!")
+
+        result_data = []
+
+        for _ in range(n):
+            # Prepare the request payload
+            payload = {
+                "prompt": prompt,
+                "model": model,
+                "size": size,
+                "response_format": "url",  # Always request URL from API
+            }
+
+            try:
+                # Make the API request
+                resp = self._client.session.request(
+                    "post",
+                    self._client.api_endpoint,
+                    json=payload,
+                    timeout=timeout,
+                )
+                resp.raise_for_status()
+
+                # Parse the response
+                result = resp.json()
+
+                if not result or "data" not in result:
+                    raise RuntimeError("Invalid response from Imagen API")
+
+                # Process each image in the response
+                for item in result["data"]:
+                    if response_format == "url":
+                        if "url" in item and item["url"]:
+                            result_data.append(ImageData(url=item["url"]))
+                        else:
+                            raise RuntimeError("No URL found in API response")
+
+                    elif response_format == "b64_json":
+                        if "url" in item and item["url"]:
+                            # Download the image and convert to base64
+                            img_resp = self._client.session.request(
+                                "get",
+                                item["url"],
+                                timeout=timeout,
+                            )
+                            img_resp.raise_for_status()
+                            img_bytes = img_resp.content
+                            b64_string = base64.b64encode(img_bytes).decode("utf-8")
+                            result_data.append(ImageData(b64_json=b64_string))
+                        elif "b64_json" in item and item["b64_json"]:
+                            result_data.append(ImageData(b64_json=item["b64_json"]))
+                        else:
+                            raise RuntimeError("No image data found in API response")
+
+                    else:
+                        raise ValueError("response_format must be 'url' or 'b64_json'")
+
+            except requests.exceptions.RequestException as e:
+                raise RuntimeError(f"Failed to generate image with Imagen API: {e}")
+            except Exception as e:
+                raise RuntimeError(f"Error processing Imagen API response: {e}")
+
+        return ImageResponse(created=int(time.time()), data=result_data)
+
+
+class ImagenAI(TTICompatibleProvider):
+    """
+    Imagen API provider for text-to-image generation.
+
+    This provider interfaces with the Imagen API at imagen.exomlapi.com
+    to generate images from text prompts.
+    """
+
+    AVAILABLE_MODELS = ["imagen_3_5", "imagen_3"]
+
+    def __init__(self, api_key: Optional[str] = None):
+        """
+        Initialize the Imagen API client.
+
+        Args:
+            api_key: Optional API key for authentication (if required)
+        """
+        self.api_endpoint = "https://imagen.exomlapi.com/v1/images/generations"
+        self.session = requests.Session()
+        self.user_agent = LitAgent().random()
+        self.api_key = api_key
+
+        # Set up headers based on the provided request details
+        self.headers = {
+            "accept": "*/*",
+            "accept-encoding": "gzip, deflate, br, zstd",
+            "accept-language": "en-US,en;q=0.9,en-IN;q=0.8",
+            "content-type": "application/json",
+            "dnt": "1",
+            "origin": "https://imagen.exomlapi.com",
+            "referer": "https://imagen.exomlapi.com/",
+            "sec-ch-ua": '"Chromium";v="136", "Microsoft Edge";v="136", "Not.A/Brand";v="99"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            "sec-gpc": "1",
+            "user-agent": self.user_agent,
+        }
+
+        # Add API key to headers if provided
+        if self.api_key:
+            self.headers["authorization"] = f"Bearer {self.api_key}"
+
+        self.session.headers.update(self.headers)
+        self.images = Images(self)
+
+    @property
+    def models(self):
+        """
+        Get available models for the Imagen API.
+
+        Returns:
+            Object with list() method that returns available models
+        """
+
+        class _ModelList:
+            def list(inner_self):
+                return type(self).AVAILABLE_MODELS
+
+        return _ModelList()
+
+
+if __name__ == "__main__":
+    from rich import print
+
+    # Example usage
+    client = ImagenAI()
+
+    try:
+        response = client.images.create(
+            model="imagen_3_5",
+            prompt="red car",
+            response_format="url",
+            n=1,
+            size="1024x1024",
+            timeout=30,
+        )
+        print("Generated image successfully:")
+        print(response)
+    except Exception as e:
+        print(f"Error: {e}")

webscout/Provider/TTI/magicstudio.py

@@ -4,7 +4,10 @@ import uuid
 import time
 import tempfile
 from typing import Optional, List
-from webscout.Provider.TTI.utils import ImageData, ImageResponse
+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
@@ -14,11 +17,13 @@ try:
 except ImportError:
     Image = None
 
+
 class Images(BaseImages):
     def __init__(self, client):
         self._client = client
 
-    def create(self,
+    def create(
+        self,
         model: str = "magicstudio",
         prompt: str = None,
         n: int = 1,
@@ -29,7 +34,7 @@ class Images(BaseImages):
         aspect_ratio: str = None,
         timeout: int = 60,
         image_format: str = "jpg",
-        **kwargs
+        **kwargs,
     ) -> ImageResponse:
         if not prompt:
             raise ValueError("Prompt is required!")
@@ -43,7 +48,7 @@ class Images(BaseImages):
             "Origin": "https://magicstudio.com",
             "Referer": "https://magicstudio.com/ai-art-generator/",
             "DNT": "1",
-            "Sec-GPC": "1"
+            "Sec-GPC": "1",
         }
         session = requests.Session()
         session.headers.update(headers)
@@ -57,7 +62,11 @@ class Images(BaseImages):
                 "user_is_subscribed": "false",
                 "client_id": uuid.uuid4().hex,
             }
-            resp = session.post(api_url, data=form_data, timeout=timeout)
+            resp = session.post(
+                api_url,
+                data=form_data,
+                timeout=timeout,
+            )
             resp.raise_for_status()
             img_bytes = resp.content
             # Convert to png or jpeg in memory if needed
@@ -65,7 +74,10 @@ class Images(BaseImages):
                 with BytesIO(img_bytes) as input_io:
                     with Image.open(input_io) as im:
                         out_io = BytesIO()
-                        if image_format.lower() == "jpeg" or image_format.lower() == "jpg":
+                        if (
+                            image_format.lower() == "jpeg"
+                            or image_format.lower() == "jpg"
+                        ):
                             im = im.convert("RGB")
                             im.save(out_io, format="JPEG")
                         else:
@@ -73,37 +85,43 @@ class Images(BaseImages):
                         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() in ("jpeg", "jpg") else "png"
                     for attempt in range(max_retries):
                         tmp_path = None
                         try:
-                            with tempfile.NamedTemporaryFile(suffix=f".{ext}", delete=False) as tmp:
+                            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:
+                            with open(tmp_path, "rb") as f:
                                 files = {
-                                    'fileToUpload': (f'image.{ext}', f, f'image/{ext}')
+                                    "fileToUpload": (f"image.{ext}", f, f"image/{ext}")
                                 }
-                                data = {
-                                    'reqtype': 'fileupload',
-                                    'json': 'true'
-                                }
-                                headers = {'User-Agent': agent.random()}
+                                data = {"reqtype": "fileupload", "json": "true"}
+                                headers = {"User-Agent": agent.random()}
                                 if attempt > 0:
-                                    headers['Connection'] = 'close'
-                                resp = requests.post("https://catbox.moe/user/api.php", files=files, data=data, headers=headers, timeout=timeout)
+                                    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'):
+                                    if text.startswith("http"):
                                         return text
                                     try:
                                         result = resp.json()
                                         if "url" in result:
                                             return result["url"]
                                     except Exception:
-                                        if 'http' in text:
+                                        if "http" in text:
                                             return text
                         except Exception:
                             if attempt < max_retries - 1:
@@ -115,22 +133,27 @@ class Images(BaseImages):
                                 except Exception:
                                     pass
                     return None
+
                 def upload_file_alternative(img_bytes, image_format):
                     try:
-                        ext = "jpg" if image_format.lower() in ("jpeg", "jpg") else "png"
-                        with tempfile.NamedTemporaryFile(suffix=f".{ext}", delete=False) as tmp:
+                        ext = (
+                            "jpg" if image_format.lower() in ("jpeg", "jpg") 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)
+                            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'):
+                                if not image_url.startswith("http"):
                                     return None
                                 return image_url
                         except Exception:
@@ -142,32 +165,36 @@ class Images(BaseImages):
                                 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")
+                    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
-        )
+
+        return ImageResponse(created=int(_time()), data=result_data)
+
 
 class MagicStudioAI(TTICompatibleProvider):
     AVAILABLE_MODELS = ["magicstudio"]
+
     def __init__(self):
         self.api_endpoint = "https://ai-api.magicstudio.com/api/ai-art-generator"
         self.session = requests.Session()
@@ -182,15 +209,19 @@ class MagicStudioAI(TTICompatibleProvider):
         }
         self.session.headers.update(self.headers)
         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 = MagicStudioAI()
     response = client.images.create(
         prompt="A cool cyberpunk city at night",