webscout 8.3.5__py3-none-any.whl → 8.3.7__py3-none-any.whl

webscout/Provider/QwenLM.py

@@ -1,7 +1,9 @@
 import json
 from typing import Union, Any, Dict, Generator, Optional
+import uuid
+import time
 
-import cloudscraper
+from curl_cffi import Session
 
 from webscout.AIutel import Optimizers, Conversation, AwesomePrompts
 from webscout.AIbase import Provider
@@ -11,17 +13,24 @@ class QwenLM(Provider):
     """
     A class to interact with the QwenLM API
     """
-
+    required_auth = True
     AVAILABLE_MODELS = [
+        "qwen-plus-2025-09-11",
+        "qwen3-max-preview",
+        "qwen3-235b-a22b",
+        "qwen3-coder-plus",
+        "qwen3-30b-a3b",
+        "qwen3-coder-30b-a3b-instruct",
         "qwen-max-latest",
-        "qwen-plus-latest",
-        "qwen2.5-14b-instruct-1m",
+        "qwen-plus-2025-01-25",
         "qwq-32b",
+        "qwen-turbo-2025-02-11",
+        "qwen2.5-omni-7b",
+        "qvq-72b-preview-0310",
+        "qwen2.5-vl-32b-instruct",
+        "qwen2.5-14b-instruct-1m",
         "qwen2.5-coder-32b-instruct",
-        "qwen-turbo-latest",
-        "qwen2.5-72b-instruct",
-        "qwen2.5-vl-72b-instruct",
-        "qvq-72b-preview"
+        "qwen2.5-72b-instruct"
     ]
 
     def __init__(
@@ -36,7 +45,7 @@ class QwenLM(Provider):
         proxies: dict = {},
         history_offset: int = 10250,
         act: Optional[str] = None,
-        model: str = "qwen-plus-latest",
+        model: str = "qwen-plus-2025-09-11",
         system_prompt: str = "You are a helpful AI assistant."
     ):
         """Initializes the QwenLM API client."""
@@ -45,36 +54,38 @@ class QwenLM(Provider):
                 f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}"
             )
 
-        self.session = cloudscraper.create_scraper()
+        self.session = Session(impersonate="chrome")
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
-        self.api_endpoint = "https://chat.qwenlm.ai/api/chat/completions"
+        self.api_endpoint = "https://chat.qwen.ai/api/chat/completions"
         self.stream_chunk_size = 64
         self.timeout = timeout
         self.last_response = {}
         self.model = model
         self.system_prompt = system_prompt
         self.cookies_path = cookies_path
-        self.cookie_string, self.token = self._load_cookies()
+        self.cookies_dict, self.token = self._load_cookies()
+        self.chat_id = str(uuid.uuid4())
 
         self.headers = {
-            "accept": "*/*",
-            "accept-language": "en-US,en;q=0.9",
-            "content-type": "application/json",
-            "origin": "https://chat.qwenlm.ai",
-            "referer": "https://chat.qwenlm.ai/",
-            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36 Edg/127.0.0.0",
+            "Accept": "*/*",
+            "Accept-Language": "en-US,en;q=0.9",
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+            "DNT": "1",
+            "Origin": "https://chat.qwen.ai",
+            "Pragma": "no-cache",
+            "Referer": f"https://chat.qwen.ai/c/{self.chat_id}",
+            "Sec-Fetch-Dest": "empty",
+            "Sec-Fetch-Mode": "cors",
+            "Sec-Fetch-Site": "same-origin",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
             "authorization": f"Bearer {self.token}" if self.token else '',
         }
         self.session.headers.update(self.headers)
+        self.session.cookies.update(self.cookies_dict)
         self.session.proxies = proxies
         self.chat_type = "t2t"  # search - used WEB, t2t - chatbot, t2i - image_gen
-        if self.chat_type != "t2t":
-            AVAILABLE_MODELS = [
-                'qwen-plus-latest', 'qvq-72b-preview',
-                'qvq-32b', 'qwen-turbo-latest',
-                'qwen-max-latest'
-            ]
 
         self.__available_optimizers = (
             method
@@ -94,19 +105,14 @@ class QwenLM(Provider):
         )
         self.conversation.history_offset = history_offset
 
-    def _load_cookies(self) -> tuple[str, str]:
-        """Load cookies from a JSON file and build a cookie header string."""
+    def _load_cookies(self) -> tuple[dict, str]:
+        """Load cookies from a JSON file and build a cookie dict."""
         try:
             with open(self.cookies_path, "r") as f:
                 cookies = json.load(f)
-            cookie_string = "; ".join(
-                f"{cookie['name']}={cookie['value']}" for cookie in cookies
-            )
-            token = next(
-                (cookie.get("value") for cookie in cookies if cookie.get("name") == "token"),
-                "",
-            )
-            return cookie_string, token
+            cookies_dict = {cookie['name']: cookie['value'] for cookie in cookies}
+            token = cookies_dict.get("token", "")
+            return cookies_dict, token
         except FileNotFoundError:
             raise exceptions.InvalidAuthenticationError(
                 "Error: cookies.json file not found!"
@@ -138,14 +144,22 @@ class QwenLM(Provider):
                 )
 
         payload = {
-            'chat_type': self.chat_type,
+            'stream': stream,
+            'incremental_output': False,
+            "chat_type": "t2t",
+            "model": self.model,
             "messages": [
-                {"role": "system", "content": self.system_prompt},
-                {"role": "user", "content": conversation_prompt}
+                {
+                    "role": "user",
+                    "content": conversation_prompt,
+                    "chat_type": "t2t",
+                    "extra": {},
+                    "feature_config": {"thinking_enabled": False},
+                }
             ],
-            "model": self.model,
-            "stream": stream,
-            "max_tokens": self.max_tokens_to_sample
+            "session_id": str(uuid.uuid4()),
+            "chat_id": str(uuid.uuid4()),
+            "id": str(uuid.uuid4()),
         }
 
         def for_stream() -> Generator[Dict[str, Any], None, None]:
@@ -158,34 +172,29 @@ class QwenLM(Provider):
                 )
 
             cumulative_text = ""
-            for line in response.iter_lines(decode_unicode=True):
-                if line and line.startswith("data: "):
-                    data = line[6:]
-                    if data == "[DONE]":
-                        break
-                    try:
-                        json_data = json.loads(data)
-                        # Handle multiple response formats
-                        if "choices" in json_data:
-                            new_content = json_data.get("choices")[0].get("delta", {}).get("content", "")
-                        elif "messages" in json_data:
-                            assistant_msg = next(
-                                (msg for msg in reversed(json_data["messages"]) if msg.get("role") == "assistant"),
-                                {}
-                            )
-                            content_field = assistant_msg.get("content", "")
-                            if isinstance(content_field, list):
-                                new_content = "".join(item.get("text", "") for item in content_field)
-                            else:
-                                new_content = content_field
-                        else:
-                            new_content = ""
-                        delta = new_content[len(cumulative_text):]
-                        cumulative_text = new_content
-                        if delta:
-                            yield delta if raw else {"text": delta}
-                    except json.JSONDecodeError:
-                        continue
+            for line in response.iter_lines(decode_unicode=False):
+                if line:
+                    line = line.decode('utf-8') if isinstance(line, bytes) else line
+                    if line.startswith("data: "):
+                        data = line[6:]
+                        if data == "[DONE]":
+                            break
+                        try:
+                            json_data = json.loads(data)
+                            if "response.created" in json_data:
+                                # Initial response, can ignore or use for chat_id etc.
+                                continue
+                            if "choices" in json_data:
+                                delta = json_data["choices"][0]["delta"]
+                                new_content = delta.get("content", "")
+                                status = delta.get("status", "")
+                                if status == "finished":
+                                    break
+                                cumulative_text += new_content
+                                if new_content:
+                                    yield delta if raw else {"text": new_content}
+                        except json.JSONDecodeError:
+                            continue
             self.last_response.update(dict(text=cumulative_text))
             self.conversation.update_chat_history(
                 prompt, self.get_message(self.last_response)
@@ -193,29 +202,35 @@ class QwenLM(Provider):
 
         def for_non_stream() -> Dict[str, Any]:
             """
-            Handles non-streaming responses by aggregating all streamed chunks into a single string.
+            Handles non-streaming responses by making a non-streaming request.
             """
 
-            # Initialize an empty string to accumulate the full response
-            full_response = ""
+            # Create a non-streaming payload
+            non_stream_payload = payload.copy()
+            non_stream_payload['stream'] = False
+            non_stream_payload['incremental_output'] = False
 
-            # Iterate through the stream generator and accumulate the text
-            try:
-                for response in self.ask(prompt, True, optimizer=optimizer, conversationally=conversationally):
-                    if isinstance(response, dict):  # Check if the response is a dictionary
-                        full_response += response.get("text", "")  # Extract and append the "text" field
-                    elif isinstance(response, str):  # If the response is a string, directly append it
-                        full_response += response
-            except Exception as e:
-                raise
+            response = self.session.post(
+                self.api_endpoint, json=non_stream_payload, headers=self.headers, stream=False, timeout=self.timeout
+            )
+            if not response.ok:
+                raise exceptions.FailedToGenerateResponseError(
+                    f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                )
 
-            # Ensure last_response is updated with the aggregated text
-            self.last_response.update({"text": full_response})
+            result = response.json()
+            assistant_reply = (
+                result.get("choices", [{}])[0]
+                .get("message", {})
+                .get("content", "")
+            )
 
-            # Update conversation history with the final response
-            self.conversation.update_chat_history(prompt, self.get_message(self.last_response))
+            self.last_response.update({"text": assistant_reply})
+            self.conversation.update_chat_history(
+                prompt, self.get_message(self.last_response)
+            )
 
-            return {"text": full_response}  # Return the dictionary containing the full response
+            return {"text": assistant_reply}
 
         return for_stream() if stream else for_non_stream()
 
@@ -246,9 +261,12 @@ class QwenLM(Provider):
 
 if __name__ == "__main__":
     from rich import print
-    ai = QwenLM(cookies_path="cookies.json")
-    response = ai.chat(input(">>> "), stream=False)
-    ai.chat_type = "search" # search - used WEB, t2t - chatbot, t2i - image_gen
-    print(response)
+    cookies_path = r"C:\Users\koula\Desktop\Webscout\cookies.json"
+    for model in QwenLM.AVAILABLE_MODELS:
+        ai = QwenLM(cookies_path=cookies_path, model=model)
+        response = ai.chat("hi")
+        print(f"Model: {model}")
+        print(response)
+        print("-" * 50)
     # for chunk in response:
     #     print(chunk, end="", flush=True)

webscout/Provider/STT/__init__.py

@@ -1,3 +1,18 @@
 # This file marks the directory as a Python package.
-from .base import *
-from .elevenlabs import *
+
+import os
+import importlib
+from pathlib import Path
+
+# Get current directory
+current_dir = Path(__file__).parent
+
+# Auto-import all .py files (except __init__.py)
+for file_path in current_dir.glob("*.py"):
+    if file_path.name != "__init__.py":
+        module_name = file_path.stem
+        try:
+            module = importlib.import_module(f".{module_name}", package=__name__)
+            globals().update(vars(module))
+        except ImportError:
+            pass  # Skip files that can't be imported

webscout/Provider/{Llama3.py → Sambanova.py}

@@ -13,19 +13,18 @@ class Sambanova(Provider):
     """
     A class to interact with the Sambanova API.
     """
-
+    required_auth = True
     AVAILABLE_MODELS = [
-        "Meta-Llama-3.1-8B-Instruct",
-        "Meta-Llama-3.1-70B-Instruct",
-        "Meta-Llama-3.1-405B-Instruct",
+        "DeepSeek-R1-0528",
         "DeepSeek-R1-Distill-Llama-70B",
-        "Llama-3.1-Tulu-3-405B",
-        "Meta-Llama-3.2-1B-Instruct",
-        "Meta-Llama-3.2-3B-Instruct",
+        "DeepSeek-V3.1",
+        "gpt-oss-120b",
+        "Qwen3-32B",
+        "DeepSeek-V3-0324",
+        "Meta-Llama-3.1-8B-Instruct",
         "Meta-Llama-3.3-70B-Instruct",
-        "Qwen2.5-72B-Instruct",
-        "Qwen2.5-Coder-32B-Instruct",
-        "QwQ-32B-Preview"
+        "Llama-3.3-Swallow-70B-Instruct-v0.4",
+        "Llama-4-Maverick-17B-128E-Instruct"
     ]
 
     def __init__(

webscout/Provider/StandardInput.py

@@ -13,7 +13,7 @@ class StandardInputAI(Provider):
     """
     A class to interact with the Standard Input chat API.
     """
-
+    required_auth = False
     AVAILABLE_MODELS = {
         "standard-quick": "quick",
         "standard-reasoning": "quick",  # Same model but with reasoning enabled

webscout/Provider/TTI/__init__.py

@@ -1,12 +1,18 @@
-from .pollinations import *
-from .piclumen import *
-from .magicstudio import *
-from .pixelmuse import *
-from .aiarta import *
-from .gpt1image import *
-from .imagen import *
-from .together import *
-from .bing import *
-from .infip import *
-from .monochat import *
-from .venice import *
+# This file marks the directory as a Python package.
+
+import os
+import importlib
+from pathlib import Path
+
+# Get current directory
+current_dir = Path(__file__).parent
+
+# Auto-import all .py files (except __init__.py)
+for file_path in current_dir.glob("*.py"):
+    if file_path.name != "__init__.py":
+        module_name = file_path.stem
+        try:
+            module = importlib.import_module(f".{module_name}", package=__name__)
+            globals().update(vars(module))
+        except ImportError:
+            pass  # Skip files that can't be imported

webscout/Provider/TTI/bing.py

@@ -20,7 +20,7 @@ class Images(BaseImages):
     def create(
         self,
         *,
-        model: str = "bing",
+        model: str = "dalle",
         prompt: str,
         n: int = 1,
         size: str = "1024x1024",
@@ -42,10 +42,21 @@ class Images(BaseImages):
         headers = self._client.headers
         images = []
         urls = []
+        
+        # Map model names to Bing model codes
+        model_mapping = {
+            "dalle": "0",
+            "gpt4o": "1",
+        }
+        
+        # Get the appropriate model code
+        model_code = model_mapping.get(model.lower(), "4")
+        
         for _ in range(n):
             data = {
                 "q": prompt,
                 "rt": "4",
+                "mdl": model_code,
                 "FORM": "GENCRE"
             }
             response = session.post(
@@ -221,8 +232,9 @@ class BingImageAI(TTICompatibleProvider):
 
 if __name__ == "__main__":
     from rich import print
-    client = BingImageAI(cookie="1pkdvumH1SEjFkDjFymRYKouIRoXZlh_p5RTfAttx4DaaNOSDyz8qFP2M7LbZ93fbl4f6Xm8fTGwXHNDB648Gom5jfnTU_Iz-VH47l0HTYJDS1sItbBBS-sqSISFgXR62SoqnW5eX5MFht-j2uB1gZ4uDnpR_60fLRTCdW1SIRegDvnBm1TGhRiZsi6wUPyzwFg7-PsXAs3Fq9iV9m-0FEw")
+    client = BingImageAI(cookie="1QyBY4Z1eHBW6fbI25kdM5TrlRGWzn5PFySapCOfvvz04zaounFG660EipVJSOXXvcdeXXLwsWHdDI8bNymucF_QnMHSlY1mc0pPI7e9Ar6o-_7e9Ik5QOe1nkJIe5vz22pibioTqx0IfVKwmVbX22A3bFD7ODaSZalKFr-AuxgAaRVod-giTTry6Ei7RVgisF7BHlkMPPwtCeO234ujgug")
     response = client.images.create(
+        model="gpt4o",
         prompt="A cat riding a bicycle",
         response_format="url",
         n=4,

webscout/Provider/TTI/together.py

@@ -202,24 +202,25 @@ class Images(BaseImages):
 class TogetherImage(TTICompatibleProvider):
     """
     Together.xyz Text-to-Image provider
-    Updated: 2025-06-02 10:42:41 UTC by OEvortex
+    Updated: 2025-08-01 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-pro",
-        "black-forest-labs/FLUX.1.1-pro",
-        "black-forest-labs/FLUX.1-redux",
-        "black-forest-labs/FLUX.1-dev-lora",
-        "black-forest-labs/FLUX.1-schnell",
+        "black-forest-labs/FLUX.1-canny",
         "black-forest-labs/FLUX.1-depth",
-        "black-forest-labs/FLUX.1-kontext-dev",
         "black-forest-labs/FLUX.1-dev",
-        "black-forest-labs/FLUX.1-canny",
+        "black-forest-labs/FLUX.1-dev-lora",
+        "black-forest-labs/FLUX.1-kontext-dev",
         "black-forest-labs/FLUX.1-kontext-max",
+        "black-forest-labs/FLUX.1-kontext-pro",
+        "black-forest-labs/FLUX.1-krea-dev",
+        "black-forest-labs/FLUX.1-pro",
+        "black-forest-labs/FLUX.1-redux",
+        "black-forest-labs/FLUX.1-schnell",
         "black-forest-labs/FLUX.1-schnell-Free",
-        "black-forest-labs/FLUX.1-kontext-pro"
+        "black-forest-labs/FLUX.1.1-pro"
     ]
 
     def __init__(self):

webscout/Provider/TTS/README.md

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

webscout/Provider/TTS/__init__.py

@@ -1,11 +1,18 @@
-from .base import BaseTTSProvider, AsyncBaseTTSProvider
-from .streamElements import *
-from .parler import *
-from .deepgram import *
-from .elevenlabs import *
-from .murfai import *
-from .gesserit import *
-from .speechma import *
-from .sthir import *
-from .openai_fm import *
-from .freetts import *
+# This file marks the directory as a Python package.
+
+import os
+import importlib
+from pathlib import Path
+
+# Get current directory
+current_dir = Path(__file__).parent
+
+# Auto-import all .py files (except __init__.py)
+for file_path in current_dir.glob("*.py"):
+    if file_path.name != "__init__.py":
+        module_name = file_path.stem
+        try:
+            module = importlib.import_module(f".{module_name}", package=__name__)
+            globals().update(vars(module))
+        except ImportError:
+            pass  # Skip files that can't be imported