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

mistralai_azure/models/sdkerror.py

@@ -1,22 +1,40 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
-from dataclasses import dataclass
-from typing import Optional
 import httpx
+from typing import Optional
+from dataclasses import dataclass
+
+from mistralai_azure.models import MistralAzureError
+
+MAX_MESSAGE_LEN = 10_000
+
+
+@dataclass(unsafe_hash=True)
+class SDKError(MistralAzureError):
+    """The fallback error class if no more specific error class is matched."""
+
+    def __init__(
+        self, message: str, raw_response: httpx.Response, body: Optional[str] = None
+    ):
+        body_display = body or raw_response.text or '""'
 
+        if message:
+            message += ": "
+        message += f"Status {raw_response.status_code}"
 
-@dataclass
-class SDKError(Exception):
-    """Represents an error returned by the API."""
+        headers = raw_response.headers
+        content_type = headers.get("content-type", '""')
+        if content_type != "application/json":
+            if " " in content_type:
+                content_type = f'"{content_type}"'
+            message += f" Content-Type {content_type}"
 
-    message: str
-    status_code: int = -1
-    body: str = ""
-    raw_response: Optional[httpx.Response] = None
+        if len(body_display) > MAX_MESSAGE_LEN:
+            truncated = body_display[:MAX_MESSAGE_LEN]
+            remaining = len(body_display) - MAX_MESSAGE_LEN
+            body_display = f"{truncated}...and {remaining} more chars"
 
-    def __str__(self):
-        body = ""
-        if len(self.body) > 0:
-            body = f"\n{self.body}"
+        message += f". Body: {body_display}"
+        message = message.strip()
 
-        return f"{self.message}: Status {self.status_code}{body}"
+        super().__init__(message, raw_response, body)

mistralai_azure/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_azure.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_azure/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_azure.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_azure/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_azure/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_azure.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_azure/models/tool.py

@@ -4,10 +4,8 @@ from __future__ import annotations
 from .function import Function, FunctionTypedDict
 from .tooltypes import ToolTypes
 from mistralai_azure.types import BaseModel
-from mistralai_azure.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_azure/models/toolcall.py

@@ -4,10 +4,8 @@ from __future__ import annotations
 from .functioncall import FunctionCall, FunctionCallTypedDict
 from .tooltypes import ToolTypes
 from mistralai_azure.types import BaseModel
-from mistralai_azure.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_azure/models/toolchoice.py

@@ -4,10 +4,8 @@ from __future__ import annotations
 from .functionname import FunctionName, FunctionNameTypedDict
 from .tooltypes import ToolTypes
 from mistralai_azure.types import BaseModel
-from mistralai_azure.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_azure/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_azure/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):

mistralai_azure/models/tooltypes.py

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

mistralai_azure/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):

mistralai_azure/ocr.py

@@ -4,6 +4,7 @@ from .basesdk import BaseSDK
 from mistralai_azure import models, utils
 from mistralai_azure._hooks import HookContext
 from mistralai_azure.types import Nullable, OptionalNullable, UNSET
+from mistralai_azure.utils.unmarshal_json_response import unmarshal_json_response
 from typing import Any, List, Mapping, Optional, Union
 
 
@@ -24,11 +25,14 @@ class Ocr(BaseSDK):
         document_annotation_format: OptionalNullable[
             Union[models.ResponseFormat, models.ResponseFormatTypedDict]
         ] = UNSET,
+        table_format: OptionalNullable[models.TableFormat] = UNSET,
+        extract_header: Optional[bool] = None,
+        extract_footer: Optional[bool] = None,
         retries: OptionalNullable[utils.RetryConfig] = UNSET,
         server_url: Optional[str] = None,
         timeout_ms: Optional[int] = None,
         http_headers: Optional[Mapping[str, str]] = None,
-    ) -> Optional[models.OCRResponse]:
+    ) -> models.OCRResponse:
         r"""OCR
 
         :param model:
@@ -40,6 +44,9 @@ class Ocr(BaseSDK):
         :param image_min_size: Minimum height and width of image to extract
         :param bbox_annotation_format: Structured output class for extracting useful information from each extracted bounding box / image from document. Only json_schema is valid for this field
         :param document_annotation_format: Structured output class for extracting useful information from the entire document. Only json_schema is valid for this field
+        :param table_format:
+        :param extract_header:
+        :param extract_footer:
         :param retries: Override the default retry configuration for this method
         :param server_url: Override the default server URL for this method
         :param timeout_ms: Override the default request timeout configuration for this method in milliseconds
@@ -69,6 +76,9 @@ class Ocr(BaseSDK):
             document_annotation_format=utils.get_pydantic_model(
                 document_annotation_format, OptionalNullable[models.ResponseFormat]
             ),
+            table_format=table_format,
+            extract_header=extract_header,
+            extract_footer=extract_footer,
         )
 
         req = self._build_request(
@@ -87,6 +97,7 @@ class Ocr(BaseSDK):
             get_serialized_body=lambda: utils.serialize_request_body(
                 request, False, False, "json", models.OCRRequest
             ),
+            allow_empty_value=None,
             timeout_ms=timeout_ms,
         )
 
@@ -103,7 +114,7 @@ class Ocr(BaseSDK):
                 config=self.sdk_configuration,
                 base_url=base_url or "",
                 operation_id="ocr_v1_ocr_post",
-                oauth2_scopes=[],
+                oauth2_scopes=None,
                 security_source=self.sdk_configuration.security,
             ),
             request=req,
@@ -113,31 +124,20 @@ class Ocr(BaseSDK):
 
         response_data: Any = None
         if utils.match_response(http_res, "200", "application/json"):
-            return utils.unmarshal_json(http_res.text, Optional[models.OCRResponse])
+            return unmarshal_json_response(models.OCRResponse, http_res)
         if utils.match_response(http_res, "422", "application/json"):
-            response_data = utils.unmarshal_json(
-                http_res.text, models.HTTPValidationErrorData
+            response_data = unmarshal_json_response(
+                models.HTTPValidationErrorData, http_res
             )
-            raise models.HTTPValidationError(data=response_data)
+            raise models.HTTPValidationError(response_data, http_res)
         if utils.match_response(http_res, "4XX", "*"):
             http_res_text = utils.stream_to_text(http_res)
-            raise models.SDKError(
-                "API error occurred", http_res.status_code, http_res_text, http_res
-            )
+            raise models.SDKError("API error occurred", http_res, http_res_text)
         if utils.match_response(http_res, "5XX", "*"):
             http_res_text = utils.stream_to_text(http_res)
-            raise models.SDKError(
-                "API error occurred", http_res.status_code, http_res_text, http_res
-            )
+            raise models.SDKError("API error occurred", http_res, http_res_text)
 
-        content_type = http_res.headers.get("Content-Type")
-        http_res_text = utils.stream_to_text(http_res)
-        raise models.SDKError(
-            f"Unexpected response received (code: {http_res.status_code}, type: {content_type})",
-            http_res.status_code,
-            http_res_text,
-            http_res,
-        )
+        raise models.SDKError("Unexpected response received", http_res)
 
     async def process_async(
         self,
@@ -155,11 +155,14 @@ class Ocr(BaseSDK):
         document_annotation_format: OptionalNullable[
             Union[models.ResponseFormat, models.ResponseFormatTypedDict]
         ] = UNSET,
+        table_format: OptionalNullable[models.TableFormat] = UNSET,
+        extract_header: Optional[bool] = None,
+        extract_footer: Optional[bool] = None,
         retries: OptionalNullable[utils.RetryConfig] = UNSET,
         server_url: Optional[str] = None,
         timeout_ms: Optional[int] = None,
         http_headers: Optional[Mapping[str, str]] = None,
-    ) -> Optional[models.OCRResponse]:
+    ) -> models.OCRResponse:
         r"""OCR
 
         :param model:
@@ -171,6 +174,9 @@ class Ocr(BaseSDK):
         :param image_min_size: Minimum height and width of image to extract
         :param bbox_annotation_format: Structured output class for extracting useful information from each extracted bounding box / image from document. Only json_schema is valid for this field
         :param document_annotation_format: Structured output class for extracting useful information from the entire document. Only json_schema is valid for this field
+        :param table_format:
+        :param extract_header:
+        :param extract_footer:
         :param retries: Override the default retry configuration for this method
         :param server_url: Override the default server URL for this method
         :param timeout_ms: Override the default request timeout configuration for this method in milliseconds
@@ -200,6 +206,9 @@ class Ocr(BaseSDK):
             document_annotation_format=utils.get_pydantic_model(
                 document_annotation_format, OptionalNullable[models.ResponseFormat]
             ),
+            table_format=table_format,
+            extract_header=extract_header,
+            extract_footer=extract_footer,
         )
 
         req = self._build_request_async(
@@ -218,6 +227,7 @@ class Ocr(BaseSDK):
             get_serialized_body=lambda: utils.serialize_request_body(
                 request, False, False, "json", models.OCRRequest
             ),
+            allow_empty_value=None,
             timeout_ms=timeout_ms,
         )
 
@@ -234,7 +244,7 @@ class Ocr(BaseSDK):
                 config=self.sdk_configuration,
                 base_url=base_url or "",
                 operation_id="ocr_v1_ocr_post",
-                oauth2_scopes=[],
+                oauth2_scopes=None,
                 security_source=self.sdk_configuration.security,
             ),
             request=req,
@@ -244,28 +254,17 @@ class Ocr(BaseSDK):
 
         response_data: Any = None
         if utils.match_response(http_res, "200", "application/json"):
-            return utils.unmarshal_json(http_res.text, Optional[models.OCRResponse])
+            return unmarshal_json_response(models.OCRResponse, http_res)
         if utils.match_response(http_res, "422", "application/json"):
-            response_data = utils.unmarshal_json(
-                http_res.text, models.HTTPValidationErrorData
+            response_data = unmarshal_json_response(
+                models.HTTPValidationErrorData, http_res
             )
-            raise models.HTTPValidationError(data=response_data)
+            raise models.HTTPValidationError(response_data, http_res)
         if utils.match_response(http_res, "4XX", "*"):
             http_res_text = await utils.stream_to_text_async(http_res)
-            raise models.SDKError(
-                "API error occurred", http_res.status_code, http_res_text, http_res
-            )
+            raise models.SDKError("API error occurred", http_res, http_res_text)
         if utils.match_response(http_res, "5XX", "*"):
             http_res_text = await utils.stream_to_text_async(http_res)
-            raise models.SDKError(
-                "API error occurred", http_res.status_code, http_res_text, http_res
-            )
+            raise models.SDKError("API error occurred", http_res, http_res_text)
 
-        content_type = http_res.headers.get("Content-Type")
-        http_res_text = await utils.stream_to_text_async(http_res)
-        raise models.SDKError(
-            f"Unexpected response received (code: {http_res.status_code}, type: {content_type})",
-            http_res.status_code,
-            http_res_text,
-            http_res,
-        )
+        raise models.SDKError("Unexpected response received", http_res)

mistralai_azure/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
+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: TypeAlias = int
-UnrecognizedStr: TypeAlias = 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_azure/utils/__init__.py

@@ -2,6 +2,8 @@
 
 from typing import TYPE_CHECKING
 from importlib import import_module
+import builtins
+import sys
 
 if TYPE_CHECKING:
     from .annotations import get_discriminator
@@ -39,7 +41,6 @@ if TYPE_CHECKING:
         validate_decimal,
         validate_float,
         validate_int,
-        validate_open_enum,
     )
     from .url import generate_url, template_url, remove_suffix
     from .values import (
@@ -100,7 +101,6 @@ __all__ = [
     "validate_const",
     "validate_float",
     "validate_int",
-    "validate_open_enum",
     "cast_partial",
 ]
 
@@ -153,11 +153,22 @@ _dynamic_imports: dict[str, str] = {
     "validate_const": ".serializers",
     "validate_float": ".serializers",
     "validate_int": ".serializers",
-    "validate_open_enum": ".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:
@@ -166,9 +177,8 @@ def __getattr__(attr_name: str) -> object:
         )
 
     try:
-        module = import_module(module_name, __package__)
-        result = getattr(module, attr_name)
-        return result
+        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}"
@@ -180,5 +190,5 @@ def __getattr__(attr_name: str) -> object:
 
 
 def __dir__():
-    lazy_attrs = list(_dynamic_imports.keys())
-    return sorted(lazy_attrs)
+    lazy_attrs = builtins.list(_dynamic_imports.keys())
+    return builtins.sorted(lazy_attrs)

mistralai_azure/utils/annotations.py

@@ -3,6 +3,7 @@
 from enum import Enum
 from typing import Any, Optional
 
+
 def get_discriminator(model: Any, fieldname: str, key: str) -> str:
     """
     Recursively search for the discriminator attribute in a model.
@@ -25,31 +26,54 @@ def get_discriminator(model: Any, fieldname: str, key: str) -> str:
 
         if isinstance(field, dict):
             if key in field:
-                return f'{field[key]}'
+                return f"{field[key]}"
 
         if hasattr(field, fieldname):
             attr = getattr(field, fieldname)
             if isinstance(attr, Enum):
-                return f'{attr.value}'
-            return f'{attr}'
+                return f"{attr.value}"
+            return f"{attr}"
 
         if hasattr(field, upper_fieldname):
             attr = getattr(field, upper_fieldname)
             if isinstance(attr, Enum):
-                return f'{attr.value}'
-            return f'{attr}'
+                return f"{attr.value}"
+            return f"{attr}"
 
         return None
 
+    def search_nested_discriminator(obj: Any) -> Optional[str]:
+        """Recursively search for discriminator in nested structures."""
+        # First try direct field lookup
+        discriminator = get_field_discriminator(obj)
+        if discriminator is not None:
+            return discriminator
+
+        # If it's a dict, search in nested values
+        if isinstance(obj, dict):
+            for value in obj.values():
+                if isinstance(value, list):
+                    # Search in list items
+                    for item in value:
+                        nested_discriminator = search_nested_discriminator(item)
+                        if nested_discriminator is not None:
+                            return nested_discriminator
+                elif isinstance(value, dict):
+                    # Search in nested dict
+                    nested_discriminator = search_nested_discriminator(value)
+                    if nested_discriminator is not None:
+                        return nested_discriminator
+
+        return None
 
     if isinstance(model, list):
         for field in model:
-            discriminator = get_field_discriminator(field)
+            discriminator = search_nested_discriminator(field)
             if discriminator is not None:
                 return discriminator
 
-    discriminator = get_field_discriminator(model)
+    discriminator = search_nested_discriminator(model)
     if discriminator is not None:
         return discriminator
 
-    raise ValueError(f'Could not find discriminator field {fieldname} in {model}')
+    raise ValueError(f"Could not find discriminator field {fieldname} in {model}")