webscout 8.3.1__py3-none-any.whl → 8.3.3__py3-none-any.whl

webscout/Provider/OPENAI/pydantic_imports.py

@@ -1,172 +1 @@
-from pydantic import (
-    # dataclasses
-    dataclasses,
-    # functional validators
-    field_validator,
-    model_validator,
-    AfterValidator,
-    BeforeValidator,
-    PlainValidator,
-    WrapValidator,
-    SkipValidation,
-    InstanceOf,
-    ModelWrapValidatorHandler,
-    # JSON Schema
-    WithJsonSchema,
-    # deprecated V1 functional validators
-    root_validator,
-    validator,
-    # functional serializers
-    field_serializer,
-    model_serializer,
-    PlainSerializer,
-    SerializeAsAny,
-    WrapSerializer,
-    # config
-    ConfigDict,
-    with_config,
-    # deprecated V1 config
-    BaseConfig,
-    Extra,
-    # validate_call
-    validate_call,
-    # errors
-    PydanticErrorCodes,
-    PydanticUserError,
-    PydanticSchemaGenerationError,
-    PydanticImportError,
-    PydanticUndefinedAnnotation,
-    PydanticInvalidForJsonSchema,
-    PydanticForbiddenQualifier,
-    # fields
-    Field,
-    computed_field,
-    PrivateAttr,
-    # alias
-    AliasChoices,
-    AliasGenerator,
-    AliasPath,
-    # main
-    BaseModel,
-    create_model,
-    # network
-    AnyUrl,
-    AnyHttpUrl,
-    FileUrl,
-    HttpUrl,
-    FtpUrl,
-    WebsocketUrl,
-    AnyWebsocketUrl,
-    UrlConstraints,
-    EmailStr,
-    NameEmail,
-    IPvAnyAddress,
-    IPvAnyInterface,
-    IPvAnyNetwork,
-    PostgresDsn,
-    CockroachDsn,
-    AmqpDsn,
-    RedisDsn,
-    MongoDsn,
-    KafkaDsn,
-    NatsDsn,
-    MySQLDsn,
-    MariaDBDsn,
-    ClickHouseDsn,
-    SnowflakeDsn,
-    validate_email,
-    # root_model
-    RootModel,
-    # deprecated tools
-    parse_obj_as,
-    schema_of,
-    schema_json_of,
-    # types
-    Strict,
-    StrictStr,
-    conbytes,
-    conlist,
-    conset,
-    confrozenset,
-    constr,
-    StringConstraints,
-    ImportString,
-    conint,
-    PositiveInt,
-    NegativeInt,
-    NonNegativeInt,
-    NonPositiveInt,
-    confloat,
-    PositiveFloat,
-    NegativeFloat,
-    NonNegativeFloat,
-    NonPositiveFloat,
-    FiniteFloat,
-    condecimal,
-    condate,
-    UUID1,
-    UUID3,
-    UUID4,
-    UUID5,
-    UUID6,
-    UUID7,
-    UUID8,
-    FilePath,
-    DirectoryPath,
-    NewPath,
-    Json,
-    Secret,
-    SecretStr,
-    SecretBytes,
-    SocketPath,
-    StrictBool,
-    StrictBytes,
-    StrictInt,
-    StrictFloat,
-    PaymentCardNumber,
-    ByteSize,
-    PastDate,
-    FutureDate,
-    PastDatetime,
-    FutureDatetime,
-    AwareDatetime,
-    NaiveDatetime,
-    AllowInfNan,
-    EncoderProtocol,
-    EncodedBytes,
-    EncodedStr,
-    Base64Encoder,
-    Base64Bytes,
-    Base64Str,
-    Base64UrlBytes,
-    Base64UrlStr,
-    GetPydanticSchema,
-    Tag,
-    Discriminator,
-    JsonValue,
-    FailFast,
-    # type_adapter
-    TypeAdapter,
-    # version
-    __version__,
-    VERSION,
-    # warnings
-    PydanticDeprecatedSince20,
-    PydanticDeprecatedSince26,
-    PydanticDeprecatedSince29,
-    PydanticDeprecatedSince210,
-    PydanticDeprecatedSince211,
-    PydanticDeprecationWarning,
-    PydanticExperimentalWarning,
-    # annotated handlers
-    GetCoreSchemaHandler,
-    GetJsonSchemaHandler,
-    # pydantic_core
-    ValidationError,
-    ValidationInfo,
-    SerializationInfo,
-    ValidatorFunctionWrapHandler,
-    FieldSerializationInfo,
-    SerializerFunctionWrapHandler,
-    OnErrorOmit,
-)
+from pydantic import *

webscout/Provider/OPENAI/scirachat.py

@@ -6,8 +6,8 @@ import re
 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, get_system_prompt, count_tokens
 )
@@ -16,20 +16,7 @@ from .utils import (
 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,
-            }
-
+    pass
 # --- SciraChat Client ---
 
 class Completions(BaseCompletions):
@@ -334,21 +321,37 @@ class SciraChat(OpenAICompatibleProvider):
             messages=[{"role": "user", "content": "Hello!"}]
         )
     """
-    
-    AVAILABLE_MODELS = {
-        "scira-default": "Grok3-mini", # thinking model
-        "scira-grok-3": "Grok3",
-        "scira-anthropic": "Claude 4 Sonnet",
-        "scira-anthropic-thinking": "Claude 4 Sonnet Thinking", # thinking model
-        "scira-vision" : "Grok2-Vision", # vision model
-        "scira-4o": "GPT4o",
-        "scira-qwq": "QWQ-32B",
-        "scira-o4-mini": "o4-mini",
-        "scira-google": "gemini 2.5 flash Thinking", # thinking model
-        "scira-google-pro": "gemini 2.5 pro",
-        "scira-llama-4": "llama 4 Maverick",
+    # 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",
     }
-    
+    # Optional: pretty display names for UI (reverse mapping)
+    MODEL_DISPLAY_NAMES = {v: k for k, v in MODEL_NAME_MAP.items()}
+
     def __init__(
         self, 
         timeout: Optional[int] = None, 
@@ -371,19 +374,9 @@ class SciraChat(OpenAICompatibleProvider):
         
         # Use the fingerprint for headers
         self.headers = {
-            "Accept": self.fingerprint["accept"],
-            "Accept-Encoding": "gzip, deflate, br, zstd",
-            "Accept-Language": self.fingerprint["accept_language"],
-            "Content-Type": "application/json",
+            **self.fingerprint,
             "Origin": "https://scira.ai",
             "Referer": "https://scira.ai/",
-            "Sec-CH-UA": self.fingerprint["sec_ch_ua"] or '"Not)A;Brand";v="99", "Microsoft Edge";v="127", "Chromium";v="127"',
-            "Sec-CH-UA-Mobile": "?0",
-            "Sec-CH-UA-Platform": f'"{self.fingerprint["platform"]}"',
-            "User-Agent": self.fingerprint["user_agent"],
-            "Sec-Fetch-Dest": "empty",
-            "Sec-Fetch-Mode": "cors",
-            "Sec-Fetch-Site": "same-origin"
         }
         
         self.session.headers.update(self.headers)
@@ -407,11 +400,7 @@ class SciraChat(OpenAICompatibleProvider):
         
         # Update headers with new fingerprint
         self.headers.update({
-            "Accept": self.fingerprint["accept"],
-            "Accept-Language": self.fingerprint["accept_language"],
-            "Sec-CH-UA": self.fingerprint["sec_ch_ua"] or self.headers["Sec-CH-UA"],
-            "Sec-CH-UA-Platform": f'"{self.fingerprint["platform"]}"',
-            "User-Agent": self.fingerprint["user_agent"],
+            **self.fingerprint,
         })
         
         # Update session headers
@@ -460,18 +449,20 @@ class SciraChat(OpenAICompatibleProvider):
     
     def convert_model_name(self, model: str) -> str:
         """
-        Convert model names to ones supported by SciraChat.
+        Convert model display names or internal keys to ones supported by SciraChat.
         
         Args:
-            model: Model name to convert
+            model: Model name or alias to convert
             
         Returns:
             SciraChat model name
         """
-        # If the model is already a valid SciraChat model, return it
-        if model in self.AVAILABLE_MODELS:
+        # 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"
@@ -480,5 +471,22 @@ class SciraChat(OpenAICompatibleProvider):
     def models(self):
         class _ModelList:
             def list(inner_self):
+                # Return display names (aliases)
                 return type(self).AVAILABLE_MODELS
         return _ModelList()
+
+if __name__ == "__main__":
+    ai = SciraChat()
+    response = ai.chat.completions.create(
+        model="Gemini 2.5 Pro",
+        messages=[
+            {"role": "user", "content": "who is pm of india?"}
+        ],
+        stream=True
+    )
+    for chunk in response:
+        if hasattr(chunk, "choices") and chunk.choices and hasattr(chunk.choices[0], "delta"):
+            content = getattr(chunk.choices[0].delta, "content", None)
+            if content:
+                print(content, end="", flush=True)
+    print()

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",
@@ -337,18 +338,11 @@ class Toolbaz(OpenAICompatibleProvider):
         
         # Set up headers
         self.session.headers.update({
-            "user-agent": LitAgent().generate_fingerprint(browser=browser)["user_agent"],
-            "accept": "*/*",
-            "accept-language": "en-US",
-            "cache-control": "no-cache",
-            "connection": "keep-alive",
-            "content-type": "application/x-www-form-urlencoded; charset=UTF-8",
-            "origin": "https://toolbaz.com",
+            **LitAgent().generate_fingerprint(browser=browser),
             "pragma": "no-cache",
             "referer": "https://toolbaz.com/",
-            "sec-fetch-mode": "cors"
         })
-        
+
         # Initialize chat property
         self.chat = Chat(self)
 

webscout/Provider/OPENAI/typegpt.py

@@ -286,7 +286,7 @@ 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-v3",

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)