mistralai 1.10.0__py3-none-any.whl → 1.11.1__py3-none-any.whl

mistralai_gcp/models/systemmessage.py

@@ -1,23 +1,27 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from .textchunk import TextChunk, TextChunkTypedDict
+from .systemmessagecontentchunks import (
+    SystemMessageContentChunks,
+    SystemMessageContentChunksTypedDict,
+)
 from mistralai_gcp.types import BaseModel
 from typing import List, Literal, Optional, Union
 from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
 SystemMessageContentTypedDict = TypeAliasType(
-    "SystemMessageContentTypedDict", Union[str, List[TextChunkTypedDict]]
+    "SystemMessageContentTypedDict",
+    Union[str, List[SystemMessageContentChunksTypedDict]],
 )
 
 
 SystemMessageContent = TypeAliasType(
-    "SystemMessageContent", Union[str, List[TextChunk]]
+    "SystemMessageContent", Union[str, List[SystemMessageContentChunks]]
 )
 
 
-Role = Literal["system"]
+Role = Literal["system",]
 
 
 class SystemMessageTypedDict(TypedDict):

mistralai_gcp/models/systemmessagecontentchunks.py

@@ -0,0 +1,21 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .textchunk import TextChunk, TextChunkTypedDict
+from .thinkchunk import ThinkChunk, ThinkChunkTypedDict
+from mistralai_gcp.utils import get_discriminator
+from pydantic import Discriminator, Tag
+from typing import Union
+from typing_extensions import Annotated, TypeAliasType
+
+
+SystemMessageContentChunksTypedDict = TypeAliasType(
+    "SystemMessageContentChunksTypedDict",
+    Union[TextChunkTypedDict, ThinkChunkTypedDict],
+)
+
+
+SystemMessageContentChunks = Annotated[
+    Union[Annotated[TextChunk, Tag("text")], Annotated[ThinkChunk, Tag("thinking")]],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]

mistralai_gcp/models/textchunk.py

@@ -6,7 +6,7 @@ from typing import Literal, Optional
 from typing_extensions import NotRequired, TypedDict
 
 
-Type = Literal["text"]
+Type = Literal["text",]
 
 
 class TextChunkTypedDict(TypedDict):

mistralai_gcp/models/thinkchunk.py

@@ -0,0 +1,35 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .referencechunk import ReferenceChunk, ReferenceChunkTypedDict
+from .textchunk import TextChunk, TextChunkTypedDict
+from mistralai_gcp.types import BaseModel
+from typing import List, Literal, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
+
+
+ThinkingTypedDict = TypeAliasType(
+    "ThinkingTypedDict", Union[ReferenceChunkTypedDict, TextChunkTypedDict]
+)
+
+
+Thinking = TypeAliasType("Thinking", Union[ReferenceChunk, TextChunk])
+
+
+ThinkChunkType = Literal["thinking",]
+
+
+class ThinkChunkTypedDict(TypedDict):
+    thinking: List[ThinkingTypedDict]
+    closed: NotRequired[bool]
+    r"""Whether the thinking chunk is closed or not. Currently only used for prefixing."""
+    type: NotRequired[ThinkChunkType]
+
+
+class ThinkChunk(BaseModel):
+    thinking: List[Thinking]
+
+    closed: Optional[bool] = None
+    r"""Whether the thinking chunk is closed or not. Currently only used for prefixing."""
+
+    type: Optional[ThinkChunkType] = "thinking"

mistralai_gcp/models/tool.py

@@ -4,10 +4,8 @@ from __future__ import annotations
 from .function import Function, FunctionTypedDict
 from .tooltypes import ToolTypes
 from mistralai_gcp.types import BaseModel
-from mistralai_gcp.utils import validate_open_enum
-from pydantic.functional_validators import PlainValidator
 from typing import Optional
-from typing_extensions import Annotated, NotRequired, TypedDict
+from typing_extensions import NotRequired, TypedDict
 
 
 class ToolTypedDict(TypedDict):
@@ -18,6 +16,4 @@ class ToolTypedDict(TypedDict):
 class Tool(BaseModel):
     function: Function
 
-    type: Annotated[Optional[ToolTypes], PlainValidator(validate_open_enum(False))] = (
-        None
-    )
+    type: Optional[ToolTypes] = None

mistralai_gcp/models/toolcall.py

@@ -4,10 +4,8 @@ from __future__ import annotations
 from .functioncall import FunctionCall, FunctionCallTypedDict
 from .tooltypes import ToolTypes
 from mistralai_gcp.types import BaseModel
-from mistralai_gcp.utils import validate_open_enum
-from pydantic.functional_validators import PlainValidator
 from typing import Optional
-from typing_extensions import Annotated, NotRequired, TypedDict
+from typing_extensions import NotRequired, TypedDict
 
 
 class ToolCallTypedDict(TypedDict):
@@ -22,8 +20,6 @@ class ToolCall(BaseModel):
 
     id: Optional[str] = "null"
 
-    type: Annotated[Optional[ToolTypes], PlainValidator(validate_open_enum(False))] = (
-        None
-    )
+    type: Optional[ToolTypes] = None
 
     index: Optional[int] = 0

mistralai_gcp/models/toolchoice.py

@@ -4,10 +4,8 @@ from __future__ import annotations
 from .functionname import FunctionName, FunctionNameTypedDict
 from .tooltypes import ToolTypes
 from mistralai_gcp.types import BaseModel
-from mistralai_gcp.utils import validate_open_enum
-from pydantic.functional_validators import PlainValidator
 from typing import Optional
-from typing_extensions import Annotated, NotRequired, TypedDict
+from typing_extensions import NotRequired, TypedDict
 
 
 class ToolChoiceTypedDict(TypedDict):
@@ -24,6 +22,4 @@ class ToolChoice(BaseModel):
     function: FunctionName
     r"""this restriction of `Function` is used to select a specific function to call"""
 
-    type: Annotated[Optional[ToolTypes], PlainValidator(validate_open_enum(False))] = (
-        None
-    )
+    type: Optional[ToolTypes] = None

mistralai_gcp/models/toolchoiceenum.py

@@ -4,4 +4,9 @@ from __future__ import annotations
 from typing import Literal
 
 
-ToolChoiceEnum = Literal["auto", "none", "any", "required"]
+ToolChoiceEnum = Literal[
+    "auto",
+    "none",
+    "any",
+    "required",
+]

mistralai_gcp/models/toolmessage.py

@@ -22,7 +22,7 @@ ToolMessageContentTypedDict = TypeAliasType(
 ToolMessageContent = TypeAliasType("ToolMessageContent", Union[str, List[ContentChunk]])
 
 
-ToolMessageRole = Literal["tool"]
+ToolMessageRole = Literal["tool",]
 
 
 class ToolMessageTypedDict(TypedDict):
@@ -51,7 +51,7 @@ class ToolMessage(BaseModel):
 
         m = {}
 
-        for n, f in self.model_fields.items():
+        for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
             serialized.pop(k, None)

mistralai_gcp/models/tooltypes.py

@@ -5,4 +5,4 @@ from mistralai_gcp.types import UnrecognizedStr
 from typing import Literal, Union
 
 
-ToolTypes = Union[Literal["function"], UnrecognizedStr]
+ToolTypes = Union[Literal["function",], UnrecognizedStr]

mistralai_gcp/models/usageinfo.py

@@ -1,19 +1,82 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from mistralai_gcp.types import BaseModel
-from typing_extensions import TypedDict
+from mistralai_gcp.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+import pydantic
+from pydantic import ConfigDict, model_serializer
+from typing import Any, Dict, Optional
+from typing_extensions import NotRequired, TypedDict
 
 
 class UsageInfoTypedDict(TypedDict):
-    prompt_tokens: int
-    completion_tokens: int
-    total_tokens: int
+    prompt_tokens: NotRequired[int]
+    completion_tokens: NotRequired[int]
+    total_tokens: NotRequired[int]
+    prompt_audio_seconds: NotRequired[Nullable[int]]
 
 
 class UsageInfo(BaseModel):
-    prompt_tokens: int
+    model_config = ConfigDict(
+        populate_by_name=True, arbitrary_types_allowed=True, extra="allow"
+    )
+    __pydantic_extra__: Dict[str, Any] = pydantic.Field(init=False)
 
-    completion_tokens: int
+    prompt_tokens: Optional[int] = 0
 
-    total_tokens: int
+    completion_tokens: Optional[int] = 0
+
+    total_tokens: Optional[int] = 0
+
+    prompt_audio_seconds: OptionalNullable[int] = UNSET
+
+    @property
+    def additional_properties(self):
+        return self.__pydantic_extra__
+
+    @additional_properties.setter
+    def additional_properties(self, value):
+        self.__pydantic_extra__ = value  # pyright: ignore[reportIncompatibleVariableOverride]
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "prompt_tokens",
+            "completion_tokens",
+            "total_tokens",
+            "prompt_audio_seconds",
+        ]
+        nullable_fields = ["prompt_audio_seconds"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        for k, v in serialized.items():
+            m[k] = v
+
+        return m

mistralai_gcp/models/usermessage.py

@@ -16,7 +16,7 @@ UserMessageContentTypedDict = TypeAliasType(
 UserMessageContent = TypeAliasType("UserMessageContent", Union[str, List[ContentChunk]])
 
 
-UserMessageRole = Literal["user"]
+UserMessageRole = Literal["user",]
 
 
 class UserMessageTypedDict(TypedDict):
@@ -39,7 +39,7 @@ class UserMessage(BaseModel):
 
         m = {}
 
-        for n, f in self.model_fields.items():
+        for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
             serialized.pop(k, None)

mistralai_gcp/sdk.py

@@ -2,7 +2,7 @@
 
 import json
 import weakref
-from typing import Any, Optional, cast
+from typing import Any, Optional, Union, cast
 
 import google.auth
 import google.auth.credentials
@@ -67,30 +67,32 @@ class MistralGoogleCloud(BaseSDK):
         :param timeout_ms: Optional request timeout applied to each operation in milliseconds
         """
 
+        credentials = None
         if not access_token:
             credentials, loaded_project_id = google.auth.default(
                 scopes=["https://www.googleapis.com/auth/cloud-platform"],
             )
-            credentials.refresh(google.auth.transport.requests.Request())
 
-            if not isinstance(credentials, google.auth.credentials.Credentials):
-                raise models.SDKError(
-                    "credentials must be an instance of google.auth.credentials.Credentials"
-                )
+            # default will already raise a google.auth.exceptions.DefaultCredentialsError if no credentials are found
+            assert isinstance(
+                credentials, google.auth.credentials.Credentials
+            ), "credentials must be an instance of google.auth.credentials.Credentials"
 
+            credentials.refresh(google.auth.transport.requests.Request())
             project_id = project_id or loaded_project_id
 
         if project_id is None:
-            raise models.SDKError("project_id must be provided")
+            raise ValueError("project_id must be provided")
 
         def auth_token() -> str:
             if access_token:
                 return access_token
 
+            assert credentials is not None, "credentials must be initialized"
             credentials.refresh(google.auth.transport.requests.Request())
             token = credentials.token
             if not token:
-                raise models.SDKError("Failed to get token from credentials")
+                raise Exception("Failed to get token from credentials")
             return token
 
         client_supplied = True
@@ -197,7 +199,7 @@ class GoogleCloudBeforeRequestHook(BeforeRequestHook):
 
     def before_request(
         self, hook_ctx, request: httpx.Request
-    ) -> httpx.Request | Exception:
+    ) -> Union[httpx.Request, Exception]:
         # The goal of this function is to template in the region, project and model into the URL path
         # We do this here so that the API remains more user-friendly
         model_id = None
@@ -210,7 +212,7 @@ class GoogleCloudBeforeRequestHook(BeforeRequestHook):
             new_content = json.dumps(parsed).encode("utf-8")
 
         if model_id == "":
-            raise models.SDKError("model must be provided")
+            raise ValueError("model must be provided")
 
         stream = "streamRawPredict" in request.url.path
         specifier = "streamRawPredict" if stream else "rawPredict"

mistralai_gcp/sdkconfiguration.py

@@ -1,6 +1,5 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
-from ._hooks import SDKHooks
 from ._version import (
     __gen_version__,
     __openapi_doc_version__,
@@ -42,9 +41,6 @@ class SDKConfiguration:
     retry_config: OptionalNullable[RetryConfig] = Field(default_factory=lambda: UNSET)
     timeout_ms: Optional[int] = None
 
-    def __post_init__(self):
-        self._hooks = SDKHooks()
-
     def get_server_details(self) -> Tuple[str, Dict[str, str]]:
         if self.server_url is not None and self.server_url:
             return remove_suffix(self.server_url, "/"), {}
@@ -55,6 +51,3 @@ class SDKConfiguration:
             raise ValueError(f'Invalid server "{self.server}"')
 
         return SERVERS[self.server], {}
-
-    def get_hooks(self) -> SDKHooks:
-        return self._hooks

mistralai_gcp/types/basemodel.py

@@ -2,7 +2,8 @@
 
 from pydantic import ConfigDict, model_serializer
 from pydantic import BaseModel as PydanticBaseModel
-from typing import TYPE_CHECKING, Literal, Optional, TypeVar, Union, NewType
+from pydantic_core import core_schema
+from typing import TYPE_CHECKING, Any, Literal, Optional, TypeVar, Union
 from typing_extensions import TypeAliasType, TypeAlias
 
 
@@ -35,5 +36,42 @@ else:
         "OptionalNullable", Union[Optional[Nullable[T]], Unset], type_params=(T,)
     )
 
-UnrecognizedInt = NewType("UnrecognizedInt", int)
-UnrecognizedStr = NewType("UnrecognizedStr", str)
+
+class UnrecognizedStr(str):
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source_type: Any, _handler: Any) -> core_schema.CoreSchema:
+        # Make UnrecognizedStr only work in lax mode, not strict mode
+        # This makes it a "fallback" option when more specific types (like Literals) don't match
+        def validate_lax(v: Any) -> 'UnrecognizedStr':
+            if isinstance(v, cls):
+                return v
+            return cls(str(v))
+
+        # Use lax_or_strict_schema where strict always fails
+        # This forces Pydantic to prefer other union members in strict mode
+        # and only fall back to UnrecognizedStr in lax mode
+        return core_schema.lax_or_strict_schema(
+            lax_schema=core_schema.chain_schema([
+                core_schema.str_schema(),
+                core_schema.no_info_plain_validator_function(validate_lax)
+            ]),
+            strict_schema=core_schema.none_schema(),  # Always fails in strict mode
+        )
+
+
+class UnrecognizedInt(int):
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source_type: Any, _handler: Any) -> core_schema.CoreSchema:
+        # Make UnrecognizedInt only work in lax mode, not strict mode
+        # This makes it a "fallback" option when more specific types (like Literals) don't match
+        def validate_lax(v: Any) -> 'UnrecognizedInt':
+            if isinstance(v, cls):
+                return v
+            return cls(int(v))
+        return core_schema.lax_or_strict_schema(
+            lax_schema=core_schema.chain_schema([
+                core_schema.int_schema(),
+                core_schema.no_info_plain_validator_function(validate_lax)
+            ]),
+            strict_schema=core_schema.none_schema(),  # Always fails in strict mode
+        )

mistralai_gcp/utils/__init__.py

@@ -1,50 +1,56 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
-from .annotations import get_discriminator
-from .enums import OpenEnumMeta
-from .headers import get_headers, get_response_headers
-from .metadata import (
-    FieldMetadata,
-    find_metadata,
-    FormMetadata,
-    HeaderMetadata,
-    MultipartFormMetadata,
-    PathParamMetadata,
-    QueryParamMetadata,
-    RequestMetadata,
-    SecurityMetadata,
-)
-from .queryparams import get_query_params
-from .retries import BackoffStrategy, Retries, retry, retry_async, RetryConfig
-from .requestbodies import serialize_request_body, SerializedRequestBody
-from .security import get_security
-from .serializers import (
-    get_pydantic_model,
-    marshal_json,
-    unmarshal,
-    unmarshal_json,
-    serialize_decimal,
-    serialize_float,
-    serialize_int,
-    stream_to_text,
-    stream_to_text_async,
-    stream_to_bytes,
-    stream_to_bytes_async,
-    validate_const,
-    validate_decimal,
-    validate_float,
-    validate_int,
-    validate_open_enum,
-)
-from .url import generate_url, template_url, remove_suffix
-from .values import (
-    get_global_from_env,
-    match_content_type,
-    match_status_codes,
-    match_response,
-    cast_partial,
-)
-from .logger import Logger, get_body_content, get_default_logger
+from typing import TYPE_CHECKING
+from importlib import import_module
+import builtins
+import sys
+
+if TYPE_CHECKING:
+    from .annotations import get_discriminator
+    from .datetimes import parse_datetime
+    from .enums import OpenEnumMeta
+    from .headers import get_headers, get_response_headers
+    from .metadata import (
+        FieldMetadata,
+        find_metadata,
+        FormMetadata,
+        HeaderMetadata,
+        MultipartFormMetadata,
+        PathParamMetadata,
+        QueryParamMetadata,
+        RequestMetadata,
+        SecurityMetadata,
+    )
+    from .queryparams import get_query_params
+    from .retries import BackoffStrategy, Retries, retry, retry_async, RetryConfig
+    from .requestbodies import serialize_request_body, SerializedRequestBody
+    from .security import get_security
+    from .serializers import (
+        get_pydantic_model,
+        marshal_json,
+        unmarshal,
+        unmarshal_json,
+        serialize_decimal,
+        serialize_float,
+        serialize_int,
+        stream_to_text,
+        stream_to_text_async,
+        stream_to_bytes,
+        stream_to_bytes_async,
+        validate_const,
+        validate_decimal,
+        validate_float,
+        validate_int,
+    )
+    from .url import generate_url, template_url, remove_suffix
+    from .values import (
+        get_global_from_env,
+        match_content_type,
+        match_status_codes,
+        match_response,
+        cast_partial,
+    )
+    from .logger import Logger, get_body_content, get_default_logger
 
 __all__ = [
     "BackoffStrategy",
@@ -55,6 +61,7 @@ __all__ = [
     "get_body_content",
     "get_default_logger",
     "get_discriminator",
+    "parse_datetime",
     "get_global_from_env",
     "get_headers",
     "get_pydantic_model",
@@ -94,6 +101,94 @@ __all__ = [
     "validate_const",
     "validate_float",
     "validate_int",
-    "validate_open_enum",
     "cast_partial",
 ]
+
+_dynamic_imports: dict[str, str] = {
+    "BackoffStrategy": ".retries",
+    "FieldMetadata": ".metadata",
+    "find_metadata": ".metadata",
+    "FormMetadata": ".metadata",
+    "generate_url": ".url",
+    "get_body_content": ".logger",
+    "get_default_logger": ".logger",
+    "get_discriminator": ".annotations",
+    "parse_datetime": ".datetimes",
+    "get_global_from_env": ".values",
+    "get_headers": ".headers",
+    "get_pydantic_model": ".serializers",
+    "get_query_params": ".queryparams",
+    "get_response_headers": ".headers",
+    "get_security": ".security",
+    "HeaderMetadata": ".metadata",
+    "Logger": ".logger",
+    "marshal_json": ".serializers",
+    "match_content_type": ".values",
+    "match_status_codes": ".values",
+    "match_response": ".values",
+    "MultipartFormMetadata": ".metadata",
+    "OpenEnumMeta": ".enums",
+    "PathParamMetadata": ".metadata",
+    "QueryParamMetadata": ".metadata",
+    "remove_suffix": ".url",
+    "Retries": ".retries",
+    "retry": ".retries",
+    "retry_async": ".retries",
+    "RetryConfig": ".retries",
+    "RequestMetadata": ".metadata",
+    "SecurityMetadata": ".metadata",
+    "serialize_decimal": ".serializers",
+    "serialize_float": ".serializers",
+    "serialize_int": ".serializers",
+    "serialize_request_body": ".requestbodies",
+    "SerializedRequestBody": ".requestbodies",
+    "stream_to_text": ".serializers",
+    "stream_to_text_async": ".serializers",
+    "stream_to_bytes": ".serializers",
+    "stream_to_bytes_async": ".serializers",
+    "template_url": ".url",
+    "unmarshal": ".serializers",
+    "unmarshal_json": ".serializers",
+    "validate_decimal": ".serializers",
+    "validate_const": ".serializers",
+    "validate_float": ".serializers",
+    "validate_int": ".serializers",
+    "cast_partial": ".values",
+}
+
+
+def dynamic_import(modname, retries=3):
+    for attempt in range(retries):
+        try:
+            return import_module(modname, __package__)
+        except KeyError:
+            # Clear any half-initialized module and retry
+            sys.modules.pop(modname, None)
+            if attempt == retries - 1:
+                break
+    raise KeyError(f"Failed to import module '{modname}' after {retries} attempts")
+
+
+def __getattr__(attr_name: str) -> object:
+    module_name = _dynamic_imports.get(attr_name)
+    if module_name is None:
+        raise AttributeError(
+            f"no {attr_name} found in _dynamic_imports, module name -> {__name__} "
+        )
+
+    try:
+        module = dynamic_import(module_name)
+        return getattr(module, attr_name)
+    except ImportError as e:
+        raise ImportError(
+            f"Failed to import {attr_name} from {module_name}: {e}"
+        ) from e
+    except AttributeError as e:
+        raise AttributeError(
+            f"Failed to get {attr_name} from {module_name}: {e}"
+        ) from e
+
+
+def __dir__():
+    lazy_attrs = builtins.list(_dynamic_imports.keys())
+    return builtins.sorted(lazy_attrs)