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

webscout/Provider/TTI/base.py

@@ -1,7 +1,8 @@
 from abc import ABC, abstractmethod
-from typing import List, Dict, Optional, Any, Union, Generator
+from typing import Any, Optional
 from .utils import ImageResponse
-import random
+
+
 
 class BaseImages(ABC):
     @abstractmethod
@@ -43,10 +44,81 @@ class BaseImages(ABC):
         """
         raise NotImplementedError
 
+# class ProxyAutoMeta(ABCMeta):
+#     """Metaclass providing seamless proxy injection for providers."""
+
+#     def __call__(cls, *args, **kwargs):
+#         # Determine if automatic proxying should be disabled
+#         disable_auto_proxy = kwargs.get('disable_auto_proxy', False) or getattr(cls, 'DISABLE_AUTO_PROXY', False)
+
+#         # Proxies may be supplied explicitly
+#         proxies = kwargs.get('proxies', None)
+
+#         # Otherwise try to fetch one automatically
+#         if proxies is None and not disable_auto_proxy:
+#             try:
+#                 proxies = {"http": get_auto_proxy(), "https": get_auto_proxy()}
+#             except Exception as e:
+#                 print(f"Failed to fetch auto-proxy: {e}")
+#                 proxies = {}
+#         elif proxies is None:
+#             proxies = {}
+
+#         # No global monkeypatching, just set proxies on the instance
+#         instance = super().__call__(*args, **kwargs)
+#         instance.proxies = proxies
+
+#         # If proxies are set, patch any existing session-like attributes
+#         if proxies:
+#             for attr in dir(instance):
+#                 obj = getattr(instance, attr)
+#                 if isinstance(obj, requests.Session):
+#                     obj.proxies.update(proxies)
+#                 if CurlSession and isinstance(obj, CurlSession):
+#                     try:
+#                         obj.proxies.update(proxies)
+#                     except (ValueError, KeyError, AttributeError):
+#                         print("Failed to update proxies for CurlSession due to an expected error.")
+#                 if CurlAsyncSession and isinstance(obj, CurlAsyncSession):
+#                     try:
+#                         obj.proxies.update(proxies)
+#                     except (ValueError, KeyError, AttributeError):
+#                         print("Failed to update proxies for CurlAsyncSession due to an expected error.")
+
+#         # Helper for backward compatibility
+#         def get_proxied_session():
+#             s = requests.Session()
+#             s.proxies.update(proxies)
+#             return s
+
+#         instance.get_proxied_session = get_proxied_session
+
+#         def get_proxied_curl_session(impersonate="chrome120", **kw):
+#             if CurlSession:
+#                 return CurlSession(proxies=proxies, impersonate=impersonate, **kw)
+#             raise ImportError("curl_cffi is not installed")
+
+#         instance.get_proxied_curl_session = get_proxied_curl_session
+
+#         def get_proxied_curl_async_session(impersonate="chrome120", **kw):
+#             if CurlAsyncSession:
+#                 return CurlAsyncSession(proxies=proxies, impersonate=impersonate, **kw)
+#             raise ImportError("curl_cffi is not installed")
+
+#         instance.get_proxied_curl_async_session = get_proxied_curl_async_session
+
+#         return instance
+
 class TTICompatibleProvider(ABC):
     """
     Abstract Base Class for TTI providers mimicking the OpenAI Python client structure.
     Requires a nested 'images.create' structure.
+    All subclasses automatically get proxy support via ProxyAutoMeta.
+
+    Available proxy helpers:
+    - self.get_proxied_session() - returns a requests.Session with proxies
+    - self.get_proxied_curl_session() - returns a curl_cffi.Session with proxies
+    - self.get_proxied_curl_async_session() - returns a curl_cffi.AsyncSession with proxies
     """
     images: BaseImages
 

webscout/Provider/TTI/fastflux.py

@@ -2,8 +2,12 @@ import requests
 import os
 import tempfile
 import time
+import base64
 from typing import Optional, List, Dict, Any
-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
@@ -13,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 = "flux_1_schnell",
         prompt: str = None,
         n: int = 1,
@@ -29,7 +35,7 @@ class Images(BaseImages):
         timeout: int = 60,
         image_format: str = "png",
         is_public: bool = False,
-        **kwargs
+        **kwargs,
     ) -> ImageResponse:
         if not prompt:
             raise ValueError("Prompt is required!")
@@ -41,15 +47,19 @@ class Images(BaseImages):
             "prompt": prompt,
             "model": model,
             "size": size,
-            "isPublic": is_public
+            "isPublic": is_public,
         }
         for _ in range(n):
-            resp = self._client.session.post(api_url, json=payload, timeout=timeout)
+            resp = self._client.session.post(
+                api_url,
+                json=payload,
+                timeout=timeout,
+            )
             resp.raise_for_status()
             result = resp.json()
-            if result and 'result' in result:
-                image_data = result['result']
-                base64_data = image_data.split(',')[1]
+            if result and "result" in result:
+                image_data = result["result"]
+                base64_data = image_data.split(",")[1]
                 img_bytes = base64.b64decode(base64_data)
                 # Convert to png or jpeg in memory if needed
                 if Image is not None:
@@ -64,37 +74,47 @@ 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() == "jpeg" 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:
@@ -106,22 +126,27 @@ class Images(BaseImages):
                                     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:
+                            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)
+                                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'):
+                                    if not image_url.startswith("http"):
                                         return None
                                     return image_url
                             except Exception:
@@ -133,13 +158,16 @@ 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"
+                        )
             else:
                 raise RuntimeError("No image data received from FastFlux API")
         result_data = []
@@ -148,21 +176,22 @@ class Images(BaseImages):
                 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 FastFluxAI(TTICompatibleProvider):
     AVAILABLE_MODELS = [
         "flux_1_schnell",
     ]
+
     def __init__(self, api_key: str = None):
         self.api_endpoint = "https://api.freeflux.ai/v1/images/generate"
         self.session = requests.Session()
@@ -180,15 +209,19 @@ class FastFluxAI(TTICompatibleProvider):
             self.headers["authorization"] = f"Bearer {self.api_key}"
         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 = FastFluxAI()
     response = client.images.create(
         model="flux_1_schnell",

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}")