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

mistralai_azure/models/chatcompletionchoice.py

@@ -3,14 +3,19 @@
 from __future__ import annotations
 from .assistantmessage import AssistantMessage, AssistantMessageTypedDict
 from mistralai_azure.types import BaseModel, UnrecognizedStr
-from mistralai_azure.utils import validate_open_enum
-from pydantic.functional_validators import PlainValidator
 from typing import Literal, Union
-from typing_extensions import Annotated, TypedDict
+from typing_extensions import TypedDict
 
 
 ChatCompletionChoiceFinishReason = Union[
-    Literal["stop", "length", "model_length", "error", "tool_calls"], UnrecognizedStr
+    Literal[
+        "stop",
+        "length",
+        "model_length",
+        "error",
+        "tool_calls",
+    ],
+    UnrecognizedStr,
 ]
 
 
@@ -25,6 +30,4 @@ class ChatCompletionChoice(BaseModel):
 
     message: AssistantMessage
 
-    finish_reason: Annotated[
-        ChatCompletionChoiceFinishReason, PlainValidator(validate_open_enum(False))
-    ]
+    finish_reason: ChatCompletionChoiceFinishReason

mistralai_azure/models/chatcompletionrequest.py

@@ -18,10 +18,9 @@ from mistralai_azure.types import (
     UNSET,
     UNSET_SENTINEL,
 )
-from mistralai_azure.utils import get_discriminator, validate_open_enum
+from mistralai_azure.utils import get_discriminator
 from pydantic import Discriminator, Tag, model_serializer
-from pydantic.functional_validators import PlainValidator
-from typing import List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
@@ -63,11 +62,13 @@ ChatCompletionRequestToolChoiceTypedDict = TypeAliasType(
     "ChatCompletionRequestToolChoiceTypedDict",
     Union[ToolChoiceTypedDict, ToolChoiceEnum],
 )
+r"""Controls which (if any) tool is called by the model. `none` means the model will not call any tool and instead generates a message. `auto` means the model can pick between generating a message or calling one or more tools. `any` or `required` means the model must call one or more tools. Specifying a particular tool via `{\"type\": \"function\", \"function\": {\"name\": \"my_function\"}}` forces the model to call that tool."""
 
 
 ChatCompletionRequestToolChoice = TypeAliasType(
     "ChatCompletionRequestToolChoice", Union[ToolChoice, ToolChoiceEnum]
 )
+r"""Controls which (if any) tool is called by the model. `none` means the model will not call any tool and instead generates a message. `auto` means the model can pick between generating a message or calling one or more tools. `any` or `required` means the model must call one or more tools. Specifying a particular tool via `{\"type\": \"function\", \"function\": {\"name\": \"my_function\"}}` forces the model to call that tool."""
 
 
 class ChatCompletionRequestTypedDict(TypedDict):
@@ -87,17 +88,23 @@ class ChatCompletionRequestTypedDict(TypedDict):
     r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
     random_seed: NotRequired[Nullable[int]]
     r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
+    metadata: NotRequired[Nullable[Dict[str, Any]]]
     response_format: NotRequired[ResponseFormatTypedDict]
+    r"""Specify the format that the model must output. By default it will use `{ \"type\": \"text\" }`. Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which guarantees the message the model generates is in JSON. When using JSON mode you MUST also instruct the model to produce JSON yourself with a system or a user message. Setting to `{ \"type\": \"json_schema\" }` enables JSON schema mode, which guarantees the message the model generates is in JSON and follows the schema you provide."""
     tools: NotRequired[Nullable[List[ToolTypedDict]]]
+    r"""A list of tools the model may call. Use this to provide a list of functions the model may generate JSON inputs for."""
     tool_choice: NotRequired[ChatCompletionRequestToolChoiceTypedDict]
+    r"""Controls which (if any) tool is called by the model. `none` means the model will not call any tool and instead generates a message. `auto` means the model can pick between generating a message or calling one or more tools. `any` or `required` means the model must call one or more tools. Specifying a particular tool via `{\"type\": \"function\", \"function\": {\"name\": \"my_function\"}}` forces the model to call that tool."""
     presence_penalty: NotRequired[float]
-    r"""presence_penalty determines how much the model penalizes the repetition of words or phrases. A higher presence penalty encourages the model to use a wider variety of words and phrases, making the output more diverse and creative."""
+    r"""The `presence_penalty` determines how much the model penalizes the repetition of words or phrases. A higher presence penalty encourages the model to use a wider variety of words and phrases, making the output more diverse and creative."""
     frequency_penalty: NotRequired[float]
-    r"""frequency_penalty penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
+    r"""The `frequency_penalty` penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
     n: NotRequired[Nullable[int]]
     r"""Number of completions to return for each request, input tokens are only billed once."""
     prediction: NotRequired[PredictionTypedDict]
+    r"""Enable users to specify an expected completion, optimizing response times by leveraging known or predictable content."""
     parallel_tool_calls: NotRequired[bool]
+    r"""Whether to enable parallel function calling during tool use, when enabled the model can call multiple tools in parallel."""
     prompt_mode: NotRequired[Nullable[MistralPromptMode]]
     r"""Allows toggling between the reasoning mode and no system prompt. When set to `reasoning` the system prompt for reasoning models will be used."""
     safe_prompt: NotRequired[bool]
@@ -129,28 +136,33 @@ class ChatCompletionRequest(BaseModel):
     random_seed: OptionalNullable[int] = UNSET
     r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
 
+    metadata: OptionalNullable[Dict[str, Any]] = UNSET
+
     response_format: Optional[ResponseFormat] = None
+    r"""Specify the format that the model must output. By default it will use `{ \"type\": \"text\" }`. Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which guarantees the message the model generates is in JSON. When using JSON mode you MUST also instruct the model to produce JSON yourself with a system or a user message. Setting to `{ \"type\": \"json_schema\" }` enables JSON schema mode, which guarantees the message the model generates is in JSON and follows the schema you provide."""
 
     tools: OptionalNullable[List[Tool]] = UNSET
+    r"""A list of tools the model may call. Use this to provide a list of functions the model may generate JSON inputs for."""
 
     tool_choice: Optional[ChatCompletionRequestToolChoice] = None
+    r"""Controls which (if any) tool is called by the model. `none` means the model will not call any tool and instead generates a message. `auto` means the model can pick between generating a message or calling one or more tools. `any` or `required` means the model must call one or more tools. Specifying a particular tool via `{\"type\": \"function\", \"function\": {\"name\": \"my_function\"}}` forces the model to call that tool."""
 
     presence_penalty: Optional[float] = None
-    r"""presence_penalty determines how much the model penalizes the repetition of words or phrases. A higher presence penalty encourages the model to use a wider variety of words and phrases, making the output more diverse and creative."""
+    r"""The `presence_penalty` determines how much the model penalizes the repetition of words or phrases. A higher presence penalty encourages the model to use a wider variety of words and phrases, making the output more diverse and creative."""
 
     frequency_penalty: Optional[float] = None
-    r"""frequency_penalty penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
+    r"""The `frequency_penalty` penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
 
     n: OptionalNullable[int] = UNSET
     r"""Number of completions to return for each request, input tokens are only billed once."""
 
     prediction: Optional[Prediction] = None
+    r"""Enable users to specify an expected completion, optimizing response times by leveraging known or predictable content."""
 
     parallel_tool_calls: Optional[bool] = None
+    r"""Whether to enable parallel function calling during tool use, when enabled the model can call multiple tools in parallel."""
 
-    prompt_mode: Annotated[
-        OptionalNullable[MistralPromptMode], PlainValidator(validate_open_enum(False))
-    ] = UNSET
+    prompt_mode: OptionalNullable[MistralPromptMode] = UNSET
     r"""Allows toggling between the reasoning mode and no system prompt. When set to `reasoning` the system prompt for reasoning models will be used."""
 
     safe_prompt: Optional[bool] = None
@@ -166,6 +178,7 @@ class ChatCompletionRequest(BaseModel):
             "stream",
             "stop",
             "random_seed",
+            "metadata",
             "response_format",
             "tools",
             "tool_choice",
@@ -181,6 +194,7 @@ class ChatCompletionRequest(BaseModel):
             "temperature",
             "max_tokens",
             "random_seed",
+            "metadata",
             "tools",
             "n",
             "prompt_mode",

mistralai_azure/models/chatcompletionstreamrequest.py

@@ -18,10 +18,9 @@ from mistralai_azure.types import (
     UNSET,
     UNSET_SENTINEL,
 )
-from mistralai_azure.utils import get_discriminator, validate_open_enum
+from mistralai_azure.utils import get_discriminator
 from pydantic import Discriminator, Tag, model_serializer
-from pydantic.functional_validators import PlainValidator
-from typing import List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
@@ -59,11 +58,13 @@ ChatCompletionStreamRequestToolChoiceTypedDict = TypeAliasType(
     "ChatCompletionStreamRequestToolChoiceTypedDict",
     Union[ToolChoiceTypedDict, ToolChoiceEnum],
 )
+r"""Controls which (if any) tool is called by the model. `none` means the model will not call any tool and instead generates a message. `auto` means the model can pick between generating a message or calling one or more tools. `any` or `required` means the model must call one or more tools. Specifying a particular tool via `{\"type\": \"function\", \"function\": {\"name\": \"my_function\"}}` forces the model to call that tool."""
 
 
 ChatCompletionStreamRequestToolChoice = TypeAliasType(
     "ChatCompletionStreamRequestToolChoice", Union[ToolChoice, ToolChoiceEnum]
 )
+r"""Controls which (if any) tool is called by the model. `none` means the model will not call any tool and instead generates a message. `auto` means the model can pick between generating a message or calling one or more tools. `any` or `required` means the model must call one or more tools. Specifying a particular tool via `{\"type\": \"function\", \"function\": {\"name\": \"my_function\"}}` forces the model to call that tool."""
 
 
 class ChatCompletionStreamRequestTypedDict(TypedDict):
@@ -82,17 +83,23 @@ class ChatCompletionStreamRequestTypedDict(TypedDict):
     r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
     random_seed: NotRequired[Nullable[int]]
     r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
+    metadata: NotRequired[Nullable[Dict[str, Any]]]
     response_format: NotRequired[ResponseFormatTypedDict]
+    r"""Specify the format that the model must output. By default it will use `{ \"type\": \"text\" }`. Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which guarantees the message the model generates is in JSON. When using JSON mode you MUST also instruct the model to produce JSON yourself with a system or a user message. Setting to `{ \"type\": \"json_schema\" }` enables JSON schema mode, which guarantees the message the model generates is in JSON and follows the schema you provide."""
     tools: NotRequired[Nullable[List[ToolTypedDict]]]
+    r"""A list of tools the model may call. Use this to provide a list of functions the model may generate JSON inputs for."""
     tool_choice: NotRequired[ChatCompletionStreamRequestToolChoiceTypedDict]
+    r"""Controls which (if any) tool is called by the model. `none` means the model will not call any tool and instead generates a message. `auto` means the model can pick between generating a message or calling one or more tools. `any` or `required` means the model must call one or more tools. Specifying a particular tool via `{\"type\": \"function\", \"function\": {\"name\": \"my_function\"}}` forces the model to call that tool."""
     presence_penalty: NotRequired[float]
-    r"""presence_penalty determines how much the model penalizes the repetition of words or phrases. A higher presence penalty encourages the model to use a wider variety of words and phrases, making the output more diverse and creative."""
+    r"""The `presence_penalty` determines how much the model penalizes the repetition of words or phrases. A higher presence penalty encourages the model to use a wider variety of words and phrases, making the output more diverse and creative."""
     frequency_penalty: NotRequired[float]
-    r"""frequency_penalty penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
+    r"""The `frequency_penalty` penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
     n: NotRequired[Nullable[int]]
     r"""Number of completions to return for each request, input tokens are only billed once."""
     prediction: NotRequired[PredictionTypedDict]
+    r"""Enable users to specify an expected completion, optimizing response times by leveraging known or predictable content."""
     parallel_tool_calls: NotRequired[bool]
+    r"""Whether to enable parallel function calling during tool use, when enabled the model can call multiple tools in parallel."""
     prompt_mode: NotRequired[Nullable[MistralPromptMode]]
     r"""Allows toggling between the reasoning mode and no system prompt. When set to `reasoning` the system prompt for reasoning models will be used."""
     safe_prompt: NotRequired[bool]
@@ -123,28 +130,33 @@ class ChatCompletionStreamRequest(BaseModel):
     random_seed: OptionalNullable[int] = UNSET
     r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
 
+    metadata: OptionalNullable[Dict[str, Any]] = UNSET
+
     response_format: Optional[ResponseFormat] = None
+    r"""Specify the format that the model must output. By default it will use `{ \"type\": \"text\" }`. Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which guarantees the message the model generates is in JSON. When using JSON mode you MUST also instruct the model to produce JSON yourself with a system or a user message. Setting to `{ \"type\": \"json_schema\" }` enables JSON schema mode, which guarantees the message the model generates is in JSON and follows the schema you provide."""
 
     tools: OptionalNullable[List[Tool]] = UNSET
+    r"""A list of tools the model may call. Use this to provide a list of functions the model may generate JSON inputs for."""
 
     tool_choice: Optional[ChatCompletionStreamRequestToolChoice] = None
+    r"""Controls which (if any) tool is called by the model. `none` means the model will not call any tool and instead generates a message. `auto` means the model can pick between generating a message or calling one or more tools. `any` or `required` means the model must call one or more tools. Specifying a particular tool via `{\"type\": \"function\", \"function\": {\"name\": \"my_function\"}}` forces the model to call that tool."""
 
     presence_penalty: Optional[float] = None
-    r"""presence_penalty determines how much the model penalizes the repetition of words or phrases. A higher presence penalty encourages the model to use a wider variety of words and phrases, making the output more diverse and creative."""
+    r"""The `presence_penalty` determines how much the model penalizes the repetition of words or phrases. A higher presence penalty encourages the model to use a wider variety of words and phrases, making the output more diverse and creative."""
 
     frequency_penalty: Optional[float] = None
-    r"""frequency_penalty penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
+    r"""The `frequency_penalty` penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
 
     n: OptionalNullable[int] = UNSET
     r"""Number of completions to return for each request, input tokens are only billed once."""
 
     prediction: Optional[Prediction] = None
+    r"""Enable users to specify an expected completion, optimizing response times by leveraging known or predictable content."""
 
     parallel_tool_calls: Optional[bool] = None
+    r"""Whether to enable parallel function calling during tool use, when enabled the model can call multiple tools in parallel."""
 
-    prompt_mode: Annotated[
-        OptionalNullable[MistralPromptMode], PlainValidator(validate_open_enum(False))
-    ] = UNSET
+    prompt_mode: OptionalNullable[MistralPromptMode] = UNSET
     r"""Allows toggling between the reasoning mode and no system prompt. When set to `reasoning` the system prompt for reasoning models will be used."""
 
     safe_prompt: Optional[bool] = None
@@ -160,6 +172,7 @@ class ChatCompletionStreamRequest(BaseModel):
             "stream",
             "stop",
             "random_seed",
+            "metadata",
             "response_format",
             "tools",
             "tool_choice",
@@ -175,6 +188,7 @@ class ChatCompletionStreamRequest(BaseModel):
             "temperature",
             "max_tokens",
             "random_seed",
+            "metadata",
             "tools",
             "n",
             "prompt_mode",

mistralai_azure/models/completionresponsestreamchoice.py

@@ -3,14 +3,20 @@
 from __future__ import annotations
 from .deltamessage import DeltaMessage, DeltaMessageTypedDict
 from mistralai_azure.types import BaseModel, Nullable, UNSET_SENTINEL, UnrecognizedStr
-from mistralai_azure.utils import validate_open_enum
 from pydantic import model_serializer
-from pydantic.functional_validators import PlainValidator
 from typing import Literal, Union
-from typing_extensions import Annotated, TypedDict
+from typing_extensions import TypedDict
 
 
-FinishReason = Union[Literal["stop", "length", "error", "tool_calls"], UnrecognizedStr]
+FinishReason = Union[
+    Literal[
+        "stop",
+        "length",
+        "error",
+        "tool_calls",
+    ],
+    UnrecognizedStr,
+]
 
 
 class CompletionResponseStreamChoiceTypedDict(TypedDict):
@@ -24,9 +30,7 @@ class CompletionResponseStreamChoice(BaseModel):
 
     delta: DeltaMessage
 
-    finish_reason: Annotated[
-        Nullable[FinishReason], PlainValidator(validate_open_enum(False))
-    ]
+    finish_reason: Nullable[FinishReason]
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):

mistralai_azure/models/documenturlchunk.py

@@ -13,7 +13,7 @@ from typing import Literal, Optional
 from typing_extensions import NotRequired, TypedDict
 
 
-DocumentURLChunkType = Literal["document_url"]
+DocumentURLChunkType = Literal["document_url",]
 
 
 class DocumentURLChunkTypedDict(TypedDict):

mistralai_azure/models/httpvalidationerror.py

@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 from .validationerror import ValidationError
-from mistralai_azure import utils
+from dataclasses import dataclass, field
+import httpx
+from mistralai_azure.models import MistralAzureError
 from mistralai_azure.types import BaseModel
 from typing import List, Optional
 
@@ -11,11 +13,16 @@ class HTTPValidationErrorData(BaseModel):
     detail: Optional[List[ValidationError]] = None
 
 
-class HTTPValidationError(Exception):
-    data: HTTPValidationErrorData
+@dataclass(unsafe_hash=True)
+class HTTPValidationError(MistralAzureError):
+    data: HTTPValidationErrorData = field(hash=False)
 
-    def __init__(self, data: HTTPValidationErrorData):
-        self.data = data
-
-    def __str__(self) -> str:
-        return utils.marshal_json(self.data, HTTPValidationErrorData)
+    def __init__(
+        self,
+        data: HTTPValidationErrorData,
+        raw_response: httpx.Response,
+        body: Optional[str] = None,
+    ):
+        message = body or raw_response.text
+        super().__init__(message, raw_response, body)
+        object.__setattr__(self, "data", data)

mistralai_azure/models/imageurlchunk.py

@@ -15,7 +15,7 @@ ImageURLChunkImageURLTypedDict = TypeAliasType(
 ImageURLChunkImageURL = TypeAliasType("ImageURLChunkImageURL", Union[ImageURL, str])
 
 
-ImageURLChunkType = Literal["image_url"]
+ImageURLChunkType = Literal["image_url",]
 
 
 class ImageURLChunkTypedDict(TypedDict):

mistralai_azure/models/mistralazureerror.py

@@ -0,0 +1,30 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import httpx
+from typing import Optional
+from dataclasses import dataclass, field
+
+
+@dataclass(unsafe_hash=True)
+class MistralAzureError(Exception):
+    """The base class for all HTTP error responses."""
+
+    message: str
+    status_code: int
+    body: str
+    headers: httpx.Headers = field(hash=False)
+    raw_response: httpx.Response = field(hash=False)
+
+    def __init__(
+        self, message: str, raw_response: httpx.Response, body: Optional[str] = None
+    ):
+        object.__setattr__(self, "message", message)
+        object.__setattr__(self, "status_code", raw_response.status_code)
+        object.__setattr__(
+            self, "body", body if body is not None else raw_response.text
+        )
+        object.__setattr__(self, "headers", raw_response.headers)
+        object.__setattr__(self, "raw_response", raw_response)
+
+    def __str__(self):
+        return self.message

mistralai_azure/models/mistralpromptmode.py

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

mistralai_azure/models/no_response_error.py

@@ -0,0 +1,17 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from dataclasses import dataclass
+
+
+@dataclass(unsafe_hash=True)
+class NoResponseError(Exception):
+    """Error raised when no HTTP response is received from the server."""
+
+    message: str
+
+    def __init__(self, message: str = "No response received"):
+        object.__setattr__(self, "message", message)
+        super().__init__(message)
+
+    def __str__(self):
+        return self.message

mistralai_azure/models/ocrpageobject.py

@@ -3,10 +3,17 @@
 from __future__ import annotations
 from .ocrimageobject import OCRImageObject, OCRImageObjectTypedDict
 from .ocrpagedimensions import OCRPageDimensions, OCRPageDimensionsTypedDict
-from mistralai_azure.types import BaseModel, Nullable, UNSET_SENTINEL
+from .ocrtableobject import OCRTableObject, OCRTableObjectTypedDict
+from mistralai_azure.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
 from pydantic import model_serializer
-from typing import List
-from typing_extensions import TypedDict
+from typing import List, Optional
+from typing_extensions import NotRequired, TypedDict
 
 
 class OCRPageObjectTypedDict(TypedDict):
@@ -18,6 +25,14 @@ class OCRPageObjectTypedDict(TypedDict):
     r"""List of all extracted images in the page"""
     dimensions: Nullable[OCRPageDimensionsTypedDict]
     r"""The dimensions of the PDF Page's screenshot image"""
+    tables: NotRequired[List[OCRTableObjectTypedDict]]
+    r"""List of all extracted tables in the page"""
+    hyperlinks: NotRequired[List[str]]
+    r"""List of all hyperlinks in the page"""
+    header: NotRequired[Nullable[str]]
+    r"""Header of the page"""
+    footer: NotRequired[Nullable[str]]
+    r"""Footer of the page"""
 
 
 class OCRPageObject(BaseModel):
@@ -33,10 +48,22 @@ class OCRPageObject(BaseModel):
     dimensions: Nullable[OCRPageDimensions]
     r"""The dimensions of the PDF Page's screenshot image"""
 
+    tables: Optional[List[OCRTableObject]] = None
+    r"""List of all extracted tables in the page"""
+
+    hyperlinks: Optional[List[str]] = None
+    r"""List of all hyperlinks in the page"""
+
+    header: OptionalNullable[str] = UNSET
+    r"""Header of the page"""
+
+    footer: OptionalNullable[str] = UNSET
+    r"""Footer of the page"""
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = []
-        nullable_fields = ["dimensions"]
+        optional_fields = ["tables", "hyperlinks", "header", "footer"]
+        nullable_fields = ["header", "footer", "dimensions"]
         null_default_fields = []
 
         serialized = handler(self)

mistralai_azure/models/ocrrequest.py

@@ -13,7 +13,7 @@ from mistralai_azure.types import (
     UNSET_SENTINEL,
 )
 from pydantic import model_serializer
-from typing import List, Optional, Union
+from typing import List, Literal, Optional, Union
 from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
@@ -28,6 +28,12 @@ Document = TypeAliasType("Document", Union[FileChunk, ImageURLChunk, DocumentURL
 r"""Document to run OCR on"""
 
 
+TableFormat = Literal[
+    "markdown",
+    "html",
+]
+
+
 class OCRRequestTypedDict(TypedDict):
     model: Nullable[str]
     document: DocumentTypedDict
@@ -45,6 +51,9 @@ class OCRRequestTypedDict(TypedDict):
     r"""Structured output class for extracting useful information from each extracted bounding box / image from document. Only json_schema is valid for this field"""
     document_annotation_format: NotRequired[Nullable[ResponseFormatTypedDict]]
     r"""Structured output class for extracting useful information from the entire document. Only json_schema is valid for this field"""
+    table_format: NotRequired[Nullable[TableFormat]]
+    extract_header: NotRequired[bool]
+    extract_footer: NotRequired[bool]
 
 
 class OCRRequest(BaseModel):
@@ -73,6 +82,12 @@ class OCRRequest(BaseModel):
     document_annotation_format: OptionalNullable[ResponseFormat] = UNSET
     r"""Structured output class for extracting useful information from the entire document. Only json_schema is valid for this field"""
 
+    table_format: OptionalNullable[TableFormat] = UNSET
+
+    extract_header: Optional[bool] = None
+
+    extract_footer: Optional[bool] = None
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = [
@@ -83,6 +98,9 @@ class OCRRequest(BaseModel):
             "image_min_size",
             "bbox_annotation_format",
             "document_annotation_format",
+            "table_format",
+            "extract_header",
+            "extract_footer",
         ]
         nullable_fields = [
             "model",
@@ -92,6 +110,7 @@ class OCRRequest(BaseModel):
             "image_min_size",
             "bbox_annotation_format",
             "document_annotation_format",
+            "table_format",
         ]
         null_default_fields = []
 

mistralai_azure/models/ocrtableobject.py

@@ -0,0 +1,34 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai_azure.types import BaseModel
+import pydantic
+from typing import Literal
+from typing_extensions import Annotated, TypedDict
+
+
+Format = Literal[
+    "markdown",
+    "html",
+]
+r"""Format of the table"""
+
+
+class OCRTableObjectTypedDict(TypedDict):
+    id: str
+    r"""Table ID for extracted table in a page"""
+    content: str
+    r"""Content of the table in the given format"""
+    format_: Format
+    r"""Format of the table"""
+
+
+class OCRTableObject(BaseModel):
+    id: str
+    r"""Table ID for extracted table in a page"""
+
+    content: str
+    r"""Content of the table in the given format"""
+
+    format_: Annotated[Format, pydantic.Field(alias="format")]
+    r"""Format of the table"""

mistralai_azure/models/prediction.py

@@ -10,11 +10,15 @@ from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class PredictionTypedDict(TypedDict):
+    r"""Enable users to specify an expected completion, optimizing response times by leveraging known or predictable content."""
+
     type: Literal["content"]
     content: NotRequired[str]
 
 
 class Prediction(BaseModel):
+    r"""Enable users to specify an expected completion, optimizing response times by leveraging known or predictable content."""
+
     TYPE: Annotated[
         Annotated[
             Optional[Literal["content"]], AfterValidator(validate_const("content"))

mistralai_azure/models/referencechunk.py

@@ -6,7 +6,7 @@ from typing import List, Literal, Optional
 from typing_extensions import NotRequired, TypedDict
 
 
-ReferenceChunkType = Literal["reference"]
+ReferenceChunkType = Literal["reference",]
 
 
 class ReferenceChunkTypedDict(TypedDict):

mistralai_azure/models/responseformat.py

@@ -16,14 +16,16 @@ from typing_extensions import NotRequired, TypedDict
 
 
 class ResponseFormatTypedDict(TypedDict):
+    r"""Specify the format that the model must output. By default it will use `{ \"type\": \"text\" }`. Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which guarantees the message the model generates is in JSON. When using JSON mode you MUST also instruct the model to produce JSON yourself with a system or a user message. Setting to `{ \"type\": \"json_schema\" }` enables JSON schema mode, which guarantees the message the model generates is in JSON and follows the schema you provide."""
+
     type: NotRequired[ResponseFormats]
-    r"""An object specifying the format that the model must output. Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which guarantees the message the model generates is in JSON. When using JSON mode you MUST also instruct the model to produce JSON yourself with a system or a user message."""
     json_schema: NotRequired[Nullable[JSONSchemaTypedDict]]
 
 
 class ResponseFormat(BaseModel):
+    r"""Specify the format that the model must output. By default it will use `{ \"type\": \"text\" }`. Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which guarantees the message the model generates is in JSON. When using JSON mode you MUST also instruct the model to produce JSON yourself with a system or a user message. Setting to `{ \"type\": \"json_schema\" }` enables JSON schema mode, which guarantees the message the model generates is in JSON and follows the schema you provide."""
+
     type: Optional[ResponseFormats] = None
-    r"""An object specifying the format that the model must output. Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which guarantees the message the model generates is in JSON. When using JSON mode you MUST also instruct the model to produce JSON yourself with a system or a user message."""
 
     json_schema: OptionalNullable[JSONSchema] = UNSET
 

mistralai_azure/models/responseformats.py

@@ -4,5 +4,8 @@ from __future__ import annotations
 from typing import Literal
 
 
-ResponseFormats = Literal["text", "json_object", "json_schema"]
-r"""An object specifying the format that the model must output. Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which guarantees the message the model generates is in JSON. When using JSON mode you MUST also instruct the model to produce JSON yourself with a system or a user message."""
+ResponseFormats = Literal[
+    "text",
+    "json_object",
+    "json_schema",
+]

mistralai_azure/models/responsevalidationerror.py

@@ -0,0 +1,27 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+import httpx
+from typing import Optional
+from dataclasses import dataclass
+
+from mistralai_azure.models import MistralAzureError
+
+
+@dataclass(unsafe_hash=True)
+class ResponseValidationError(MistralAzureError):
+    """Error raised when there is a type mismatch between the response data and the expected Pydantic model."""
+
+    def __init__(
+        self,
+        message: str,
+        raw_response: httpx.Response,
+        cause: Exception,
+        body: Optional[str] = None,
+    ):
+        message = f"{message}: {cause}"
+        super().__init__(message, raw_response, body)
+
+    @property
+    def cause(self):
+        """Normally the Pydantic ValidationError"""
+        return self.__cause__