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

mistralai/models/modelcapabilities.py

@@ -8,22 +8,31 @@ from typing_extensions import NotRequired, TypedDict
 
 class ModelCapabilitiesTypedDict(TypedDict):
     completion_chat: NotRequired[bool]
-    completion_fim: NotRequired[bool]
     function_calling: NotRequired[bool]
+    completion_fim: NotRequired[bool]
     fine_tuning: NotRequired[bool]
     vision: NotRequired[bool]
+    ocr: NotRequired[bool]
     classification: NotRequired[bool]
+    moderation: NotRequired[bool]
+    audio: NotRequired[bool]
 
 
 class ModelCapabilities(BaseModel):
-    completion_chat: Optional[bool] = True
+    completion_chat: Optional[bool] = False
 
-    completion_fim: Optional[bool] = False
+    function_calling: Optional[bool] = False
 
-    function_calling: Optional[bool] = True
+    completion_fim: Optional[bool] = False
 
     fine_tuning: Optional[bool] = False
 
     vision: Optional[bool] = False
 
+    ocr: Optional[bool] = False
+
     classification: Optional[bool] = False
+
+    moderation: Optional[bool] = False
+
+    audio: Optional[bool] = False

mistralai/models/modelconversation.py

@@ -12,7 +12,7 @@ from datetime import datetime
 from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from mistralai.utils import get_discriminator
 from pydantic import Discriminator, Tag, model_serializer
-from typing import List, Literal, Optional, Union
+from typing import Any, Dict, List, Literal, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
@@ -60,6 +60,8 @@ class ModelConversationTypedDict(TypedDict):
     r"""Name given to the conversation."""
     description: NotRequired[Nullable[str]]
     r"""Description of the what the conversation is about."""
+    metadata: NotRequired[Nullable[Dict[str, Any]]]
+    r"""Custom metadata for the conversation."""
     object: NotRequired[ModelConversationObject]
 
 
@@ -87,6 +89,9 @@ class ModelConversation(BaseModel):
     description: OptionalNullable[str] = UNSET
     r"""Description of the what the conversation is about."""
 
+    metadata: OptionalNullable[Dict[str, Any]] = UNSET
+    r"""Custom metadata for the conversation."""
+
     object: Optional[ModelConversationObject] = "conversation"
 
     @model_serializer(mode="wrap")
@@ -97,9 +102,10 @@ class ModelConversation(BaseModel):
             "completion_args",
             "name",
             "description",
+            "metadata",
             "object",
         ]
-        nullable_fields = ["instructions", "name", "description"]
+        nullable_fields = ["instructions", "name", "description", "metadata"]
         null_default_fields = []
 
         serialized = handler(self)

mistralai/models/ocrpageobject.py

@@ -3,10 +3,11 @@
 from __future__ import annotations
 from .ocrimageobject import OCRImageObject, OCRImageObjectTypedDict
 from .ocrpagedimensions import OCRPageDimensions, OCRPageDimensionsTypedDict
-from mistralai.types import BaseModel, Nullable, UNSET_SENTINEL
+from .ocrtableobject import OCRTableObject, OCRTableObjectTypedDict
+from mistralai.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 +19,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 +42,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/models/ocrrequest.py

@@ -7,7 +7,7 @@ from .imageurlchunk import ImageURLChunk, ImageURLChunkTypedDict
 from .responseformat import ResponseFormat, ResponseFormatTypedDict
 from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, 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
 
 
@@ -22,6 +22,9 @@ 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
@@ -39,6 +42,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):
@@ -67,6 +73,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 = [
@@ -77,6 +89,9 @@ class OCRRequest(BaseModel):
             "image_min_size",
             "bbox_annotation_format",
             "document_annotation_format",
+            "table_format",
+            "extract_header",
+            "extract_footer",
         ]
         nullable_fields = [
             "model",
@@ -86,6 +101,7 @@ class OCRRequest(BaseModel):
             "image_min_size",
             "bbox_annotation_format",
             "document_annotation_format",
+            "table_format",
         ]
         null_default_fields = []
 

mistralai/models/ocrtableobject.py

@@ -0,0 +1,31 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.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/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/models/requestsource.py

@@ -0,0 +1,7 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from typing import Literal
+
+
+RequestSource = Literal["api", "playground", "agent_builder_v1"]

mistralai/models/responseformat.py

@@ -10,14 +10,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/models/responseformats.py

@@ -5,4 +5,3 @@ 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."""

mistralai/models/sharingdelete.py

@@ -2,25 +2,56 @@
 
 from __future__ import annotations
 from .entitytype import EntityType
-from mistralai.types import BaseModel
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from mistralai.utils import validate_open_enum
+from pydantic import model_serializer
 from pydantic.functional_validators import PlainValidator
-from typing_extensions import Annotated, TypedDict
+from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class SharingDeleteTypedDict(TypedDict):
-    org_id: str
     share_with_uuid: str
     r"""The id of the entity (user, workspace or organization) to share with"""
     share_with_type: EntityType
     r"""The type of entity, used to share a library."""
+    org_id: NotRequired[Nullable[str]]
 
 
 class SharingDelete(BaseModel):
-    org_id: str
-
     share_with_uuid: str
     r"""The id of the entity (user, workspace or organization) to share with"""
 
     share_with_type: Annotated[EntityType, PlainValidator(validate_open_enum(False))]
     r"""The type of entity, used to share a library."""
+
+    org_id: OptionalNullable[str] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["org_id"]
+        nullable_fields = ["org_id"]
+        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
+
+        return m

mistralai/models/sharingin.py

@@ -3,24 +3,23 @@
 from __future__ import annotations
 from .entitytype import EntityType
 from .shareenum import ShareEnum
-from mistralai.types import BaseModel
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from mistralai.utils import validate_open_enum
+from pydantic import model_serializer
 from pydantic.functional_validators import PlainValidator
-from typing_extensions import Annotated, TypedDict
+from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class SharingInTypedDict(TypedDict):
-    org_id: str
     level: ShareEnum
     share_with_uuid: str
     r"""The id of the entity (user, workspace or organization) to share with"""
     share_with_type: EntityType
     r"""The type of entity, used to share a library."""
+    org_id: NotRequired[Nullable[str]]
 
 
 class SharingIn(BaseModel):
-    org_id: str
-
     level: Annotated[ShareEnum, PlainValidator(validate_open_enum(False))]
 
     share_with_uuid: str
@@ -28,3 +27,35 @@ class SharingIn(BaseModel):
 
     share_with_type: Annotated[EntityType, PlainValidator(validate_open_enum(False))]
     r"""The type of entity, used to share a library."""
+
+    org_id: OptionalNullable[str] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["org_id"]
+        nullable_fields = ["org_id"]
+        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
+
+        return m

mistralai/models/sharingout.py

@@ -11,7 +11,7 @@ class SharingOutTypedDict(TypedDict):
     org_id: str
     role: str
     share_with_type: str
-    share_with_uuid: str
+    share_with_uuid: Nullable[str]
     user_id: NotRequired[Nullable[str]]
 
 
@@ -24,14 +24,14 @@ class SharingOut(BaseModel):
 
     share_with_type: str
 
-    share_with_uuid: str
+    share_with_uuid: Nullable[str]
 
     user_id: OptionalNullable[str] = UNSET
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = ["user_id"]
-        nullable_fields = ["user_id"]
+        nullable_fields = ["user_id", "share_with_uuid"]
         null_default_fields = []
 
         serialized = handler(self)

mistralai/models/toolexecutiondeltaevent.py

@@ -4,16 +4,25 @@ from __future__ import annotations
 from .builtinconnectors import BuiltInConnectors
 from datetime import datetime
 from mistralai.types import BaseModel
-from typing import Literal, Optional
-from typing_extensions import NotRequired, TypedDict
+from typing import Literal, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
 ToolExecutionDeltaEventType = Literal["tool.execution.delta"]
 
+ToolExecutionDeltaEventNameTypedDict = TypeAliasType(
+    "ToolExecutionDeltaEventNameTypedDict", Union[BuiltInConnectors, str]
+)
+
+
+ToolExecutionDeltaEventName = TypeAliasType(
+    "ToolExecutionDeltaEventName", Union[BuiltInConnectors, str]
+)
+
 
 class ToolExecutionDeltaEventTypedDict(TypedDict):
     id: str
-    name: BuiltInConnectors
+    name: ToolExecutionDeltaEventNameTypedDict
     arguments: str
     type: NotRequired[ToolExecutionDeltaEventType]
     created_at: NotRequired[datetime]
@@ -23,7 +32,7 @@ class ToolExecutionDeltaEventTypedDict(TypedDict):
 class ToolExecutionDeltaEvent(BaseModel):
     id: str
 
-    name: BuiltInConnectors
+    name: ToolExecutionDeltaEventName
 
     arguments: str
 

mistralai/models/toolexecutiondoneevent.py

@@ -4,16 +4,25 @@ from __future__ import annotations
 from .builtinconnectors import BuiltInConnectors
 from datetime import datetime
 from mistralai.types import BaseModel
-from typing import Any, Dict, Literal, Optional
-from typing_extensions import NotRequired, TypedDict
+from typing import Any, Dict, Literal, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
 ToolExecutionDoneEventType = Literal["tool.execution.done"]
 
+ToolExecutionDoneEventNameTypedDict = TypeAliasType(
+    "ToolExecutionDoneEventNameTypedDict", Union[BuiltInConnectors, str]
+)
+
+
+ToolExecutionDoneEventName = TypeAliasType(
+    "ToolExecutionDoneEventName", Union[BuiltInConnectors, str]
+)
+
 
 class ToolExecutionDoneEventTypedDict(TypedDict):
     id: str
-    name: BuiltInConnectors
+    name: ToolExecutionDoneEventNameTypedDict
     type: NotRequired[ToolExecutionDoneEventType]
     created_at: NotRequired[datetime]
     output_index: NotRequired[int]
@@ -23,7 +32,7 @@ class ToolExecutionDoneEventTypedDict(TypedDict):
 class ToolExecutionDoneEvent(BaseModel):
     id: str
 
-    name: BuiltInConnectors
+    name: ToolExecutionDoneEventName
 
     type: Optional[ToolExecutionDoneEventType] = "tool.execution.done"
 

mistralai/models/toolexecutionentry.py

@@ -5,17 +5,22 @@ from .builtinconnectors import BuiltInConnectors
 from datetime import datetime
 from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from pydantic import model_serializer
-from typing import Any, Dict, Literal, Optional
-from typing_extensions import NotRequired, TypedDict
+from typing import Any, Dict, Literal, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
 ToolExecutionEntryObject = Literal["entry"]
 
 ToolExecutionEntryType = Literal["tool.execution"]
 
+NameTypedDict = TypeAliasType("NameTypedDict", Union[BuiltInConnectors, str])
+
+
+Name = TypeAliasType("Name", Union[BuiltInConnectors, str])
+
 
 class ToolExecutionEntryTypedDict(TypedDict):
-    name: BuiltInConnectors
+    name: NameTypedDict
     arguments: str
     object: NotRequired[ToolExecutionEntryObject]
     type: NotRequired[ToolExecutionEntryType]
@@ -26,7 +31,7 @@ class ToolExecutionEntryTypedDict(TypedDict):
 
 
 class ToolExecutionEntry(BaseModel):
-    name: BuiltInConnectors
+    name: Name
 
     arguments: str
 

mistralai/models/toolexecutionstartedevent.py

@@ -4,16 +4,25 @@ from __future__ import annotations
 from .builtinconnectors import BuiltInConnectors
 from datetime import datetime
 from mistralai.types import BaseModel
-from typing import Literal, Optional
-from typing_extensions import NotRequired, TypedDict
+from typing import Literal, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
 ToolExecutionStartedEventType = Literal["tool.execution.started"]
 
+ToolExecutionStartedEventNameTypedDict = TypeAliasType(
+    "ToolExecutionStartedEventNameTypedDict", Union[BuiltInConnectors, str]
+)
+
+
+ToolExecutionStartedEventName = TypeAliasType(
+    "ToolExecutionStartedEventName", Union[BuiltInConnectors, str]
+)
+
 
 class ToolExecutionStartedEventTypedDict(TypedDict):
     id: str
-    name: BuiltInConnectors
+    name: ToolExecutionStartedEventNameTypedDict
     arguments: str
     type: NotRequired[ToolExecutionStartedEventType]
     created_at: NotRequired[datetime]
@@ -23,7 +32,7 @@ class ToolExecutionStartedEventTypedDict(TypedDict):
 class ToolExecutionStartedEvent(BaseModel):
     id: str
 
-    name: BuiltInConnectors
+    name: ToolExecutionStartedEventName
 
     arguments: str
 

mistralai/models_.py

@@ -73,18 +73,12 @@ class Models(BaseSDK):
                 ),
             ),
             request=req,
-            error_status_codes=["422", "4XX", "5XX"],
+            error_status_codes=["4XX", "5XX"],
             retry_config=retry_config,
         )
 
-        response_data: Any = None
         if utils.match_response(http_res, "200", "application/json"):
             return unmarshal_json_response(models.ModelList, http_res)
-        if utils.match_response(http_res, "422", "application/json"):
-            response_data = unmarshal_json_response(
-                models.HTTPValidationErrorData, http_res
-            )
-            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, http_res_text)
@@ -155,18 +149,12 @@ class Models(BaseSDK):
                 ),
             ),
             request=req,
-            error_status_codes=["422", "4XX", "5XX"],
+            error_status_codes=["4XX", "5XX"],
             retry_config=retry_config,
         )
 
-        response_data: Any = None
         if utils.match_response(http_res, "200", "application/json"):
             return unmarshal_json_response(models.ModelList, http_res)
-        if utils.match_response(http_res, "422", "application/json"):
-            response_data = unmarshal_json_response(
-                models.HTTPValidationErrorData, http_res
-            )
-            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, http_res_text)