webscout 8.2.8__py3-none-any.whl → 8.3__py3-none-any.whl

webscout/Provider/OPENAI/utils.py

@@ -1,8 +1,11 @@
 from typing import List, Dict, Optional, Any, Union, Literal
-from dataclasses import dataclass, asdict, is_dataclass, field
 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
+)
 
 # --- OpenAI Response Structure Mimics ---
 # Moved here for reusability across different OpenAI-compatible providers
@@ -11,108 +14,65 @@ class ToolCallType(str, Enum):
     """Type of tool call."""
     FUNCTION = "function"
 
-@dataclass
-class BaseModel:
-    """Base class for all models."""
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert the model to a dictionary."""
-        def _convert(obj: Any) -> Any:
-            if is_dataclass(obj):
-                return {k: _convert(v) for k, v in asdict(obj).items() if v is not None}
-            elif isinstance(obj, list):
-                return [_convert(item) for item in obj]
-            elif isinstance(obj, dict):
-                return {k: _convert(v) for k, v in obj.items() if v is not None}
-            elif isinstance(obj, Enum):
-                return obj.value
-            return obj
-        return _convert(self)
-
-    def __getitem__(self, key):
-        """Support dictionary-style access."""
-        if hasattr(self, key):
-            return getattr(self, key)
-        raise KeyError(f"{key} not found in {self.__class__.__name__}")
-
-    def get(self, key, default=None):
-        """Dictionary-style get method with default value."""
-        try:
-            return self[key]
-        except KeyError:
-            return default
-
-    def __contains__(self, key):
-        """Support 'in' operator."""
-        return hasattr(self, key)
-
-@dataclass
 class FunctionCall(BaseModel):
     """Function call specification."""
-    name: str
-    arguments: str
+    name: StrictStr
+    arguments: StrictStr
 
-@dataclass
 class ToolFunction(BaseModel):
     """Function specification in a tool."""
-    name: str
-    arguments: str
+    name: StrictStr
+    arguments: StrictStr
 
-@dataclass
 class ToolCall(BaseModel):
     """Tool call specification."""
-    id: str
-    type: str
+    id: StrictStr
+    type: StrictStr
     function: ToolFunction
 
-@dataclass
 class CompletionUsage(BaseModel):
     """Token usage information."""
-    prompt_tokens: int
-    completion_tokens: int
-    total_tokens: int
+    prompt_tokens: StrictInt
+    completion_tokens: StrictInt
+    total_tokens: StrictInt
     prompt_tokens_details: Optional[Dict[str, Any]] = None
 
-@dataclass
 class ChoiceDelta(BaseModel):
     """Delta content in streaming response."""
-    content: Optional[str] = None
+    content: Optional[StrictStr] = None
     function_call: Optional[FunctionCall] = None
-    role: Optional[str] = None
+    role: Optional[StrictStr] = None
     tool_calls: Optional[List[ToolCall]] = None
 
-@dataclass
 class ChatCompletionMessage(BaseModel):
     """Chat message in completion response."""
-    role: str
-    content: Optional[str] = None
+    role: StrictStr
+    content: Optional[StrictStr] = None
     function_call: Optional[FunctionCall] = None
     tool_calls: Optional[List[ToolCall]] = None
 
-@dataclass
 class Choice(BaseModel):
     """Choice in completion response."""
-    index: int
+    index: StrictInt
     message: Optional[ChatCompletionMessage] = None
     delta: Optional[ChoiceDelta] = None
-    finish_reason: Optional[str] = None
+    finish_reason: Optional[StrictStr] = None
     logprobs: Optional[Dict[str, Any]] = None
 
-@dataclass
 class ModelData(BaseModel):
     """OpenAI model info response."""
-    id: str
-    object: str = "model"
-    created: int = int(time.time())
-    owned_by: str = "webscout"
+    id: StrictStr
+    object: StrictStr = "model"
+    created: StrictInt = int(time.time())
+    owned_by: StrictStr = "webscout"
     permission: Optional[List[Dict[str, Any]]] = None
-    root: Optional[str] = None
-    parent: Optional[str] = None
+    root: Optional[StrictStr] = None
+    parent: Optional[StrictStr] = None
 
-@dataclass
 class ModelList(BaseModel):
     """OpenAI model list response."""
-    data: List[ModelData] # Moved before 'object'
-    object: str = "list"
+    data: List[ModelData]
+    object: StrictStr = "list"
 
 
 # @dataclass
@@ -191,26 +151,25 @@ class ModelList(BaseModel):
 #     data: List[ImageData]
 #     created: int = int(time.time())
 
-@dataclass
 class ChatCompletion(BaseModel):
     """Chat completion response."""
-    model: str
+    model: StrictStr
     choices: List[Choice]
-    id: str = field(default_factory=lambda: f"chatcmpl-{str(uuid.uuid4())}")
-    created: int = field(default_factory=lambda: int(time.time()))
-    object: str = "chat.completion"
-    system_fingerprint: Optional[str] = None
+    id: StrictStr = Field(default_factory=lambda: f"chatcmpl-{str(uuid.uuid4())}")
+    created: StrictInt = Field(default_factory=lambda: int(time.time()))
+    object: StrictStr = "chat.completion"
+    system_fingerprint: Optional[StrictStr] = None
     usage: Optional[CompletionUsage] = None
 
-@dataclass
 class ChatCompletionChunk(BaseModel):
     """Streaming chat completion response chunk."""
-    model: str
+    model: StrictStr
     choices: List[Choice]
-    id: str = field(default_factory=lambda: f"chatcmpl-{str(uuid.uuid4())}")
-    created: int = field(default_factory=lambda: int(time.time()))
-    object: str = "chat.completion.chunk"
-    system_fingerprint: Optional[str] = None
+    id: StrictStr = Field(default_factory=lambda: f"chatcmpl-{str(uuid.uuid4())}")
+    created: StrictInt = Field(default_factory=lambda: int(time.time()))
+    object: StrictStr = "chat.completion.chunk"
+    system_fingerprint: Optional[StrictStr] = None
+    usage: Optional[Dict[str, Any]] = None  # Add usage field for streaming chunks
 
 
 # --- Helper Functions ---
@@ -305,3 +264,55 @@ def get_last_user_message(messages: List[Dict[str, Any]]) -> str:
                         text_parts.append(part)
                 return "".join(text_parts)
     return ""
+
+
+# --- Token Counter ---
+
+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.
+
+    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