mistralai 1.4.0__py3-none-any.whl → 1.5.1__py3-none-any.whl

mistralai/models/contentchunk.py

@@ -1,6 +1,7 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .documenturlchunk import DocumentURLChunk, DocumentURLChunkTypedDict
 from .imageurlchunk import ImageURLChunk, ImageURLChunkTypedDict
 from .referencechunk import ReferenceChunk, ReferenceChunkTypedDict
 from .textchunk import TextChunk, TextChunkTypedDict
@@ -12,13 +13,19 @@ from typing_extensions import Annotated, TypeAliasType
 
 ContentChunkTypedDict = TypeAliasType(
     "ContentChunkTypedDict",
-    Union[TextChunkTypedDict, ImageURLChunkTypedDict, ReferenceChunkTypedDict],
+    Union[
+        TextChunkTypedDict,
+        ImageURLChunkTypedDict,
+        ReferenceChunkTypedDict,
+        DocumentURLChunkTypedDict,
+    ],
 )
 
 
 ContentChunk = Annotated[
     Union[
         Annotated[ImageURLChunk, Tag("image_url")],
+        Annotated[DocumentURLChunk, Tag("document_url")],
         Annotated[TextChunk, Tag("text")],
         Annotated[ReferenceChunk, Tag("reference")],
     ],

mistralai/models/documenturlchunk.py

@@ -0,0 +1,62 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from mistralai.utils import validate_const
+import pydantic
+from pydantic import model_serializer
+from pydantic.functional_validators import AfterValidator
+from typing import Literal, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class DocumentURLChunkTypedDict(TypedDict):
+    document_url: str
+    type: Literal["document_url"]
+    document_name: NotRequired[Nullable[str]]
+    r"""The filename of the document"""
+
+
+class DocumentURLChunk(BaseModel):
+    document_url: str
+
+    TYPE: Annotated[
+        Annotated[
+            Optional[Literal["document_url"]],
+            AfterValidator(validate_const("document_url")),
+        ],
+        pydantic.Field(alias="type"),
+    ] = "document_url"
+
+    document_name: OptionalNullable[str] = UNSET
+    r"""The filename of the document"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["type", "document_name"]
+        nullable_fields = ["document_name"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in 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/embeddingrequest.py

@@ -1,9 +1,8 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from mistralai.types import BaseModel
 import pydantic
-from pydantic import model_serializer
 from typing import List, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
@@ -21,8 +20,6 @@ class EmbeddingRequestTypedDict(TypedDict):
     r"""Text to embed."""
     model: NotRequired[str]
     r"""ID of the model to use."""
-    encoding_format: NotRequired[Nullable[str]]
-    r"""The format to return the embeddings in."""
 
 
 class EmbeddingRequest(BaseModel):
@@ -31,36 +28,3 @@ class EmbeddingRequest(BaseModel):
 
     model: Optional[str] = "mistral-embed"
     r"""ID of the model to use."""
-
-    encoding_format: OptionalNullable[str] = UNSET
-    r"""The format to return the embeddings in."""
-
-    @model_serializer(mode="wrap")
-    def serialize_model(self, handler):
-        optional_fields = ["model", "encoding_format"]
-        nullable_fields = ["encoding_format"]
-        null_default_fields = []
-
-        serialized = handler(self)
-
-        m = {}
-
-        for n, f in 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/fimcompletionrequest.py

@@ -20,7 +20,7 @@ r"""Stop generation if this token is detected. Or if one of these tokens is dete
 
 
 class FIMCompletionRequestTypedDict(TypedDict):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. Only compatible for now with:
     - `codestral-2405`
     - `codestral-latest`
@@ -46,7 +46,7 @@ class FIMCompletionRequestTypedDict(TypedDict):
 
 
 class FIMCompletionRequest(BaseModel):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. Only compatible for now with:
     - `codestral-2405`
     - `codestral-latest`
@@ -92,7 +92,6 @@ class FIMCompletionRequest(BaseModel):
             "min_tokens",
         ]
         nullable_fields = [
-            "model",
             "temperature",
             "max_tokens",
             "random_seed",

mistralai/models/fimcompletionstreamrequest.py

@@ -20,7 +20,7 @@ r"""Stop generation if this token is detected. Or if one of these tokens is dete
 
 
 class FIMCompletionStreamRequestTypedDict(TypedDict):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. Only compatible for now with:
     - `codestral-2405`
     - `codestral-latest`
@@ -45,7 +45,7 @@ class FIMCompletionStreamRequestTypedDict(TypedDict):
 
 
 class FIMCompletionStreamRequest(BaseModel):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. Only compatible for now with:
     - `codestral-2405`
     - `codestral-latest`
@@ -90,7 +90,6 @@ class FIMCompletionStreamRequest(BaseModel):
             "min_tokens",
         ]
         nullable_fields = [
-            "model",
             "temperature",
             "max_tokens",
             "random_seed",

mistralai/models/jsonschema.py

@@ -0,0 +1,55 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+import pydantic
+from pydantic import model_serializer
+from typing import Any, Dict, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class JSONSchemaTypedDict(TypedDict):
+    name: str
+    schema_definition: Dict[str, Any]
+    description: NotRequired[Nullable[str]]
+    strict: NotRequired[bool]
+
+
+class JSONSchema(BaseModel):
+    name: str
+
+    schema_definition: Annotated[Dict[str, Any], pydantic.Field(alias="schema")]
+
+    description: OptionalNullable[str] = UNSET
+
+    strict: Optional[bool] = False
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["description", "strict"]
+        nullable_fields = ["description"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in 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/ocrimageobject.py

@@ -0,0 +1,77 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing_extensions import NotRequired, TypedDict
+
+
+class OCRImageObjectTypedDict(TypedDict):
+    id: str
+    r"""Image ID for extracted image in a page"""
+    top_left_x: Nullable[int]
+    r"""X coordinate of top-left corner of the extracted image"""
+    top_left_y: Nullable[int]
+    r"""Y coordinate of top-left corner of the extracted image"""
+    bottom_right_x: Nullable[int]
+    r"""X coordinate of bottom-right corner of the extracted image"""
+    bottom_right_y: Nullable[int]
+    r"""Y coordinate of bottom-right corner of the extracted image"""
+    image_base64: NotRequired[Nullable[str]]
+    r"""Base64 string of the extracted image"""
+
+
+class OCRImageObject(BaseModel):
+    id: str
+    r"""Image ID for extracted image in a page"""
+
+    top_left_x: Nullable[int]
+    r"""X coordinate of top-left corner of the extracted image"""
+
+    top_left_y: Nullable[int]
+    r"""Y coordinate of top-left corner of the extracted image"""
+
+    bottom_right_x: Nullable[int]
+    r"""X coordinate of bottom-right corner of the extracted image"""
+
+    bottom_right_y: Nullable[int]
+    r"""Y coordinate of bottom-right corner of the extracted image"""
+
+    image_base64: OptionalNullable[str] = UNSET
+    r"""Base64 string of the extracted image"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["image_base64"]
+        nullable_fields = [
+            "top_left_x",
+            "top_left_y",
+            "bottom_right_x",
+            "bottom_right_y",
+            "image_base64",
+        ]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in 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/ocrpagedimensions.py

@@ -0,0 +1,25 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel
+from typing_extensions import TypedDict
+
+
+class OCRPageDimensionsTypedDict(TypedDict):
+    dpi: int
+    r"""Dots per inch of the page-image"""
+    height: int
+    r"""Height of the image in pixels"""
+    width: int
+    r"""Width of the image in pixels"""
+
+
+class OCRPageDimensions(BaseModel):
+    dpi: int
+    r"""Dots per inch of the page-image"""
+
+    height: int
+    r"""Height of the image in pixels"""
+
+    width: int
+    r"""Width of the image in pixels"""

mistralai/models/ocrpageobject.py

@@ -0,0 +1,64 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .ocrimageobject import OCRImageObject, OCRImageObjectTypedDict
+from .ocrpagedimensions import OCRPageDimensions, OCRPageDimensionsTypedDict
+from mistralai.types import BaseModel, Nullable, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import List
+from typing_extensions import TypedDict
+
+
+class OCRPageObjectTypedDict(TypedDict):
+    index: int
+    r"""The page index in a pdf document starting from 0"""
+    markdown: str
+    r"""The markdown string response of the page"""
+    images: List[OCRImageObjectTypedDict]
+    r"""List of all extracted images in the page"""
+    dimensions: Nullable[OCRPageDimensionsTypedDict]
+    r"""The dimensions of the PDF Page's screenshot image"""
+
+
+class OCRPageObject(BaseModel):
+    index: int
+    r"""The page index in a pdf document starting from 0"""
+
+    markdown: str
+    r"""The markdown string response of the page"""
+
+    images: List[OCRImageObject]
+    r"""List of all extracted images in the page"""
+
+    dimensions: Nullable[OCRPageDimensions]
+    r"""The dimensions of the PDF Page's screenshot image"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = []
+        nullable_fields = ["dimensions"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in 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/ocrrequest.py

@@ -0,0 +1,97 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .documenturlchunk import DocumentURLChunk, DocumentURLChunkTypedDict
+from .imageurlchunk import ImageURLChunk, ImageURLChunkTypedDict
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import List, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
+
+
+DocumentTypedDict = TypeAliasType(
+    "DocumentTypedDict", Union[ImageURLChunkTypedDict, DocumentURLChunkTypedDict]
+)
+r"""Document to run OCR on"""
+
+
+Document = TypeAliasType("Document", Union[ImageURLChunk, DocumentURLChunk])
+r"""Document to run OCR on"""
+
+
+class OCRRequestTypedDict(TypedDict):
+    model: Nullable[str]
+    document: DocumentTypedDict
+    r"""Document to run OCR on"""
+    id: NotRequired[str]
+    pages: NotRequired[Nullable[List[int]]]
+    r"""Specific pages user wants to process in various formats: single number, range, or list of both. Starts from 0"""
+    include_image_base64: NotRequired[Nullable[bool]]
+    r"""Include image URLs in response"""
+    image_limit: NotRequired[Nullable[int]]
+    r"""Max images to extract"""
+    image_min_size: NotRequired[Nullable[int]]
+    r"""Minimum height and width of image to extract"""
+
+
+class OCRRequest(BaseModel):
+    model: Nullable[str]
+
+    document: Document
+    r"""Document to run OCR on"""
+
+    id: Optional[str] = None
+
+    pages: OptionalNullable[List[int]] = UNSET
+    r"""Specific pages user wants to process in various formats: single number, range, or list of both. Starts from 0"""
+
+    include_image_base64: OptionalNullable[bool] = UNSET
+    r"""Include image URLs in response"""
+
+    image_limit: OptionalNullable[int] = UNSET
+    r"""Max images to extract"""
+
+    image_min_size: OptionalNullable[int] = UNSET
+    r"""Minimum height and width of image to extract"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "id",
+            "pages",
+            "include_image_base64",
+            "image_limit",
+            "image_min_size",
+        ]
+        nullable_fields = [
+            "model",
+            "pages",
+            "include_image_base64",
+            "image_limit",
+            "image_min_size",
+        ]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in 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/ocrresponse.py

@@ -0,0 +1,26 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .ocrpageobject import OCRPageObject, OCRPageObjectTypedDict
+from .ocrusageinfo import OCRUsageInfo, OCRUsageInfoTypedDict
+from mistralai.types import BaseModel
+from typing import List
+from typing_extensions import TypedDict
+
+
+class OCRResponseTypedDict(TypedDict):
+    pages: List[OCRPageObjectTypedDict]
+    r"""List of OCR info for pages."""
+    model: str
+    r"""The model used to generate the OCR."""
+    usage_info: OCRUsageInfoTypedDict
+
+
+class OCRResponse(BaseModel):
+    pages: List[OCRPageObject]
+    r"""List of OCR info for pages."""
+
+    model: str
+    r"""The model used to generate the OCR."""
+
+    usage_info: OCRUsageInfo

mistralai/models/ocrusageinfo.py

@@ -0,0 +1,51 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing_extensions import NotRequired, TypedDict
+
+
+class OCRUsageInfoTypedDict(TypedDict):
+    pages_processed: int
+    r"""Number of pages processed"""
+    doc_size_bytes: NotRequired[Nullable[int]]
+    r"""Document size in bytes"""
+
+
+class OCRUsageInfo(BaseModel):
+    pages_processed: int
+    r"""Number of pages processed"""
+
+    doc_size_bytes: OptionalNullable[int] = UNSET
+    r"""Document size in bytes"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["doc_size_bytes"]
+        nullable_fields = ["doc_size_bytes"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in 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/prediction.py

@@ -9,17 +9,16 @@ from typing import Literal, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
-PredictionType = Literal["content"]
-
-
 class PredictionTypedDict(TypedDict):
-    type: PredictionType
+    type: Literal["content"]
     content: NotRequired[str]
 
 
 class Prediction(BaseModel):
     TYPE: Annotated[
-        Annotated[Optional[PredictionType], AfterValidator(validate_const("content"))],
+        Annotated[
+            Optional[Literal["content"]], AfterValidator(validate_const("content"))
+        ],
         pydantic.Field(alias="type"),
     ] = "content"
 

mistralai/models/responseformat.py

@@ -1,8 +1,10 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .jsonschema import JSONSchema, JSONSchemaTypedDict
 from .responseformats import ResponseFormats
-from mistralai.types import BaseModel
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
 from typing import Optional
 from typing_extensions import NotRequired, TypedDict
 
@@ -10,8 +12,41 @@ from typing_extensions import NotRequired, TypedDict
 class ResponseFormatTypedDict(TypedDict):
     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):
     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
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["type", "json_schema"]
+        nullable_fields = ["json_schema"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in 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/responseformats.py

@@ -4,5 +4,5 @@ from __future__ import annotations
 from typing import Literal
 
 
-ResponseFormats = Literal["text", "json_object"]
+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."""