mistralai 1.5.0__py3-none-any.whl → 1.5.2rc1__py3-none-any.whl

mistralai/models/chatcompletionstreamrequest.py

@@ -63,7 +63,7 @@ ChatCompletionStreamRequestToolChoice = TypeAliasType(
 
 
 class ChatCompletionStreamRequestTypedDict(TypedDict):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. You can use the [List Available Models](/api/#tag/models/operation/list_models_v1_models_get) API to see all of your available models, or see our [Model overview](/models) for model descriptions."""
     messages: List[ChatCompletionStreamRequestMessagesTypedDict]
     r"""The prompt(s) to generate completions for, encoded as a list of dict with role and content."""
@@ -93,7 +93,7 @@ class ChatCompletionStreamRequestTypedDict(TypedDict):
 
 
 class ChatCompletionStreamRequest(BaseModel):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. You can use the [List Available Models](/api/#tag/models/operation/list_models_v1_models_get) API to see all of your available models, or see our [Model overview](/models) for model descriptions."""
 
     messages: List[ChatCompletionStreamRequestMessages]
@@ -154,14 +154,7 @@ class ChatCompletionStreamRequest(BaseModel):
             "prediction",
             "safe_prompt",
         ]
-        nullable_fields = [
-            "model",
-            "temperature",
-            "max_tokens",
-            "random_seed",
-            "tools",
-            "n",
-        ]
+        nullable_fields = ["temperature", "max_tokens", "random_seed", "tools", "n"]
         null_default_fields = []
 
         serialized = handler(self)

mistralai/models/chatmoderationrequest.py

@@ -0,0 +1,86 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .assistantmessage import AssistantMessage, AssistantMessageTypedDict
+from .systemmessage import SystemMessage, SystemMessageTypedDict
+from .toolmessage import ToolMessage, ToolMessageTypedDict
+from .usermessage import UserMessage, UserMessageTypedDict
+from mistralai.types import BaseModel
+from mistralai.utils import get_discriminator
+import pydantic
+from pydantic import Discriminator, Tag
+from typing import List, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+TwoTypedDict = TypeAliasType(
+    "TwoTypedDict",
+    Union[
+        SystemMessageTypedDict,
+        UserMessageTypedDict,
+        AssistantMessageTypedDict,
+        ToolMessageTypedDict,
+    ],
+)
+
+
+Two = Annotated[
+    Union[
+        Annotated[AssistantMessage, Tag("assistant")],
+        Annotated[SystemMessage, Tag("system")],
+        Annotated[ToolMessage, Tag("tool")],
+        Annotated[UserMessage, Tag("user")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "role", "role")),
+]
+
+
+OneTypedDict = TypeAliasType(
+    "OneTypedDict",
+    Union[
+        SystemMessageTypedDict,
+        UserMessageTypedDict,
+        AssistantMessageTypedDict,
+        ToolMessageTypedDict,
+    ],
+)
+
+
+One = Annotated[
+    Union[
+        Annotated[AssistantMessage, Tag("assistant")],
+        Annotated[SystemMessage, Tag("system")],
+        Annotated[ToolMessage, Tag("tool")],
+        Annotated[UserMessage, Tag("user")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "role", "role")),
+]
+
+
+ChatModerationRequestInputsTypedDict = TypeAliasType(
+    "ChatModerationRequestInputsTypedDict",
+    Union[List[OneTypedDict], List[List[TwoTypedDict]]],
+)
+r"""Chat to classify"""
+
+
+ChatModerationRequestInputs = TypeAliasType(
+    "ChatModerationRequestInputs", Union[List[One], List[List[Two]]]
+)
+r"""Chat to classify"""
+
+
+class ChatModerationRequestTypedDict(TypedDict):
+    model: str
+    inputs: ChatModerationRequestInputsTypedDict
+    r"""Chat to classify"""
+    truncate_for_context_length: NotRequired[bool]
+
+
+class ChatModerationRequest(BaseModel):
+    model: str
+
+    inputs: Annotated[ChatModerationRequestInputs, pydantic.Field(alias="input")]
+    r"""Chat to classify"""
+
+    truncate_for_context_length: Optional[bool] = False

mistralai/models/classificationrequest.py

@@ -1,11 +1,10 @@
 """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, Union
-from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+from typing_extensions import Annotated, TypeAliasType, TypedDict
 
 
 ClassificationRequestInputsTypedDict = TypeAliasType(
@@ -21,43 +20,15 @@ r"""Text to classify."""
 
 
 class ClassificationRequestTypedDict(TypedDict):
+    model: str
+    r"""ID of the model to use."""
     inputs: ClassificationRequestInputsTypedDict
     r"""Text to classify."""
-    model: NotRequired[Nullable[str]]
 
 
 class ClassificationRequest(BaseModel):
+    model: str
+    r"""ID of the model to use."""
+
     inputs: Annotated[ClassificationRequestInputs, pydantic.Field(alias="input")]
     r"""Text to classify."""
-
-    model: OptionalNullable[str] = UNSET
-
-    @model_serializer(mode="wrap")
-    def serialize_model(self, handler):
-        optional_fields = ["model"]
-        nullable_fields = ["model"]
-        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/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,56 @@
+"""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 import Literal, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+DocumentURLChunkType = Literal["document_url"]
+
+
+class DocumentURLChunkTypedDict(TypedDict):
+    document_url: str
+    document_name: NotRequired[Nullable[str]]
+    r"""The filename of the document"""
+    type: NotRequired[DocumentURLChunkType]
+
+
+class DocumentURLChunk(BaseModel):
+    document_url: str
+
+    document_name: OptionalNullable[str] = UNSET
+    r"""The filename of the document"""
+
+    type: Optional[DocumentURLChunkType] = "document_url"
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["document_name", "type"]
+        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,11 +1,10 @@
 """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
+from typing import List, Union
+from typing_extensions import Annotated, TypeAliasType, TypedDict
 
 
 InputsTypedDict = TypeAliasType("InputsTypedDict", Union[str, List[str]])
@@ -17,50 +16,15 @@ r"""Text to embed."""
 
 
 class EmbeddingRequestTypedDict(TypedDict):
+    model: str
+    r"""ID of the model to use."""
     inputs: InputsTypedDict
     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):
-    inputs: Annotated[Inputs, pydantic.Field(alias="input")]
-    r"""Text to embed."""
-
-    model: Optional[str] = "mistral-embed"
+    model: str
     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
+    inputs: Annotated[Inputs, pydantic.Field(alias="input")]
+    r"""Text to embed."""

mistralai/models/filepurpose.py

@@ -5,4 +5,4 @@ from mistralai.types import UnrecognizedStr
 from typing import Literal, Union
 
 
-FilePurpose = Union[Literal["fine-tune", "batch"], UnrecognizedStr]
+FilePurpose = Union[Literal["fine-tune", "batch", "ocr"], UnrecognizedStr]

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/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