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

webscout/Provider/OPENAI/scirachat.py

@@ -321,36 +321,88 @@ class SciraChat(OpenAICompatibleProvider):
             messages=[{"role": "user", "content": "Hello!"}]
         )
     """
-    # List of model display names for registration (aliases)
-    AVAILABLE_MODELS = [
-        "Grok3-mini (thinking)",
-        "Grok3",
-        "Claude 4 Sonnet",
-        "Claude 4 Sonnet Thinking",
-        "Grok2-Vision (vision)",
-        "GPT4o",
-        "QWQ-32B",
-        "o4-mini",
-        "Gemini 2.5 Flash Thinking",
-        "Gemini 2.5 Pro",
-        "Llama 4 Maverick",
-    ]
-    # Mapping from display name to internal model key
-    MODEL_NAME_MAP = {
-        "Grok3-mini (thinking)": "scira-default",
-        "Grok3": "scira-grok-3",
-        "Claude 4 Sonnet": "scira-anthropic",
-        "Claude 4 Sonnet Thinking": "scira-anthropic-thinking",
-        "Grok2-Vision (vision)": "scira-vision",
-        "GPT4o": "scira-4o",
-        "QWQ-32B": "scira-qwq",
-        "o4-mini": "scira-o4-mini",
-        "Gemini 2.5 Flash Thinking": "scira-google",
-        "Gemini 2.5 Pro": "scira-google-pro",
-        "Llama 4 Maverick": "scira-llama-4",
+    # Model mapping: actual model names to Scira API format
+    MODEL_MAPPING = {
+        "grok-3-mini": "scira-default",
+        "grok-3-mini-fast": "scira-x-fast-mini",
+        "grok-3-fast": "scira-x-fast",
+        "gpt-4.1-nano": "scira-nano",
+        "grok-3": "scira-grok-3",
+        "grok-4": "scira-grok-4",
+        "grok-2-vision-1212": "scira-vision",
+        "grok-2-latest": "scira-g2",
+        "gpt-4o-mini": "scira-4o-mini",
+        "o4-mini-2025-04-16": "scira-o4-mini",
+        "o3": "scira-o3",
+        "qwen/qwen3-32b": "scira-qwen-32b",
+        "qwen3-30b-a3b": "scira-qwen-30b",
+        "deepseek-v3-0324": "scira-deepseek-v3",
+        "claude-3-5-haiku-20241022": "scira-haiku",
+        "mistral-small-latest": "scira-mistral",
+        "gemini-2.5-flash-lite-preview-06-17": "scira-google-lite",
+        "gemini-2.5-flash": "scira-google",
+        "gemini-2.5-pro": "scira-google-pro",
+        "claude-sonnet-4-20250514": "scira-anthropic",
+        "claude-sonnet-4-20250514-thinking": "scira-anthropic-thinking",
+        "claude-4-opus-20250514": "scira-opus",
+        "claude-4-opus-20250514-pro": "scira-opus-pro",
+        "meta-llama/llama-4-maverick-17b-128e-instruct": "scira-llama-4",
     }
+    # Reverse mapping: Scira format to actual model names
+    SCIRA_TO_MODEL = {v: k for k, v in MODEL_MAPPING.items()}
+    # Add special cases for aliases and duplicate mappings
+    SCIRA_TO_MODEL["scira-anthropic-thinking"] = "claude-sonnet-4-20250514"
+    SCIRA_TO_MODEL["scira-opus-pro"] = "claude-4-opus-20250514"
+    SCIRA_TO_MODEL["scira-x-fast"] = "grok-3-fast"
+    SCIRA_TO_MODEL["scira-x-fast-mini"] = "grok-3-mini-fast"
+    SCIRA_TO_MODEL["scira-nano"] = "gpt-4.1-nano"
+    SCIRA_TO_MODEL["scira-qwen-32b"] = "qwen/qwen3-32b"
+    SCIRA_TO_MODEL["scira-qwen-30b"] = "qwen3-30b-a3b"
+    SCIRA_TO_MODEL["scira-deepseek-v3"] = "deepseek-v3-0324"
+    SCIRA_TO_MODEL["scira-grok-4"] = "grok-4"
+    MODEL_MAPPING["claude-4-opus-20250514-pro"] = "scira-opus-pro"
+    # Available models list (actual model names + scira aliases)
+    AVAILABLE_MODELS = list(MODEL_MAPPING.keys()) + list(SCIRA_TO_MODEL.keys())
     # Optional: pretty display names for UI (reverse mapping)
-    MODEL_DISPLAY_NAMES = {v: k for k, v in MODEL_NAME_MAP.items()}
+    MODEL_DISPLAY_NAMES = {v: k for k, v in MODEL_MAPPING.items()}
+
+    @classmethod
+    def _resolve_model(cls, model: str) -> str:
+        """
+        Resolve a model name to its Scira API format.
+
+        Args:
+            model: Either an actual model name or a Scira alias
+
+        Returns:
+            The Scira API format model name
+
+        Raises:
+            ValueError: If the model is not supported
+        """
+        # If it's already a Scira format, return as-is
+        if model in cls.SCIRA_TO_MODEL:
+            return model
+        # If it's an actual model name, convert to Scira format
+        if model in cls.MODEL_MAPPING:
+            return cls.MODEL_MAPPING[model]
+        # Model not found
+        raise ValueError(f"Invalid model: {model}. Choose from: {cls.AVAILABLE_MODELS}")
+
+    def convert_model_name(self, model: str) -> str:
+        """
+        Convert model display names or internal keys to ones supported by SciraChat.
+        Args:
+            model: Model name or alias to convert
+        Returns:
+            SciraChat model name
+        """
+        # Use the new _resolve_model logic
+        try:
+            return self._resolve_model(model)
+        except Exception as e:
+            print(f"Warning: {e} Using 'scira-default' instead.")
+            return "scira-default"
 
     def __init__(
         self, 
@@ -447,25 +499,6 @@ class SciraChat(OpenAICompatibleProvider):
             print(f"Warning: Error formatting text: {e}")
             return text
     
-    def convert_model_name(self, model: str) -> str:
-        """
-        Convert model display names or internal keys to ones supported by SciraChat.
-        
-        Args:
-            model: Model name or alias to convert
-            
-        Returns:
-            SciraChat model name
-        """
-        # If model is a display name (alias), map to internal key
-        if model in self.MODEL_NAME_MAP:
-            return self.MODEL_NAME_MAP[model]
-        # If model is already an internal key, return it if valid
-        if model in self.MODEL_DISPLAY_NAMES:
-            return model
-        # Default to scira-default if model not found
-        print(f"Warning: Unknown model '{model}'. Using 'scira-default' instead.")
-        return "scira-default"
 
     @property
     def models(self):
@@ -478,9 +511,9 @@ class SciraChat(OpenAICompatibleProvider):
 if __name__ == "__main__":
     ai = SciraChat()
     response = ai.chat.completions.create(
-        model="Gemini 2.5 Pro",
+        model="grok-3-mini-fast-latest",
         messages=[
-            {"role": "user", "content": "who is pm of india?"}
+            {"role": "user", "content": "who are u?"}
         ],
         stream=True
     )

webscout/Provider/OPENAI/textpollinations.py

@@ -279,25 +279,26 @@ class TextPollinations(OpenAICompatibleProvider):
         "openai",
         "openai-fast",
         "openai-large",
+        "openai-reasoning",
         "openai-roblox",
-        "qwen-coder",
-        "llama",
+        "openai-audio",
+        "deepseek",
+        "deepseek-reasoning",
+        "grok",
         "llamascout",
         "mistral",
-        "unity",
-        "mirexa",
-        "midijourney",
-        "rtist",
+        "phi",
+        "qwen-coder",
         "searchgpt",
+        "bidara",
+        "elixposearch",
         "evil",
-        "deepseek-reasoning",
-        "phi",
-        "hormoz",
         "hypnosis-tracy",
-        "deepseek",
+        "midijourney",
+        "mirexa",
+        "rtist",
         "sur",
-        "bidara",
-        "openai-audio",
+        "unity",
     ]
 
     def __init__(

webscout/Provider/OPENAI/toolbaz.py

@@ -292,6 +292,7 @@ class Toolbaz(OpenAICompatibleProvider):
     AVAILABLE_MODELS = [
         "gemini-2.5-flash",
         "gemini-2.0-flash-thinking",
+        "sonar",
         "gemini-2.0-flash",
         "gemini-1.5-flash",
         "o3-mini",

webscout/Provider/OPENAI/typegpt.py

@@ -286,12 +286,12 @@ class TypeGPT(OpenAICompatibleProvider):
 
     AVAILABLE_MODELS = [
         # Working Models (based on testing)
-        "gpt-4o-mini-2024-07-18",
+        "gpt-4o-mini",
         "chatgpt-4o-latest",
-        "deepseek-r1",
+        # "deepseek-r1",
         "deepseek-v3",
-        "uncensored-r1",
-        "Image-Generator",
+        # "uncensored-r1",
+        # "Image-Generator",
     ]
 
     def __init__(

webscout/Provider/OPENAI/utils.py

@@ -1,10 +1,9 @@
-from typing import List, Dict, Optional, Any, Union, Literal
+from typing import List, Dict, Optional, Any
 from enum import Enum
 import time
 import uuid
 from webscout.Provider.OPENAI.pydantic_imports import (
-    BaseModel, Field, field_validator, model_validator, field_serializer, model_serializer,
-    StrictStr, StrictInt, StrictFloat, StrictBool
+    BaseModel, Field, StrictStr, StrictInt
 )
 
 # --- OpenAI Response Structure Mimics ---
@@ -270,49 +269,27 @@ def get_last_user_message(messages: List[Dict[str, Any]]) -> str:
 
 def count_tokens(text_or_messages: Any) -> int:
     """
-    Count tokens in a string or a list of messages using tiktoken if available, else fallback to webstoken's WordTokenizer.
+    Count tokens in a string or a list of messages using tiktoken.
 
     Args:
         text_or_messages: A string or a list of messages (string or any type).
-        model: Optional model name for tiktoken encoding.
 
     Returns:
         int: Number of tokens.
     """
-    try:
-        import tiktoken
-        # Use tiktoken if available
-        if isinstance(text_or_messages, str):
-            enc = tiktoken.encoding_for_model("gpt-4o")
-            return len(enc.encode(text_or_messages))
-        elif isinstance(text_or_messages, list):
-            enc = tiktoken.encoding_for_model("gpt-4o")
-            total = 0
-            for m in text_or_messages:
-                # Remove .get('content', '') and treat m as string or convert to string
-                if isinstance(m, str):
-                    total += len(enc.encode(m))
-                else:
-                    total += len(enc.encode(str(m)))
-            return total
-        else:
-            return 0
-    except ImportError:
-        # Fallback to webstoken's WordTokenizer
-        try:
-            from webstoken import WordTokenizer
-        except ImportError:
-            return 0
-        tokenizer = WordTokenizer()
-        if isinstance(text_or_messages, str):
-            return len(tokenizer.tokenize(text_or_messages))
-        elif isinstance(text_or_messages, list):
-            total = 0
-            for m in text_or_messages:
-                if isinstance(m, str):
-                    total += len(tokenizer.tokenize(m))
-                else:
-                    total += len(tokenizer.tokenize(str(m)))
-            return total
-        else:
-            return 0
+    import tiktoken
+    if isinstance(text_or_messages, str):
+        enc = tiktoken.encoding_for_model("gpt-4o")
+        return len(enc.encode(text_or_messages))
+    elif isinstance(text_or_messages, list):
+        enc = tiktoken.encoding_for_model("gpt-4o")
+        total = 0
+        for m in text_or_messages:
+            if isinstance(m, str):
+                total += len(enc.encode(m))
+            else:
+                total += len(enc.encode(str(m)))
+        return total
+    else:
+        return 0
+

webscout/Provider/OPENAI/x0gpt.py

@@ -6,8 +6,8 @@ import json
 from typing import List, Dict, Optional, Union, Generator, Any
 
 # Import base classes and utility structures
-from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
-from .utils import (
+from webscout.Provider.OPENAI.base import OpenAICompatibleProvider, BaseChat, BaseCompletions
+from webscout.Provider.OPENAI.utils import (
     ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
     ChatCompletionMessage, CompletionUsage, count_tokens
 )
@@ -365,3 +365,15 @@ class X0GPT(OpenAICompatibleProvider):
         """
         # X0GPT doesn't actually use model names, but we'll keep this for compatibility
         return model
+
+if __name__ == "__main__":
+    from rich import print
+    client = X0GPT()
+    response = client.chat.completions.create(
+        model="X0GPT",
+        messages=[{"role": "user", "content": "Hello!"}],
+        stream=True
+    )
+
+    for chunk in response:
+        print(chunk, end='', flush=True)

webscout/Provider/OpenGPT.py

@@ -87,7 +87,7 @@ class OpenGPT(Provider):
     def ask(
         self,
         prompt: str,
-        stream: bool = False, # Note: API does not support streaming
+        stream: bool = False, # Note: API does not support streaming natively
         raw: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
@@ -121,38 +121,54 @@ class OpenGPT(Provider):
             "id": self.app_id,
             "userKey": ""  # Assuming userKey is meant to be empty as in the original code
         }
-        
-        # API does not stream, implement non-stream logic directly
+
+        def for_stream():
+            try:
+                response = self.session.post(
+                    "https://open-gpt.app/api/generate",
+                    data=json.dumps(payload),
+                    timeout=self.timeout,
+                    impersonate="chrome110"
+                )
+                response.raise_for_status()
+                response_text = response.text
+                buffer = ""
+                chunk_size = 32
+                for i in range(0, len(response_text), chunk_size):
+                    out = response_text[i:i+chunk_size]
+                    if out.strip():
+                        if raw:
+                            yield out
+                        else:
+                            yield {"text": out}
+                self.last_response = {"text": response_text}
+                self.conversation.update_chat_history(prompt, response_text)
+            except CurlError as e:
+                raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}") from e
+            except Exception as e:
+                err_text = getattr(e, 'response', None) and getattr(e.response, 'text', '')
+                raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e} - {err_text}") from e
+
         def for_non_stream():
             try:
-                # Use curl_cffi session post with impersonate
                 response = self.session.post(
                     "https://open-gpt.app/api/generate",
-                    # headers are set on the session
-                    data=json.dumps(payload), # Keep data as JSON string
+                    data=json.dumps(payload),
                     timeout=self.timeout,
-                    # proxies are set on the session
-                    impersonate="chrome110" # Use a common impersonation profile
+                    impersonate="chrome110"
                 )
-                
-                response.raise_for_status() # Check for HTTP errors
-                
-                # Use response.text which is already decoded
+                response.raise_for_status()
                 response_text = response.text
                 self.last_response = {"text": response_text}
                 self.conversation.update_chat_history(prompt, response_text)
-                
-                # Return dict or raw string based on raw flag
                 return {"raw": response_text} if raw else {"text": response_text}
-                
-            except CurlError as e: # Catch CurlError
+            except CurlError as e:
                 raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}") from e
-            except Exception as e: # Catch other potential exceptions (like HTTPError, JSONDecodeError)
+            except Exception as e:
                 err_text = getattr(e, 'response', None) and getattr(e.response, 'text', '')
                 raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e} - {err_text}") from e
-        
-        # This provider doesn't support streaming, so just return non-stream
-        return for_non_stream()
+
+        return for_stream() if stream else for_non_stream()
 
     def chat(
         self,
@@ -173,21 +189,25 @@ class OpenGPT(Provider):
         Returns:
             A string with the response text.
         """
-        # Since ask() now handles both stream=True/False by returning the full response dict:
-        response_data = self.ask(
-            prompt, 
-            stream=False, # Call ask in non-stream mode internally
-            raw=False, # Ensure ask returns dict with 'text' key
-            optimizer=optimizer, 
-            conversationally=conversationally
-        )
-        # If stream=True was requested, simulate streaming by yielding the full message at once
         if stream:
             def stream_wrapper():
-                yield self.get_message(response_data)  # yield only the text string
+                for part in self.ask(
+                    prompt,
+                    stream=True,
+                    raw=False,
+                    optimizer=optimizer,
+                    conversationally=conversationally
+                ):
+                    yield self.get_message(part) if isinstance(part, dict) else part
             return stream_wrapper()
         else:
-            # If stream=False, return the full message directly
+            response_data = self.ask(
+                prompt,
+                stream=False,
+                raw=False,
+                optimizer=optimizer,
+                conversationally=conversationally
+            )
             return self.get_message(response_data)
 
     def get_message(self, response: dict) -> str:
@@ -206,4 +226,6 @@ class OpenGPT(Provider):
 
 if __name__ == "__main__":
     ai = OpenGPT()
-    print(ai.chat("Hello, how are you?"))
+    response = ai.chat("write me about humans in points", stream=True)
+    for part in response:
+        print(part, end="", flush=True)