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

webscout/Provider/TTI/pollinations.py

@@ -2,7 +2,10 @@ import requests
 from typing import Optional, List, Dict, Any, Union
 from pathlib import Path
 from requests.exceptions import RequestException
-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
 import os
@@ -17,6 +20,7 @@ try:
 except ImportError:
     Image = None
 
+
 class Images(BaseImages):
     def __init__(self, client):
         self._client = client
@@ -35,7 +39,7 @@ class Images(BaseImages):
         timeout: int = 60,
         image_format: str = "png",
         seed: Optional[int] = None,
-        **kwargs
+        **kwargs,
     ) -> ImageResponse:
         """
         image_format: "png" or "jpeg"
@@ -52,32 +56,35 @@ class Images(BaseImages):
             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:
-                        files = {
-                            'fileToUpload': (f'image.{ext}', f, f'image/{ext}')
-                        }
-                        data = {
-                            'reqtype': 'fileupload',
-                            'json': 'true'
-                        }
-                        headers = {'User-Agent': LitAgent().random()}
+                    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)
+                            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 json.JSONDecodeError:
-                                if 'http' in text:
+                                if "http" in text:
                                     return text
                 except Exception:
                     if attempt < max_retries - 1:
@@ -100,12 +107,12 @@ class Images(BaseImages):
                 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:
@@ -132,7 +139,10 @@ class Images(BaseImages):
             query = "&".join(f"{k}={v}" for k, v in params.items())
             url = f"{base_url}?{query}"
             try:
-                resp = self._client.session.get(url, timeout=timeout)
+                resp = self._client.session.get(
+                    url,
+                    timeout=timeout,
+                )
                 resp.raise_for_status()
                 img_bytes = resp.content
             except RequestException as e:
@@ -158,7 +168,9 @@ class Images(BaseImages):
                 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":
@@ -166,6 +178,7 @@ 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))
@@ -173,17 +186,12 @@ class Images(BaseImages):
             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 PollinationsAI(TTICompatibleProvider):
-    AVAILABLE_MODELS = [
-        "flux",
-        "turbo",
-        "gptimage"
-    ]
+    AVAILABLE_MODELS = ["flux", "turbo", "gptimage"]
 
     def __init__(self):
         self.api_endpoint = "https://image.pollinations.ai/prompt"
@@ -205,10 +213,13 @@ class PollinationsAI(TTICompatibleProvider):
         class _ModelList:
             def list(inner_self):
                 return type(self).AVAILABLE_MODELS
+
         return _ModelList()
 
+
 if __name__ == "__main__":
     from rich import print
+
     client = PollinationsAI()
     response = client.images.create(
         model="flux",
@@ -216,6 +227,6 @@ if __name__ == "__main__":
         response_format="url",
         n=4,
         timeout=30,
-        seed=None  # You can set a specific seed for reproducibility
+        seed=None,  # You can set a specific seed for reproducibility
     )
     print(response)

webscout/Provider/TTI/together.py

@@ -0,0 +1,287 @@
+import requests
+import random
+import string
+import json
+import time
+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
+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://api.together.xyz/v1"
+        # 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)
+
+    def get_api_key(self) -> str:
+        """Get API key from activation endpoint or cache"""
+        if hasattr(self._client, '_api_key_cache') and self._client._api_key_cache:
+            return self._client._api_key_cache
+            
+        try:
+            activation_endpoint = "https://www.codegeneration.ai/activate-v2"
+            response = requests.get(
+                activation_endpoint,
+                headers={"Accept": "application/json"},
+                timeout=30
+            )
+            response.raise_for_status()
+            activation_data = response.json()
+            api_key = activation_data["openAIParams"]["apiKey"]
+            self._client._api_key_cache = api_key
+            return api_key
+        except Exception as e:
+            raise Exception(f"Failed to get activation key: {e}")
+
+    def build_headers(self, extra: Optional[Dict[str, str]] = None) -> Dict[str, str]:
+        """Build headers with API authorization"""
+        api_key = self.get_api_key()
+        
+        agent = LitAgent()
+        fp = agent.generate_fingerprint("chrome")
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+            "accept": "application/json",
+            "accept-language": fp["accept_language"],
+            "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": "cross-site",
+        }
+        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 = 120,
+        image_format: str = "png",
+        enhance: bool = True,
+        steps: int = 20,
+        seed: Optional[int] = None,
+        **kwargs,
+    ) -> ImageResponse:
+        """
+        Create images using Together.xyz image models
+        
+        Args:
+            model: Image model to use (defaults to first available)
+            prompt: Text description of the image to generate
+            n: Number of images to generate (1-4)
+            size: Image size in format "WIDTHxHEIGHT" 
+            response_format: "url" or "b64_json"
+            timeout: Request timeout in seconds
+            steps: Number of inference steps (1-50)
+            seed: Random seed for reproducible results
+            **kwargs: Additional model-specific parameters
+        """
+        if not prompt:
+            raise ValueError(
+                "Describe the image you want to create (use the 'prompt' property)."
+            )
+
+        # Use provided model or default to first available
+        if not model:
+            model = self._client.AVAILABLE_MODELS[0]
+        elif model not in self._client.AVAILABLE_MODELS:
+            raise ValueError(f"Model '{model}' not available. Choose from: {self._client.AVAILABLE_MODELS}")
+
+        # Parse size
+        if 'x' in size:
+            width, height = map(int, size.split('x'))
+        else:
+            width = height = int(size)
+
+        # Build request body
+        body = {
+            "model": model,
+            "prompt": prompt,
+            "width": width,
+            "height": height,
+            # Clamp steps to 1-4 as required by Together.xyz API
+            "steps": min(max(steps, 1), 4),
+            "n": min(max(n, 1), 4),  # Clamp between 1-4
+        }
+
+        # Add optional parameters
+        if seed is not None:
+            body["seed"] = seed
+            
+        # Add any additional kwargs
+        body.update(kwargs)
+
+        try:
+            resp = self.session.request(
+                "post",
+                f"{self.base_url}/images/generations",
+                json=body,
+                headers=self.build_headers(),
+                timeout=timeout,
+            )
+            
+            data = resp.json()
+            
+            # Check for errors
+            if "error" in data:
+                error_msg = data["error"].get("message", str(data["error"]))
+                raise RuntimeError(f"Together.xyz API error: {error_msg}")
+                
+            if not data.get("data") or len(data["data"]) == 0:
+                raise RuntimeError("Failed to process image. No data found.")
+
+            result = data["data"]
+            result_data = []
+            
+            for i, item in enumerate(result):
+                if response_format == "url":
+                    if "url" in item:
+                        result_data.append(ImageData(url=item["url"]))
+                else:  # b64_json
+                    if "b64_json" in item:
+                        result_data.append(ImageData(b64_json=item["b64_json"]))
+            
+            if not result_data:
+                raise RuntimeError("No valid image data found in response")
+                
+            return ImageResponse(data=result_data)
+            
+        except requests.exceptions.Timeout:
+            raise RuntimeError(f"Request timed out after {timeout} seconds. Try reducing image size or steps.")
+        except requests.exceptions.RequestException as e:
+            # Print the response content for debugging if available
+            if hasattr(e, 'response') and e.response is not None:
+                try:
+                    print("[Together.xyz API error details]", e.response.text)
+                except Exception:
+                    pass
+            raise RuntimeError(f"Network error: {str(e)}")
+        except json.JSONDecodeError:
+            raise RuntimeError("Invalid JSON response from Together.xyz API")
+        except Exception as e:
+            raise RuntimeError(f"An error occurred: {str(e)}")
+
+
+class TogetherImage(TTICompatibleProvider):
+    """
+    Together.xyz Text-to-Image provider
+    Updated: 2025-06-02 10:42:41 UTC by OEvortex
+    Supports FLUX and other image generation models
+    """
+    
+    # Image models from Together.xyz API (filtered for image type only)
+    AVAILABLE_MODELS = [
+        "black-forest-labs/FLUX.1-schnell-Free",
+        "black-forest-labs/FLUX.1.1-pro",
+        "black-forest-labs/FLUX.1-pro",
+        "black-forest-labs/FLUX.1-redux",
+        "black-forest-labs/FLUX.1-depth",
+        "black-forest-labs/FLUX.1-canny",
+        "black-forest-labs/FLUX.1-kontext-max",
+        "black-forest-labs/FLUX.1-dev-lora",
+        "black-forest-labs/FLUX.1-schnell",
+        "black-forest-labs/FLUX.1-dev",
+        "black-forest-labs/FLUX.1-kontext-pro",
+    ]
+
+    def __init__(self):
+        self.images = Images(self)
+        self._api_key_cache = None
+
+    @property 
+    def models(self):
+        class _ModelList:
+            def list(inner_self):
+                return TogetherImage.AVAILABLE_MODELS
+                
+        return _ModelList()
+
+    def convert_model_name(self, model: str) -> str:
+        """Convert model alias to full model name"""
+        if model in self.AVAILABLE_MODELS:
+            return model
+        
+        # Default to first available model
+        return self.AVAILABLE_MODELS[0]
+
+    # def fetch_available_models(self) -> List[str]:
+    #     """Fetch current image models from Together.xyz API"""
+    #     try:
+    #         api_key = self.images.get_api_key()
+    #         headers = {
+    #             "Authorization": f"Bearer {api_key}",
+    #             "Accept": "application/json"
+    #         }
+            
+    #         response = requests.get(
+    #             "https://api.together.xyz/v1/models", 
+    #             headers=headers, 
+    #             timeout=30
+    #         )
+    #         response.raise_for_status()
+    #         models_data = response.json()
+            
+    #         # Filter image models
+    #         image_models = []
+    #         for model in models_data:
+    #             if isinstance(model, dict) and model.get("type", "").lower() == "image":
+    #                 image_models.append(model["id"])
+            
+    #         return sorted(image_models)
+        
+    #     except Exception as e:
+    #         return self.AVAILABLE_MODELS
+
+
+if __name__ == "__main__":
+    from rich import print
+    client = TogetherImage()
+    
+    # Test with a sample prompt
+    response = client.images.create(
+        model="black-forest-labs/FLUX.1-schnell-Free",  # Free FLUX model
+        prompt="A majestic dragon flying over a mystical forest, fantasy art, highly detailed",
+        size="1024x1024",
+        n=1,
+        steps=25,
+        response_format="url",
+        timeout=120,
+    )
+    print(response)

webscout/Provider/TTI/utils.py

@@ -1,11 +1,12 @@
+import time
 from typing import List, Optional
 from pydantic import BaseModel, Field
-import time
 
 class ImageData(BaseModel):
     url: Optional[str] = None
     b64_json: Optional[str] = None
 
+
 class ImageResponse(BaseModel):
     created: int = Field(default_factory=lambda: int(time.time()))
     data: List[ImageData]

webscout/Provider/TTS/README.md

@@ -25,6 +25,7 @@ Webscout's TTS Providers offer a versatile and powerful text-to-speech conversio
 6. **StreamElementsTTS**
 7. **SpeechMaTTS**
 8. **SthirTTS**
+9. **FreeTTS**
 ## 🚀 Installation
 
 ```bash

webscout/Provider/TTS/__init__.py

@@ -7,4 +7,5 @@ from .murfai import *
 from .gesserit import *
 from .speechma import *
 from .sthir import *
-from .openai_fm import *
+from .openai_fm import *
+from .freetts import *

webscout/Provider/TTS/freetts.py

@@ -0,0 +1,140 @@
+import os
+import requests
+from datetime import datetime
+from datetime import datetime
+from webscout.Provider.TTS import BaseTTSProvider
+from webscout.litagent import LitAgent
+
+
+class FreeTTS(BaseTTSProvider):
+    """
+    Text-to-speech provider using the FreeTTS API.
+    """
+
+    headers = {
+        "accept": "*/*",
+        "accept-language": "ru-RU,ru;q=0.8",
+        "cache-control": "no-cache",
+        "pragma": "no-cache",
+        "sec-ch-ua": '"Brave";v="137", "Chromium";v="137", "Not/A)Brand";v="24"',
+        "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": LitAgent().random()
+    }
+
+    def __init__(self, lang="ru-RU", timeout: int = 30, proxies: dict = None):
+        """Initializes the FreeTTS TTS client."""
+        super().__init__()
+        self.lang = lang
+        self.url = "https://freetts.ru/api/v1/tts" 
+        self.select_url = "https://freetts.ru/api/v1/select" 
+        self.audio_base_url = "https://freetts.ru" 
+        self.session = requests.Session()
+        self.session.headers.update(self.headers)
+        if proxies:
+            self.session.proxies.update(proxies)
+        self.timeout = timeout
+        self.voices = {}
+        self.load_voices()
+
+    def load_voices(self):
+        """Загружает данные о голосах и приводит их к нужному виду"""
+        try:
+            response = self.session.get(self.select_url, timeout=self.timeout)
+            if response.status_code == 200:
+                data = response.json()
+                voices_data = data["data"]["voice"]
+
+                if isinstance(voices_data, list):
+                    for voice_info in voices_data:
+                        if isinstance(voice_info, dict):
+                            voice_id = voice_info.get("code")
+                            voice_name = voice_info.get("name", voice_id)
+                            if voice_id and voice_id.startswith(self.lang):
+                                self.voices[voice_id] = voice_name
+                else:
+                    print("Error")
+                print("Done")
+            else:
+                print(f"Error HTTP: {response.status_code}")
+        except Exception as e:
+            print(f"Error downloading voice: {e}")
+
+    def get_available_voices(self):
+        """Возвращает все доступные голоса в формате строки"""
+        if not self.voices:
+            return "Error"
+        voices_list = [f"{voice_id}: {name}" for voice_id, name in self.voices.items()]
+        return "\n".join(voices_list)
+
+    def tts(self, text: str, voiceid: str = None) -> str:
+        """
+        Converts text to speech using the FreeTTS API and saves it to a file.
+        Args:
+            text (str): The text to convert to speech
+            voiceid (str): Voice ID to use for TTS (default: first available)
+        Returns:
+            str: Path to the generated audio file (MP3)
+        Raises:
+            AssertionError: If no voices are available
+            requests.RequestException: If there's an error communicating with the API
+            RuntimeError: If there's an error processing the audio
+        """
+        try:
+            if not self.voices:
+                raise RuntimeError(f"No voices available for language '{self.lang}'")
+
+            available_voices = self.get_available_voices()
+            if not available_voices:
+                print(f"There are no available voices for the language '{self.lang}'")
+                return ""
+
+            if voiceid is None:
+                voiceid = next(iter(available_voices.keys()))
+
+            payload = {
+                "text": text,
+                "voiceid": voiceid
+            }
+
+            response = requests.post(self.url, json=payload, headers=self.headers)
+
+            if response.status_code == 200:
+                data = response.json()
+                mp3_path = data.get("data", {}).get("src", "")
+
+                if not mp3_path:
+                    print("The path to the audio file in the response was not found.")
+                    return ""
+
+                mp3_url = self.audio_base_url + mp3_path
+
+                mp3_filename = datetime.now().strftime("%Y_%m_%d_%H_%M_%S") + ".mp3"
+                full_path = os.path.abspath(mp3_filename)
+
+                with requests.get(mp3_url, stream=True) as r:
+                    r.raise_for_status()
+                    with open(mp3_filename, "wb") as f:
+                        for chunk in r.iter_content(chunk_size=1024):
+                            f.write(chunk)
+
+                print(f"File '{mp3_filename}'saved successfully!")
+                return full_path
+
+        except Exception as e:
+            print(e)
+
+if __name__ == "__main__":
+    tts = FreeTTS(lang="ru")
+    available_voices = tts.get_available_voices()
+    print("Available voices:", available_voices)
+
+    text_to_speak = input("\nEnter text: ")
+    voice_id = "ru-RU001" 
+    print("[debug] Generating audio...")
+    audio_file = tts.tts(text=text_to_speak, voiceid=voice_id)
+    print(f"Audio saved to: {audio_file}")