webscout 8.3.6__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/TTS/__init__.py

@@ -1,10 +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 .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

webscout/Provider/TeachAnything.py

@@ -15,6 +15,7 @@ class TeachAnything(Provider):
     """
     # Add AVAILABLE_MODELS if applicable, otherwise remove model param
     # AVAILABLE_MODELS = ["default"] # Example
+    required_auth = False
 
     def __init__(
         self,

webscout/Provider/TextPollinationsAI.py

@@ -14,30 +14,23 @@ class TextPollinationsAI(Provider):
     A class to interact with the Pollinations AI API.
     """
 
+    required_auth = False
     AVAILABLE_MODELS = [
         "deepseek-reasoning",
-        "glm",
-        "gpt-5-nano",
-        "llama-fast-roblox",
-        "llama-roblox",
-        "llamascout",
+        "gemini",
         "mistral",
-        "mistral-nemo-roblox",
-        "mistral-roblox",
         "nova-fast",
         "openai",
         "openai-audio",
         "openai-fast",
-        "openai-large",
-        "openai-roblox",
+        "openai-reasoning",
         "qwen-coder",
+        "roblox-rp",
         "bidara",
         "evil",
-        "hypnosis-tracy",
         "midijourney",
         "mirexa",
         "rtist",
-        "sur",
         "unity",
     ]
     _models_url = "https://text.pollinations.ai/models"
@@ -315,4 +308,4 @@ if __name__ == "__main__":
             #      print(f"\r{model:<50} {'✗ (Non-Stream)':<10} Empty non-stream response")
 
         except Exception as e:
-            print(f"\r{model:<50} {'✗':<10} {str(e)}")
+            print(f"\r{model:<50} {'✗':<10} {str(e)}")