webscout 8.3.1__py3-none-any.whl → 8.3.2__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/TTS/speechma.py

@@ -1,15 +1,12 @@
 ##################################################################################
 ##  Modified version of code written by t.me/infip1217                          ##
 ##################################################################################
-import time
 import requests
 import pathlib
 import tempfile
-from io import BytesIO
 from webscout import exceptions
 from webscout.litagent import LitAgent
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from webscout.Provider.TTS import utils
+from webscout.Litlogger import Logger, LogLevel
 from webscout.Provider.TTS.base import BaseTTSProvider
 
 class SpeechMaTTS(BaseTTSProvider):
@@ -18,12 +15,11 @@ class SpeechMaTTS(BaseTTSProvider):
     """
     # Request headers
     headers = {
-        "accept": "*/*",
-        "accept-language": "en-IN,en-GB;q=0.9,en-US;q=0.8,en;q=0.7,en-AU;q=0.6",
-        "content-type": "application/json",
+        "authority": "speechma.com",
         "origin": "https://speechma.com",
-        "priority": "u=1, i",
-        "User-Agent": LitAgent().random()
+        "referer": "https://speechma.com/",
+        "content-type": "application/json",
+        **LitAgent().generate_fingerprint()
     }
 
     # Available voices with their IDs
@@ -496,8 +492,9 @@ class SpeechMaTTS(BaseTTSProvider):
         if proxies:
             self.session.proxies.update(proxies)
         self.timeout = timeout
+        self.logger = Logger(name="SpeechMaTTS", level=LogLevel.INFO)
 
-    def tts(self, text: str, voice: str = "Emma", pitch: int = 0, rate: int = 0) -> str:
+    def tts(self, text: str, voice: str = "Emma", pitch: int = 0, rate: int = 0, verbose: bool = False) -> str:
         """
         Converts text to speech using the SpeechMa API and saves it to a file.
 
@@ -506,6 +503,7 @@ class SpeechMaTTS(BaseTTSProvider):
             voice (str): The voice to use for TTS (default: "Emma")
             pitch (int): Voice pitch adjustment (-10 to 10, default: 0)
             rate (int): Voice rate/speed adjustment (-10 to 10, default: 0)
+            verbose (bool): Whether to print debug information (default: False)
 
         Returns:
             str: Path to the generated audio file
@@ -517,10 +515,13 @@ class SpeechMaTTS(BaseTTSProvider):
             voice in self.all_voices
         ), f"Voice '{voice}' not one of [{', '.join(self.all_voices.keys())}]"
 
+        if not text or text.strip() == '':
+            raise exceptions.FailedToGenerateResponseError("Text is empty")
+
         filename = pathlib.Path(tempfile.mktemp(suffix=".mp3", dir=self.temp_dir))
         voice_id = self.all_voices[voice]
 
-        # Prepare payload for the job-based API
+        # Prepare payload for the API
         payload = {
             "text": text,
             "voice": voice_id,
@@ -530,44 +531,49 @@ class SpeechMaTTS(BaseTTSProvider):
         }
 
         try:
+            # Set logger level based on verbose flag
+            if verbose:
+                self.logger.level = LogLevel.DEBUG
+                self.logger.debug(f"Generating audio for voice: {voice} ({voice_id})")
+                self.logger.debug(f"Text length: {len(text)} characters")
+            else:
+                self.logger.level = LogLevel.INFO
+
+            # Make the request to the SpeechMa API
             response = self.session.post(
                 self.api_url,
                 headers=self.headers,
                 json=payload,
                 timeout=self.timeout
             )
-            response.raise_for_status()
-            resp_json = response.json()
-            if not resp_json.get("success") or "data" not in resp_json or "job_id" not in resp_json["data"]:
-                raise exceptions.FailedToGenerateResponseError(f"SpeechMa API error: {resp_json}")
-            job_id = resp_json["data"]["job_id"]
 
-            # Poll for job completion
-            status_url = f"https://speechma.com/com.api/tts-api.php/status/{job_id}"
-            for _ in range(30):  # up to ~30 seconds
-                status_resp = self.session.get(
-                    status_url,
-                    headers=self.headers,
-                    timeout=self.timeout
-                )
-                status_resp.raise_for_status()
-                status_json = status_resp.json()
-                if status_json.get("success") and status_json.get("data", {}).get("status") == "completed":
-                    break
-                time.sleep(1)
-            else:
-                raise exceptions.FailedToGenerateResponseError("TTS job did not complete in time.")
+            if response.status_code != 200:
+                if verbose:
+                    self.logger.error(f"API error: Status {response.status_code}")
+                raise exceptions.FailedToGenerateResponseError(f"API returned status {response.status_code}: {response.text[:500]}")
 
-            # Download the audio file (API provides a URL in the status response)
-            data = status_json["data"]
-            audio_url = f"https://speechma.com/com.api/tts-api.php/audio/{job_id}"
-            audio_resp = self.session.get(audio_url, timeout=self.timeout)
-            audio_resp.raise_for_status()
-            with open(filename, 'wb') as f:
-                f.write(audio_resp.content)
-            return filename.as_posix()
+            # Check if response is audio data (content-type should be audio/mpeg)
+            content_type = response.headers.get('content-type', '').lower()
+            if verbose:
+                self.logger.debug(f"Response content type: {content_type}")
+                self.logger.debug(f"Response size: {len(response.content)} bytes")
+
+            if 'audio' in content_type or response.content.startswith(b'\xff\xfb') or response.content.startswith(b'ID3') or b'LAME' in response.content[:100]:
+                # This is audio data, save it directly
+                with open(filename, 'wb') as f:
+                    f.write(response.content)
+                if verbose:
+                    self.logger.debug(f"Audio saved to: {filename}")
+                return filename.as_posix()
+            else:
+                # Unexpected response format
+                if verbose:
+                    self.logger.error(f"Unexpected response format: {content_type}")
+                raise exceptions.FailedToGenerateResponseError(f"Unexpected response format. Content-Type: {content_type}, Content: {response.text[:200]}")
 
         except requests.exceptions.RequestException as e:
+            if verbose:
+                self.logger.error(f"Request failed: {e}")
             raise exceptions.FailedToGenerateResponseError(
                 f"Failed to perform the operation: {e}"
             )