webscout 8.2.2__py3-none-any.whl → 2026.1.19__py3-none-any.whl

webscout/Provider/OPENAI/wisecat.py

@@ -1,39 +1,35 @@
+import re
 import time
 import uuid
-import requests
-import re
-import json
-from typing import List, Dict, Optional, Union, Generator, Any
+from typing import Any, Dict, Generator, List, Optional, Union, cast
+
+from curl_cffi.requests import Session
 
 # Import base classes and utility structures
-from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
-from .utils import (
-    ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
-    ChatCompletionMessage, CompletionUsage
+from webscout.Provider.OPENAI.base import (
+    BaseChat,
+    BaseCompletions,
+    OpenAICompatibleProvider,
+    SimpleModelList,
+)
+from webscout.Provider.OPENAI.utils import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ChatCompletionMessage,
+    Choice,
+    ChoiceDelta,
+    CompletionUsage,
+    count_tokens,
 )
 
 # Attempt to import LitAgent, fallback if not available
-try:
-    from webscout.litagent import LitAgent
-except ImportError:
-    # Define a dummy LitAgent if webscout is not installed or accessible
-    class LitAgent:
-        def generate_fingerprint(self, browser: str = "chrome") -> Dict[str, Any]:
-            # Return minimal default headers if LitAgent is unavailable
-            print("Warning: LitAgent not found. Using default minimal headers.")
-            return {
-                "accept": "*/*",
-                "accept_language": "en-US,en;q=0.9",
-                "platform": "Windows",
-                "sec_ch_ua": '"Not/A)Brand";v="99", "Google Chrome";v="127", "Chromium";v="127"',
-                "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",
-                "browser_type": browser,
-            }
+from ...litagent import LitAgent
 
 # --- WiseCat Client ---
 
+
 class Completions(BaseCompletions):
-    def __init__(self, client: 'WiseCat'):
+    def __init__(self, client: "WiseCat"):
         self._client = client
 
     def create(
@@ -45,7 +41,7 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
-        **kwargs: Any
+        **kwargs: Any,
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
         Creates a model response for the given chat conversation.
@@ -55,7 +51,7 @@ class Completions(BaseCompletions):
         payload = {
             "id": "ephemeral",
             "messages": messages,
-            "selectedChatModel": self._client.convert_model_name(model)
+            "selectedChatModel": self._client.convert_model_name(model),
         }
 
         # Add optional parameters if provided
@@ -88,11 +84,12 @@ class Completions(BaseCompletions):
                 headers=self._client.headers,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=self._client.timeout,
+                impersonate="chrome120",
             )
 
             # Handle non-200 responses
-            if not response.ok:
+            if response.status_code != 200:
                 raise IOError(
                     f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
                 )
@@ -104,18 +101,18 @@ class Completions(BaseCompletions):
 
             # Estimate prompt tokens based on message length
             for msg in payload.get("messages", []):
-                prompt_tokens += len(msg.get("content", "").split())
+                prompt_tokens += count_tokens(msg.get("content", ""))
 
             for line in response.iter_lines():
                 if line:
-                    decoded_line = line.decode('utf-8').strip()
+                    decoded_line = line.decode("utf-8").strip()
 
                     # WiseCat uses a different format, so we need to extract the content
                     match = re.search(r'0:"(.*?)"', decoded_line)
                     if match:
                         content = match.group(1)
 
-                        # Format the content (replace escaped newlines)
+                        # Format the content (replace escaped newlines and unicode escapes)
                         content = self._client.format_text(content)
 
                         # Update token counts
@@ -123,19 +120,10 @@ class Completions(BaseCompletions):
                         total_tokens = prompt_tokens + completion_tokens
 
                         # Create the delta object
-                        delta = ChoiceDelta(
-                            content=content,
-                            role="assistant",
-                            tool_calls=None
-                        )
+                        delta = ChoiceDelta(content=content, role="assistant", tool_calls=None)
 
                         # Create the choice object
-                        choice = Choice(
-                            index=0,
-                            delta=delta,
-                            finish_reason=None,
-                            logprobs=None
-                        )
+                        choice = Choice(index=0, delta=delta, finish_reason=None, logprobs=None)
 
                         # Create the chunk object
                         chunk = ChatCompletionChunk(
@@ -143,18 +131,21 @@ class Completions(BaseCompletions):
                             choices=[choice],
                             created=created_time,
                             model=model,
-                            system_fingerprint=None
+                            system_fingerprint=None,
                         )
 
-                        # Convert to dict for proper formatting
-                        chunk_dict = chunk.to_dict()
+                        # Convert chunk to dict using Pydantic's API
+                        if hasattr(chunk, "model_dump"):
+                            chunk_dict = chunk.model_dump(exclude_none=True)
+                        else:
+                            chunk_dict = chunk.dict(exclude_none=True)
 
                         # Add usage information to match OpenAI format
                         usage_dict = {
                             "prompt_tokens": prompt_tokens,
                             "completion_tokens": completion_tokens,
                             "total_tokens": total_tokens,
-                            "estimated_cost": None
+                            "estimated_cost": None,
                         }
 
                         chunk_dict["usage"] = usage_dict
@@ -163,33 +154,27 @@ class Completions(BaseCompletions):
                         yield chunk
 
             # Final chunk with finish_reason="stop"
-            delta = ChoiceDelta(
-                content=None,
-                role=None,
-                tool_calls=None
-            )
+            delta = ChoiceDelta(content=None, role=None, tool_calls=None)
 
-            choice = Choice(
-                index=0,
-                delta=delta,
-                finish_reason="stop",
-                logprobs=None
-            )
+            choice = Choice(index=0, delta=delta, finish_reason="stop", logprobs=None)
 
             chunk = ChatCompletionChunk(
                 id=request_id,
                 choices=[choice],
                 created=created_time,
                 model=model,
-                system_fingerprint=None
+                system_fingerprint=None,
             )
 
-            chunk_dict = chunk.to_dict()
+            if hasattr(chunk, "model_dump"):
+                chunk_dict = chunk.model_dump(exclude_none=True)
+            else:
+                chunk_dict = chunk.dict(exclude_none=True)
             chunk_dict["usage"] = {
                 "prompt_tokens": prompt_tokens,
                 "completion_tokens": completion_tokens,
                 "total_tokens": total_tokens,
-                "estimated_cost": None
+                "estimated_cost": None,
             }
 
             yield chunk
@@ -208,20 +193,22 @@ class Completions(BaseCompletions):
                 headers=self._client.headers,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=self._client.timeout,
+                impersonate="chrome120",
             )
 
             # Handle non-200 responses
-            if not response.ok:
+            if response.status_code != 200:
                 raise IOError(
                     f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
                 )
 
             # Collect the full response
             full_text = ""
-            for line in response.iter_lines(decode_unicode=True):
+            for line in response.iter_lines():
                 if line:
-                    match = re.search(r'0:"(.*?)"', line)
+                    decoded_line = line.decode("utf-8").strip()
+                    match = re.search(r'0:"(.*?)"', decoded_line)
                     if match:
                         content = match.group(1)
                         full_text += content
@@ -232,29 +219,22 @@ class Completions(BaseCompletions):
             # Estimate token counts
             prompt_tokens = 0
             for msg in payload.get("messages", []):
-                prompt_tokens += len(msg.get("content", "").split())
+                prompt_tokens += count_tokens(msg.get("content", ""))
 
-            completion_tokens = len(full_text.split())
+            completion_tokens = count_tokens(full_text)
             total_tokens = prompt_tokens + completion_tokens
 
             # Create the message object
-            message = ChatCompletionMessage(
-                role="assistant",
-                content=full_text
-            )
+            message = ChatCompletionMessage(role="assistant", content=full_text)
 
             # Create the choice object
-            choice = Choice(
-                index=0,
-                message=message,
-                finish_reason="stop"
-            )
+            choice = Choice(index=0, message=message, finish_reason="stop")
 
             # Create the usage object
             usage = CompletionUsage(
                 prompt_tokens=prompt_tokens,
                 completion_tokens=completion_tokens,
-                total_tokens=total_tokens
+                total_tokens=total_tokens,
             )
 
             # Create the completion object
@@ -272,10 +252,12 @@ class Completions(BaseCompletions):
             print(f"Error during WiseCat non-stream request: {e}")
             raise IOError(f"WiseCat request failed: {e}") from e
 
+
 class Chat(BaseChat):
-    def __init__(self, client: 'WiseCat'):
+    def __init__(self, client: "WiseCat"):
         self.completions = Completions(client)
 
+
 class WiseCat(OpenAICompatibleProvider):
     """
     OpenAI-compatible client for WiseCat API.
@@ -288,19 +270,14 @@ class WiseCat(OpenAICompatibleProvider):
         )
     """
 
-    AVAILABLE_MODELS = [
-        "chat-model-small",
-        "chat-model-large",
-        "chat-model-reasoning",
-    ]
+    required_auth = False
+    _base_models = ["chat-model-small", "chat-model-large", "chat-model-reasoning"]
+    # Create AVAILABLE_MODELS as a list with the format "WiseCat/model"
+    AVAILABLE_MODELS = [f"WiseCat/{model}" for model in _base_models]
+    # Create a mapping dictionary for internal use
+    _model_mapping = {model: f"WiseCat/{model}" for model in _base_models}
 
-    # No model mapping needed as we use the model names directly
-
-    def __init__(
-        self,
-        timeout: Optional[int] = None,
-        browser: str = "chrome"
-    ):
+    def __init__(self, timeout: Optional[int] = None, browser: str = "chrome"):
         """
         Initialize the WiseCat client.
 
@@ -310,7 +287,7 @@ class WiseCat(OpenAICompatibleProvider):
         """
         self.timeout = timeout
         self.api_endpoint = "https://wise-cat-groq.vercel.app/api/chat"
-        self.session = requests.Session()
+        self.session = Session()
 
         # Initialize LitAgent for user agent generation
         agent = LitAgent()
@@ -334,29 +311,16 @@ class WiseCat(OpenAICompatibleProvider):
         Returns:
             Formatted text
         """
-        # Use a more comprehensive approach to handle all escape sequences
         try:
-            # First handle double backslashes to avoid issues
-            text = text.replace('\\\\', '\\')
-
-            # Handle common escape sequences
-            text = text.replace('\\n', '\n')
-            text = text.replace('\\r', '\r')
-            text = text.replace('\\t', '\t')
-            text = text.replace('\\"', '"')
-            text = text.replace("\\'", "'")
-
-            # Handle any remaining escape sequences using JSON decoding
-            # This is a fallback in case there are other escape sequences
-            try:
-                # Add quotes to make it a valid JSON string
-                json_str = f'"{text}"'
-                # Use json module to decode all escape sequences
-                decoded = json.loads(json_str)
-                return decoded
-            except json.JSONDecodeError:
-                # If JSON decoding fails, return the text with the replacements we've already done
-                return text
+            # Handle unicode escaping and quote unescaping
+            text = text.encode().decode("unicode_escape")
+            text = text.replace("\\\\", "\\").replace('\\"', '"')
+
+            # Remove timing information
+            text = re.sub(r"\(\d+\.?\d*s\)", "", text)
+            text = re.sub(r"\(\d+\.?\d*ms\)", "", text)
+
+            return text
         except Exception as e:
             # If any error occurs, return the original text
             print(f"Warning: Error formatting text: {e}")
@@ -364,18 +328,32 @@ class WiseCat(OpenAICompatibleProvider):
 
     def convert_model_name(self, model: str) -> str:
         """
-        Convert model names to ones supported by WiseCat.
-
-        Args:
-            model: Model name to convert
-
-        Returns:
-            WiseCat model name
+        Convert model names to ones supported by WiseCat. Accepts both 'WiseCat/model' and raw model names.
         """
-        # If the model is already a valid WiseCat model, return it
-        if model in self.AVAILABLE_MODELS:
-            return model
-
-        # Default to the most capable model
+        if model.startswith("WiseCat/"):
+            model_raw = model.replace("WiseCat/", "", 1)
+        else:
+            model_raw = model
+        if f"WiseCat/{model_raw}" in self.AVAILABLE_MODELS:
+            return model_raw
         print(f"Warning: Unknown model '{model}'. Using 'chat-model-large' instead.")
         return "chat-model-large"
+
+    @property
+    def models(self) -> SimpleModelList:
+        return SimpleModelList(type(self).AVAILABLE_MODELS)
+
+
+if __name__ == "__main__":
+    # Test the provider
+    client = WiseCat()
+    response = client.chat.completions.create(
+        model="chat-model-small",
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": "Hello! How are you today?"},
+        ],
+    )
+    if isinstance(response, ChatCompletion):
+        if response.choices[0].message and response.choices[0].message.content:
+            print(response.choices[0].message.content)