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

webscout/Provider/OPENAI/pydantic_imports.py

@@ -0,0 +1,172 @@
+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,
+)

webscout/Provider/OPENAI/scirachat.py

@@ -9,7 +9,7 @@ from typing import List, Dict, Optional, Union, Generator, Any
 from .base import OpenAICompatibleProvider, BaseChat, BaseCompletions
 from .utils import (
     ChatCompletionChunk, ChatCompletion, Choice, ChoiceDelta,
-    ChatCompletionMessage, CompletionUsage, get_system_prompt
+    ChatCompletionMessage, CompletionUsage, get_system_prompt, count_tokens
 )
 
 # Attempt to import LitAgent, fallback if not available
@@ -45,6 +45,8 @@ class Completions(BaseCompletions):
         stream: bool = False,
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
+        timeout: Optional[int] = None,
+        proxies: Optional[Dict[str, str]] = None,
         **kwargs: Any
     ) -> Union[ChatCompletion, Generator[ChatCompletionChunk, None, None]]:
         """
@@ -75,19 +77,20 @@ class Completions(BaseCompletions):
         created_time = int(time.time())
 
         if stream:
-            return self._create_stream(request_id, created_time, model, payload)
+            return self._create_stream(request_id, created_time, model, payload, timeout, proxies)
         else:
-            return self._create_non_stream(request_id, created_time, model, payload)
+            return self._create_non_stream(request_id, created_time, model, payload, timeout, proxies)
 
     def _create_stream(
-        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any]
+        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any], timeout: Optional[int] = None, proxies: Optional[Dict[str, str]] = None
     ) -> Generator[ChatCompletionChunk, None, None]:
         try:
             response = self._client.session.post(
                 self._client.api_endpoint,
                 json=payload,
                 stream=True,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
             
             # Handle non-200 responses
@@ -100,7 +103,8 @@ class Completions(BaseCompletions):
                         self._client.api_endpoint,
                         json=payload,
                         stream=True,
-                        timeout=self._client.timeout
+                        timeout=timeout or self._client.timeout,
+                        proxies=proxies or getattr(self._client, "proxies", None)
                     )
                     if not response.ok:
                         raise IOError(
@@ -118,7 +122,7 @@ class Completions(BaseCompletions):
             total_tokens = 0
             
             # Estimate prompt tokens based on message length
-            prompt_tokens = len(payload.get("messages", [{}])[0].get("content", "").split())
+            prompt_tokens = count_tokens(payload.get("messages", [{}])[0].get("content", ""))
 
             for line in response.iter_lines():
                 if not line:
@@ -135,8 +139,8 @@ class Completions(BaseCompletions):
                         # Format the content (replace escaped newlines)
                         content = self._client.format_text(content)
                         
-                        # Update token counts
-                        completion_tokens += 1
+                        # Update token counts using count_tokens
+                        completion_tokens += count_tokens(content)
                         total_tokens = prompt_tokens + completion_tokens
                         
                         # Create the delta object
@@ -163,8 +167,11 @@ class Completions(BaseCompletions):
                             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 = {
@@ -204,7 +211,10 @@ class Completions(BaseCompletions):
                 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,
@@ -219,13 +229,14 @@ class Completions(BaseCompletions):
             raise IOError(f"SciraChat request failed: {e}") from e
 
     def _create_non_stream(
-        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any]
+        self, request_id: str, created_time: int, model: str, payload: Dict[str, Any], timeout: Optional[int] = None, proxies: Optional[Dict[str, str]] = None
     ) -> ChatCompletion:
         try:
             response = self._client.session.post(
                 self._client.api_endpoint,
                 json=payload,
-                timeout=self._client.timeout
+                timeout=timeout or self._client.timeout,
+                proxies=proxies or getattr(self._client, "proxies", None)
             )
             
             # Handle non-200 responses
@@ -237,7 +248,8 @@ class Completions(BaseCompletions):
                     response = self._client.session.post(
                         self._client.api_endpoint,
                         json=payload,
-                        timeout=self._client.timeout
+                        timeout=timeout or self._client.timeout,
+                        proxies=proxies or getattr(self._client, "proxies", None)
                     )
                     if not response.ok:
                         raise IOError(
@@ -268,8 +280,8 @@ class Completions(BaseCompletions):
             full_response = self._client.format_text(full_response)
             
             # Estimate token counts
-            prompt_tokens = len(payload.get("messages", [{}])[0].get("content", "").split())
-            completion_tokens = len(full_response.split())
+            prompt_tokens = count_tokens(payload.get("messages", [{}])[0].get("content", ""))
+            completion_tokens = count_tokens(full_response)
             total_tokens = prompt_tokens + completion_tokens
             
             # Create the message object