mistralai 1.7.0__py3-none-any.whl → 1.8.0__py3-none-any.whl

mistralai/models/functiontool.py

@@ -0,0 +1,21 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .function import Function, FunctionTypedDict
+from mistralai.types import BaseModel
+from typing import Literal, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+FunctionToolType = Literal["function"]
+
+
+class FunctionToolTypedDict(TypedDict):
+    function: FunctionTypedDict
+    type: NotRequired[FunctionToolType]
+
+
+class FunctionTool(BaseModel):
+    function: Function
+
+    type: Optional[FunctionToolType] = "function"

mistralai/models/imagegenerationtool.py

@@ -0,0 +1,17 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel
+from typing import Literal, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+ImageGenerationToolType = Literal["image_generation"]
+
+
+class ImageGenerationToolTypedDict(TypedDict):
+    type: NotRequired[ImageGenerationToolType]
+
+
+class ImageGenerationTool(BaseModel):
+    type: Optional[ImageGenerationToolType] = "image_generation"

mistralai/models/inputentries.py

@@ -0,0 +1,18 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .functionresultentry import FunctionResultEntry, FunctionResultEntryTypedDict
+from .messageinputentry import MessageInputEntry, MessageInputEntryTypedDict
+from typing import Union
+from typing_extensions import TypeAliasType
+
+
+InputEntriesTypedDict = TypeAliasType(
+    "InputEntriesTypedDict",
+    Union[MessageInputEntryTypedDict, FunctionResultEntryTypedDict],
+)
+
+
+InputEntries = TypeAliasType(
+    "InputEntries", Union[MessageInputEntry, FunctionResultEntry]
+)

mistralai/models/messageentries.py

@@ -0,0 +1,18 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .messageinputentry import MessageInputEntry, MessageInputEntryTypedDict
+from .messageoutputentry import MessageOutputEntry, MessageOutputEntryTypedDict
+from typing import Union
+from typing_extensions import TypeAliasType
+
+
+MessageEntriesTypedDict = TypeAliasType(
+    "MessageEntriesTypedDict",
+    Union[MessageInputEntryTypedDict, MessageOutputEntryTypedDict],
+)
+
+
+MessageEntries = TypeAliasType(
+    "MessageEntries", Union[MessageInputEntry, MessageOutputEntry]
+)

mistralai/models/messageinputcontentchunks.py

@@ -0,0 +1,26 @@
+"""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 .textchunk import TextChunk, TextChunkTypedDict
+from .toolfilechunk import ToolFileChunk, ToolFileChunkTypedDict
+from typing import Union
+from typing_extensions import TypeAliasType
+
+
+MessageInputContentChunksTypedDict = TypeAliasType(
+    "MessageInputContentChunksTypedDict",
+    Union[
+        TextChunkTypedDict,
+        ImageURLChunkTypedDict,
+        DocumentURLChunkTypedDict,
+        ToolFileChunkTypedDict,
+    ],
+)
+
+
+MessageInputContentChunks = TypeAliasType(
+    "MessageInputContentChunks",
+    Union[TextChunk, ImageURLChunk, DocumentURLChunk, ToolFileChunk],
+)

mistralai/models/messageinputentry.py

@@ -0,0 +1,89 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .messageinputcontentchunks import (
+    MessageInputContentChunks,
+    MessageInputContentChunksTypedDict,
+)
+from datetime import datetime
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import List, Literal, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
+
+
+Object = Literal["entry"]
+
+MessageInputEntryType = Literal["message.input"]
+
+MessageInputEntryRole = Literal["assistant", "user"]
+
+MessageInputEntryContentTypedDict = TypeAliasType(
+    "MessageInputEntryContentTypedDict",
+    Union[str, List[MessageInputContentChunksTypedDict]],
+)
+
+
+MessageInputEntryContent = TypeAliasType(
+    "MessageInputEntryContent", Union[str, List[MessageInputContentChunks]]
+)
+
+
+class MessageInputEntryTypedDict(TypedDict):
+    r"""Representation of an input message inside the conversation."""
+
+    role: MessageInputEntryRole
+    content: MessageInputEntryContentTypedDict
+    object: NotRequired[Object]
+    type: NotRequired[MessageInputEntryType]
+    created_at: NotRequired[datetime]
+    completed_at: NotRequired[Nullable[datetime]]
+    id: NotRequired[str]
+
+
+class MessageInputEntry(BaseModel):
+    r"""Representation of an input message inside the conversation."""
+
+    role: MessageInputEntryRole
+
+    content: MessageInputEntryContent
+
+    object: Optional[Object] = "entry"
+
+    type: Optional[MessageInputEntryType] = "message.input"
+
+    created_at: Optional[datetime] = None
+
+    completed_at: OptionalNullable[datetime] = UNSET
+
+    id: Optional[str] = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["object", "type", "created_at", "completed_at", "id"]
+        nullable_fields = ["completed_at"]
+        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/messageoutputcontentchunks.py

@@ -0,0 +1,30 @@
+"""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 .textchunk import TextChunk, TextChunkTypedDict
+from .toolfilechunk import ToolFileChunk, ToolFileChunkTypedDict
+from .toolreferencechunk import ToolReferenceChunk, ToolReferenceChunkTypedDict
+from typing import Union
+from typing_extensions import TypeAliasType
+
+
+MessageOutputContentChunksTypedDict = TypeAliasType(
+    "MessageOutputContentChunksTypedDict",
+    Union[
+        TextChunkTypedDict,
+        ImageURLChunkTypedDict,
+        DocumentURLChunkTypedDict,
+        ToolFileChunkTypedDict,
+        ToolReferenceChunkTypedDict,
+    ],
+)
+
+
+MessageOutputContentChunks = TypeAliasType(
+    "MessageOutputContentChunks",
+    Union[
+        TextChunk, ImageURLChunk, DocumentURLChunk, ToolFileChunk, ToolReferenceChunk
+    ],
+)

mistralai/models/messageoutputentry.py

@@ -0,0 +1,100 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .messageoutputcontentchunks import (
+    MessageOutputContentChunks,
+    MessageOutputContentChunksTypedDict,
+)
+from datetime import datetime
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import List, Literal, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
+
+
+MessageOutputEntryObject = Literal["entry"]
+
+MessageOutputEntryType = Literal["message.output"]
+
+MessageOutputEntryRole = Literal["assistant"]
+
+MessageOutputEntryContentTypedDict = TypeAliasType(
+    "MessageOutputEntryContentTypedDict",
+    Union[str, List[MessageOutputContentChunksTypedDict]],
+)
+
+
+MessageOutputEntryContent = TypeAliasType(
+    "MessageOutputEntryContent", Union[str, List[MessageOutputContentChunks]]
+)
+
+
+class MessageOutputEntryTypedDict(TypedDict):
+    content: MessageOutputEntryContentTypedDict
+    object: NotRequired[MessageOutputEntryObject]
+    type: NotRequired[MessageOutputEntryType]
+    created_at: NotRequired[datetime]
+    completed_at: NotRequired[Nullable[datetime]]
+    id: NotRequired[str]
+    agent_id: NotRequired[Nullable[str]]
+    model: NotRequired[Nullable[str]]
+    role: NotRequired[MessageOutputEntryRole]
+
+
+class MessageOutputEntry(BaseModel):
+    content: MessageOutputEntryContent
+
+    object: Optional[MessageOutputEntryObject] = "entry"
+
+    type: Optional[MessageOutputEntryType] = "message.output"
+
+    created_at: Optional[datetime] = None
+
+    completed_at: OptionalNullable[datetime] = UNSET
+
+    id: Optional[str] = None
+
+    agent_id: OptionalNullable[str] = UNSET
+
+    model: OptionalNullable[str] = UNSET
+
+    role: Optional[MessageOutputEntryRole] = "assistant"
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "object",
+            "type",
+            "created_at",
+            "completed_at",
+            "id",
+            "agent_id",
+            "model",
+            "role",
+        ]
+        nullable_fields = ["completed_at", "agent_id", "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/messageoutputevent.py

@@ -0,0 +1,93 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .outputcontentchunks import OutputContentChunks, OutputContentChunksTypedDict
+from datetime import datetime
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Literal, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
+
+
+MessageOutputEventType = Literal["message.output.delta"]
+
+MessageOutputEventRole = Literal["assistant"]
+
+MessageOutputEventContentTypedDict = TypeAliasType(
+    "MessageOutputEventContentTypedDict", Union[str, OutputContentChunksTypedDict]
+)
+
+
+MessageOutputEventContent = TypeAliasType(
+    "MessageOutputEventContent", Union[str, OutputContentChunks]
+)
+
+
+class MessageOutputEventTypedDict(TypedDict):
+    id: str
+    content: MessageOutputEventContentTypedDict
+    type: NotRequired[MessageOutputEventType]
+    created_at: NotRequired[datetime]
+    output_index: NotRequired[int]
+    content_index: NotRequired[int]
+    model: NotRequired[Nullable[str]]
+    agent_id: NotRequired[Nullable[str]]
+    role: NotRequired[MessageOutputEventRole]
+
+
+class MessageOutputEvent(BaseModel):
+    id: str
+
+    content: MessageOutputEventContent
+
+    type: Optional[MessageOutputEventType] = "message.output.delta"
+
+    created_at: Optional[datetime] = None
+
+    output_index: Optional[int] = 0
+
+    content_index: Optional[int] = 0
+
+    model: OptionalNullable[str] = UNSET
+
+    agent_id: OptionalNullable[str] = UNSET
+
+    role: Optional[MessageOutputEventRole] = "assistant"
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "type",
+            "created_at",
+            "output_index",
+            "content_index",
+            "model",
+            "agent_id",
+            "role",
+        ]
+        nullable_fields = ["model", "agent_id"]
+        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/modelconversation.py

@@ -0,0 +1,127 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .codeinterpretertool import CodeInterpreterTool, CodeInterpreterToolTypedDict
+from .completionargs import CompletionArgs, CompletionArgsTypedDict
+from .documentlibrarytool import DocumentLibraryTool, DocumentLibraryToolTypedDict
+from .functiontool import FunctionTool, FunctionToolTypedDict
+from .imagegenerationtool import ImageGenerationTool, ImageGenerationToolTypedDict
+from .websearchpremiumtool import WebSearchPremiumTool, WebSearchPremiumToolTypedDict
+from .websearchtool import WebSearchTool, WebSearchToolTypedDict
+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_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+ModelConversationToolsTypedDict = TypeAliasType(
+    "ModelConversationToolsTypedDict",
+    Union[
+        WebSearchToolTypedDict,
+        WebSearchPremiumToolTypedDict,
+        CodeInterpreterToolTypedDict,
+        ImageGenerationToolTypedDict,
+        FunctionToolTypedDict,
+        DocumentLibraryToolTypedDict,
+    ],
+)
+
+
+ModelConversationTools = Annotated[
+    Union[
+        Annotated[CodeInterpreterTool, Tag("code_interpreter")],
+        Annotated[DocumentLibraryTool, Tag("document_library")],
+        Annotated[FunctionTool, Tag("function")],
+        Annotated[ImageGenerationTool, Tag("image_generation")],
+        Annotated[WebSearchTool, Tag("web_search")],
+        Annotated[WebSearchPremiumTool, Tag("web_search_premium")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+ModelConversationObject = Literal["conversation"]
+
+
+class ModelConversationTypedDict(TypedDict):
+    id: str
+    created_at: datetime
+    updated_at: datetime
+    model: str
+    instructions: NotRequired[Nullable[str]]
+    r"""Instruction prompt the model will follow during the conversation."""
+    tools: NotRequired[List[ModelConversationToolsTypedDict]]
+    r"""List of tools which are available to the model during the conversation."""
+    completion_args: NotRequired[CompletionArgsTypedDict]
+    r"""White-listed arguments from the completion API"""
+    name: NotRequired[Nullable[str]]
+    r"""Name given to the conversation."""
+    description: NotRequired[Nullable[str]]
+    r"""Description of the what the conversation is about."""
+    object: NotRequired[ModelConversationObject]
+
+
+class ModelConversation(BaseModel):
+    id: str
+
+    created_at: datetime
+
+    updated_at: datetime
+
+    model: str
+
+    instructions: OptionalNullable[str] = UNSET
+    r"""Instruction prompt the model will follow during the conversation."""
+
+    tools: Optional[List[ModelConversationTools]] = None
+    r"""List of tools which are available to the model during the conversation."""
+
+    completion_args: Optional[CompletionArgs] = None
+    r"""White-listed arguments from the completion API"""
+
+    name: OptionalNullable[str] = UNSET
+    r"""Name given to the conversation."""
+
+    description: OptionalNullable[str] = UNSET
+    r"""Description of the what the conversation is about."""
+
+    object: Optional[ModelConversationObject] = "conversation"
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "instructions",
+            "tools",
+            "completion_args",
+            "name",
+            "description",
+            "object",
+        ]
+        nullable_fields = ["instructions", "name", "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

@@ -19,6 +19,8 @@ class OCRImageObjectTypedDict(TypedDict):
     r"""Y coordinate of bottom-right corner of the extracted image"""
     image_base64: NotRequired[Nullable[str]]
     r"""Base64 string of the extracted image"""
+    image_annotation: NotRequired[Nullable[str]]
+    r"""Annotation of the extracted image in json str"""
 
 
 class OCRImageObject(BaseModel):
@@ -40,15 +42,19 @@ class OCRImageObject(BaseModel):
     image_base64: OptionalNullable[str] = UNSET
     r"""Base64 string of the extracted image"""
 
+    image_annotation: OptionalNullable[str] = UNSET
+    r"""Annotation of the extracted image in json str"""
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["image_base64"]
+        optional_fields = ["image_base64", "image_annotation"]
         nullable_fields = [
             "top_left_x",
             "top_left_y",
             "bottom_right_x",
             "bottom_right_y",
             "image_base64",
+            "image_annotation",
         ]
         null_default_fields = []
 

mistralai/models/ocrrequest.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 from .documenturlchunk import DocumentURLChunk, DocumentURLChunkTypedDict
 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
@@ -32,6 +33,10 @@ class OCRRequestTypedDict(TypedDict):
     r"""Max images to extract"""
     image_min_size: NotRequired[Nullable[int]]
     r"""Minimum height and width of image to extract"""
+    bbox_annotation_format: NotRequired[Nullable[ResponseFormatTypedDict]]
+    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"""
 
 
 class OCRRequest(BaseModel):
@@ -54,6 +59,12 @@ class OCRRequest(BaseModel):
     image_min_size: OptionalNullable[int] = UNSET
     r"""Minimum height and width of image to extract"""
 
+    bbox_annotation_format: OptionalNullable[ResponseFormat] = UNSET
+    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: OptionalNullable[ResponseFormat] = UNSET
+    r"""Structured output class for extracting useful information from the entire document. Only json_schema is valid for this field"""
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = [
@@ -62,6 +73,8 @@ class OCRRequest(BaseModel):
             "include_image_base64",
             "image_limit",
             "image_min_size",
+            "bbox_annotation_format",
+            "document_annotation_format",
         ]
         nullable_fields = [
             "model",
@@ -69,6 +82,8 @@ class OCRRequest(BaseModel):
             "include_image_base64",
             "image_limit",
             "image_min_size",
+            "bbox_annotation_format",
+            "document_annotation_format",
         ]
         null_default_fields = []
 

mistralai/models/ocrresponse.py

@@ -3,9 +3,10 @@
 from __future__ import annotations
 from .ocrpageobject import OCRPageObject, OCRPageObjectTypedDict
 from .ocrusageinfo import OCRUsageInfo, OCRUsageInfoTypedDict
-from mistralai.types import BaseModel
+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_extensions import NotRequired, TypedDict
 
 
 class OCRResponseTypedDict(TypedDict):
@@ -14,6 +15,8 @@ class OCRResponseTypedDict(TypedDict):
     model: str
     r"""The model used to generate the OCR."""
     usage_info: OCRUsageInfoTypedDict
+    document_annotation: NotRequired[Nullable[str]]
+    r"""Formatted response in the request_format if provided in json str"""
 
 
 class OCRResponse(BaseModel):
@@ -24,3 +27,36 @@ class OCRResponse(BaseModel):
     r"""The model used to generate the OCR."""
 
     usage_info: OCRUsageInfo
+
+    document_annotation: OptionalNullable[str] = UNSET
+    r"""Formatted response in the request_format if provided in json str"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["document_annotation"]
+        nullable_fields = ["document_annotation"]
+        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