webscout 8.3__py3-none-any.whl → 8.3.2__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/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/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",