mistralai 1.0.3__py3-none-any.whl → 1.1.0__py3-none-any.whl

mistralai/models/jobsout.py

@@ -10,13 +10,17 @@ from typing_extensions import Annotated, NotRequired
 
 JobsOutObject = Literal["list"]
 
+
 class JobsOutTypedDict(TypedDict):
     total: int
     data: NotRequired[List[JobOutTypedDict]]
-    
+
 
 class JobsOut(BaseModel):
     total: int
+
     data: Optional[List[JobOut]] = None
+
+    # fmt: off
     OBJECT: Annotated[Final[Optional[JobsOutObject]], pydantic.Field(alias="object")] = "list" # type: ignore
-    
+    # fmt: on

mistralai/models/legacyjobmetadataout.py

@@ -10,6 +10,7 @@ from typing_extensions import Annotated, NotRequired
 
 LegacyJobMetadataOutObject = Literal["job.metadata"]
 
+
 class LegacyJobMetadataOutTypedDict(TypedDict):
     details: str
     expected_duration_seconds: NotRequired[Nullable[int]]
@@ -30,34 +31,69 @@ class LegacyJobMetadataOutTypedDict(TypedDict):
     r"""The number of complete passes through the entire training dataset."""
     training_steps: NotRequired[Nullable[int]]
     r"""The number of training steps to perform. A training step refers to a single update of the model weights during the fine-tuning process. This update is typically calculated using a batch of samples from the training dataset."""
-    
+
 
 class LegacyJobMetadataOut(BaseModel):
     details: str
+
     expected_duration_seconds: OptionalNullable[int] = UNSET
     r"""The approximated time (in seconds) for the fine-tuning process to complete."""
+
     cost: OptionalNullable[float] = UNSET
     r"""The cost of the fine-tuning job."""
+
     cost_currency: OptionalNullable[str] = UNSET
     r"""The currency used for the fine-tuning job cost."""
+
     train_tokens_per_step: OptionalNullable[int] = UNSET
     r"""The number of tokens consumed by one training step."""
+
     train_tokens: OptionalNullable[int] = UNSET
     r"""The total number of tokens used during the fine-tuning process."""
+
     data_tokens: OptionalNullable[int] = UNSET
     r"""The total number of tokens in the training dataset."""
+
     estimated_start_time: OptionalNullable[int] = UNSET
+
     deprecated: Optional[bool] = True
+
     epochs: OptionalNullable[float] = UNSET
     r"""The number of complete passes through the entire training dataset."""
+
     training_steps: OptionalNullable[int] = UNSET
     r"""The number of training steps to perform. A training step refers to a single update of the model weights during the fine-tuning process. This update is typically calculated using a batch of samples from the training dataset."""
+
+    # fmt: off
     OBJECT: Annotated[Final[Optional[LegacyJobMetadataOutObject]], pydantic.Field(alias="object")] = "job.metadata" # type: ignore
-    
+    # fmt: on
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["expected_duration_seconds", "cost", "cost_currency", "train_tokens_per_step", "train_tokens", "data_tokens", "estimated_start_time", "deprecated", "epochs", "training_steps", "object"]
-        nullable_fields = ["expected_duration_seconds", "cost", "cost_currency", "train_tokens_per_step", "train_tokens", "data_tokens", "estimated_start_time", "epochs", "training_steps"]
+        optional_fields = [
+            "expected_duration_seconds",
+            "cost",
+            "cost_currency",
+            "train_tokens_per_step",
+            "train_tokens",
+            "data_tokens",
+            "estimated_start_time",
+            "deprecated",
+            "epochs",
+            "training_steps",
+            "object",
+        ]
+        nullable_fields = [
+            "expected_duration_seconds",
+            "cost",
+            "cost_currency",
+            "train_tokens_per_step",
+            "train_tokens",
+            "data_tokens",
+            "estimated_start_time",
+            "epochs",
+            "training_steps",
+        ]
         null_default_fields = []
 
         serialized = handler(self)
@@ -67,9 +103,13 @@ class LegacyJobMetadataOut(BaseModel):
         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
+            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
@@ -79,4 +119,3 @@ class LegacyJobMetadataOut(BaseModel):
                 m[k] = val
 
         return m
-        

mistralai/models/listfilesout.py

@@ -9,9 +9,9 @@ from typing import List, TypedDict
 class ListFilesOutTypedDict(TypedDict):
     data: List[FileSchemaTypedDict]
     object: str
-    
+
 
 class ListFilesOut(BaseModel):
     data: List[FileSchema]
+
     object: str
-    

mistralai/models/metricout.py

@@ -9,19 +9,21 @@ from typing_extensions import NotRequired
 
 class MetricOutTypedDict(TypedDict):
     r"""Metrics at the step number during the fine-tuning job. Use these metrics to assess if the training is going smoothly (loss should decrease, token accuracy should increase)."""
-    
+
     train_loss: NotRequired[Nullable[float]]
     valid_loss: NotRequired[Nullable[float]]
     valid_mean_token_accuracy: NotRequired[Nullable[float]]
-    
+
 
 class MetricOut(BaseModel):
     r"""Metrics at the step number during the fine-tuning job. Use these metrics to assess if the training is going smoothly (loss should decrease, token accuracy should increase)."""
-    
+
     train_loss: OptionalNullable[float] = UNSET
+
     valid_loss: OptionalNullable[float] = UNSET
+
     valid_mean_token_accuracy: OptionalNullable[float] = UNSET
-    
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = ["train_loss", "valid_loss", "valid_mean_token_accuracy"]
@@ -35,9 +37,13 @@ class MetricOut(BaseModel):
         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
+            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
@@ -47,4 +53,3 @@ class MetricOut(BaseModel):
                 m[k] = val
 
         return m
-        

mistralai/models/modelcapabilities.py

@@ -11,11 +11,16 @@ class ModelCapabilitiesTypedDict(TypedDict):
     completion_fim: NotRequired[bool]
     function_calling: NotRequired[bool]
     fine_tuning: NotRequired[bool]
-    
+    vision: NotRequired[bool]
+
 
 class ModelCapabilities(BaseModel):
     completion_chat: Optional[bool] = True
+
     completion_fim: Optional[bool] = False
+
     function_calling: Optional[bool] = True
+
     fine_tuning: Optional[bool] = False
-    
+
+    vision: Optional[bool] = False

mistralai/models/modellist.py

@@ -1,18 +1,32 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from .modelcard import ModelCard, ModelCardTypedDict
+from .basemodelcard import BaseModelCard, BaseModelCardTypedDict
+from .ftmodelcard import FTModelCard, FTModelCardTypedDict
 from mistralai.types import BaseModel
-from typing import List, Optional, TypedDict
-from typing_extensions import NotRequired
+from mistralai.utils import get_discriminator
+from pydantic import Discriminator, Tag
+from typing import List, Optional, TypedDict, Union
+from typing_extensions import Annotated, NotRequired
+
+
+DataTypedDict = Union[BaseModelCardTypedDict, FTModelCardTypedDict]
+
+
+Data = Annotated[
+    Union[
+        Annotated[BaseModelCard, Tag("base")], Annotated[FTModelCard, Tag("fine-tuned")]
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
 
 
 class ModelListTypedDict(TypedDict):
     object: NotRequired[str]
-    data: NotRequired[List[ModelCardTypedDict]]
-    
+    data: NotRequired[List[DataTypedDict]]
+
 
 class ModelList(BaseModel):
     object: Optional[str] = "list"
-    data: Optional[List[ModelCard]] = None
-    
+
+    data: Optional[List[Data]] = None

mistralai/models/responseformat.py

@@ -1,18 +1,17 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .responseformats import ResponseFormats
 from mistralai.types import BaseModel
-from typing import Literal, Optional, TypedDict
+from typing import Optional, TypedDict
 from typing_extensions import NotRequired
 
 
-ResponseFormats = Literal["text", "json_object"]
-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."""
-
 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."""
+
 
 class ResponseFormat(BaseModel):
-    type: Optional[ResponseFormats] = "text"
-    
+    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."""

mistralai/models/responseformats.py

@@ -0,0 +1,8 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from typing import Literal
+
+
+ResponseFormats = Literal["text", "json_object"]
+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/retrieve_model_v1_models_model_id_getop.py

@@ -1,18 +1,37 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .basemodelcard import BaseModelCard, BaseModelCardTypedDict
+from .ftmodelcard import FTModelCard, FTModelCardTypedDict
 from mistralai.types import BaseModel
-from mistralai.utils import FieldMetadata, PathParamMetadata
-from typing import TypedDict
+from mistralai.utils import FieldMetadata, PathParamMetadata, get_discriminator
+from pydantic import Discriminator, Tag
+from typing import TypedDict, Union
 from typing_extensions import Annotated
 
 
 class RetrieveModelV1ModelsModelIDGetRequestTypedDict(TypedDict):
     model_id: str
     r"""The ID of the model to retrieve."""
-    
+
 
 class RetrieveModelV1ModelsModelIDGetRequest(BaseModel):
-    model_id: Annotated[str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))]
+    model_id: Annotated[
+        str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))
+    ]
     r"""The ID of the model to retrieve."""
-    
+
+
+RetrieveModelV1ModelsModelIDGetResponseRetrieveModelV1ModelsModelIDGetTypedDict = Union[
+    BaseModelCardTypedDict, FTModelCardTypedDict
+]
+r"""Successful Response"""
+
+
+RetrieveModelV1ModelsModelIDGetResponseRetrieveModelV1ModelsModelIDGet = Annotated[
+    Union[
+        Annotated[BaseModelCard, Tag("base")], Annotated[FTModelCard, Tag("fine-tuned")]
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+r"""Successful Response"""

mistralai/models/retrievefileout.py

@@ -3,7 +3,14 @@
 from __future__ import annotations
 from .sampletype import SampleType
 from .source import Source
-from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL, UnrecognizedStr
+from mistralai.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+    UnrecognizedStr,
+)
 from mistralai.utils import validate_open_enum
 import pydantic
 from pydantic import model_serializer
@@ -15,6 +22,7 @@ from typing_extensions import Annotated, NotRequired
 RetrieveFileOutPurpose = Union[Literal["fine-tune"], UnrecognizedStr]
 r"""The intended purpose of the uploaded file. Only accepts fine-tuning (`fine-tune`) for now."""
 
+
 class RetrieveFileOutTypedDict(TypedDict):
     id: str
     r"""The unique identifier of the file."""
@@ -29,25 +37,35 @@ class RetrieveFileOutTypedDict(TypedDict):
     sample_type: SampleType
     source: Source
     num_lines: NotRequired[Nullable[int]]
-    
+
 
 class RetrieveFileOut(BaseModel):
     id: str
     r"""The unique identifier of the file."""
+
     object: str
     r"""The object type, which is always \"file\"."""
+
     bytes: int
     r"""The size of the file, in bytes."""
+
     created_at: int
     r"""The UNIX timestamp (in seconds) of the event."""
+
     filename: str
     r"""The name of the uploaded file."""
+
     sample_type: SampleType
+
     source: Source
+
+    # fmt: off
     PURPOSE: Annotated[Final[Annotated[RetrieveFileOutPurpose, PlainValidator(validate_open_enum(False))]], pydantic.Field(alias="purpose")] = "fine-tune" # type: ignore
+    # fmt: on
     r"""The intended purpose of the uploaded file. Only accepts fine-tuning (`fine-tune`) for now."""
+
     num_lines: OptionalNullable[int] = UNSET
-    
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = ["num_lines"]
@@ -61,9 +79,13 @@ class RetrieveFileOut(BaseModel):
         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
+            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
@@ -73,4 +95,3 @@ class RetrieveFileOut(BaseModel):
                 m[k] = val
 
         return m
-        

mistralai/models/security.py

@@ -9,8 +9,17 @@ from typing_extensions import Annotated, NotRequired
 
 class SecurityTypedDict(TypedDict):
     api_key: NotRequired[str]
-    
+
 
 class Security(BaseModel):
-    api_key: Annotated[Optional[str], FieldMetadata(security=SecurityMetadata(scheme=True, scheme_type="http", sub_type="bearer", field_name="Authorization"))] = None
-    
+    api_key: Annotated[
+        Optional[str],
+        FieldMetadata(
+            security=SecurityMetadata(
+                scheme=True,
+                scheme_type="http",
+                sub_type="bearer",
+                field_name="Authorization",
+            )
+        ),
+    ] = None

mistralai/models/systemmessage.py

@@ -1,26 +1,27 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from .contentchunk import ContentChunk, ContentChunkTypedDict
+from .textchunk import TextChunk, TextChunkTypedDict
 from mistralai.types import BaseModel
 from typing import List, Literal, Optional, TypedDict, Union
 from typing_extensions import NotRequired
 
 
-ContentTypedDict = Union[str, List[ContentChunkTypedDict]]
+ContentTypedDict = Union[str, List[TextChunkTypedDict]]
 
 
-Content = Union[str, List[ContentChunk]]
+Content = Union[str, List[TextChunk]]
 
 
 Role = Literal["system"]
 
+
 class SystemMessageTypedDict(TypedDict):
     content: ContentTypedDict
     role: NotRequired[Role]
-    
+
 
 class SystemMessage(BaseModel):
     content: Content
+
     role: Optional[Role] = "system"
-    

mistralai/models/textchunk.py

@@ -3,15 +3,20 @@
 from __future__ import annotations
 from mistralai.types import BaseModel
 import pydantic
-from typing import Final, Optional, TypedDict
+from typing import Final, Literal, Optional, TypedDict
 from typing_extensions import Annotated
 
 
+TextChunkType = Literal["text"]
+
+
 class TextChunkTypedDict(TypedDict):
     text: str
-    
+
 
 class TextChunk(BaseModel):
     text: str
-    TYPE: Annotated[Final[Optional[str]], pydantic.Field(alias="type")] = "text" # type: ignore
-    
+
+    # fmt: off
+    TYPE: Annotated[Final[Optional[TextChunkType]], pydantic.Field(alias="type")] = "text" # type: ignore
+    # fmt: on

mistralai/models/tool.py

@@ -2,21 +2,22 @@
 
 from __future__ import annotations
 from .function import Function, FunctionTypedDict
-from mistralai.types import BaseModel, UnrecognizedStr
+from .tooltypes import ToolTypes
+from mistralai.types import BaseModel
 from mistralai.utils import validate_open_enum
 from pydantic.functional_validators import PlainValidator
-from typing import Literal, Optional, TypedDict, Union
+from typing import Optional, TypedDict
 from typing_extensions import Annotated, NotRequired
 
 
-ToolToolTypes = Union[Literal["function"], UnrecognizedStr]
-
 class ToolTypedDict(TypedDict):
     function: FunctionTypedDict
-    type: NotRequired[ToolToolTypes]
-    
+    type: NotRequired[ToolTypes]
+
 
 class Tool(BaseModel):
     function: Function
-    type: Annotated[Optional[ToolToolTypes], PlainValidator(validate_open_enum(False))] = "function"
-    
+
+    type: Annotated[Optional[ToolTypes], PlainValidator(validate_open_enum(False))] = (
+        None
+    )

mistralai/models/toolcall.py

@@ -2,23 +2,25 @@
 
 from __future__ import annotations
 from .functioncall import FunctionCall, FunctionCallTypedDict
-from mistralai.types import BaseModel, UnrecognizedStr
+from .tooltypes import ToolTypes
+from mistralai.types import BaseModel
 from mistralai.utils import validate_open_enum
 from pydantic.functional_validators import PlainValidator
-from typing import Literal, Optional, TypedDict, Union
+from typing import Optional, TypedDict
 from typing_extensions import Annotated, NotRequired
 
 
-ToolTypes = Union[Literal["function"], UnrecognizedStr]
-
 class ToolCallTypedDict(TypedDict):
     function: FunctionCallTypedDict
     id: NotRequired[str]
     type: NotRequired[ToolTypes]
-    
+
 
 class ToolCall(BaseModel):
     function: FunctionCall
+
     id: Optional[str] = "null"
-    type: Annotated[Optional[ToolTypes], PlainValidator(validate_open_enum(False))] = "function"
-    
+
+    type: Annotated[Optional[ToolTypes], PlainValidator(validate_open_enum(False))] = (
+        None
+    )

mistralai/models/toolchoice.py

@@ -0,0 +1,29 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .functionname import FunctionName, FunctionNameTypedDict
+from .tooltypes import ToolTypes
+from mistralai.types import BaseModel
+from mistralai.utils import validate_open_enum
+from pydantic.functional_validators import PlainValidator
+from typing import Optional, TypedDict
+from typing_extensions import Annotated, NotRequired
+
+
+class ToolChoiceTypedDict(TypedDict):
+    r"""ToolChoice is either a ToolChoiceEnum or a ToolChoice"""
+
+    function: FunctionNameTypedDict
+    r"""this restriction of `Function` is used to select a specific function to call"""
+    type: NotRequired[ToolTypes]
+
+
+class ToolChoice(BaseModel):
+    r"""ToolChoice is either a ToolChoiceEnum or a ToolChoice"""
+
+    function: FunctionName
+    r"""this restriction of `Function` is used to select a specific function to call"""
+
+    type: Annotated[Optional[ToolTypes], PlainValidator(validate_open_enum(False))] = (
+        None
+    )

mistralai/models/toolchoiceenum.py

@@ -0,0 +1,7 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from typing import Literal
+
+
+ToolChoiceEnum = Literal["auto", "none", "any", "required"]

mistralai/models/toolmessage.py

@@ -9,19 +9,23 @@ from typing_extensions import NotRequired
 
 ToolMessageRole = Literal["tool"]
 
+
 class ToolMessageTypedDict(TypedDict):
     content: str
     tool_call_id: NotRequired[Nullable[str]]
     name: NotRequired[Nullable[str]]
     role: NotRequired[ToolMessageRole]
-    
+
 
 class ToolMessage(BaseModel):
     content: str
+
     tool_call_id: OptionalNullable[str] = UNSET
+
     name: OptionalNullable[str] = UNSET
+
     role: Optional[ToolMessageRole] = "tool"
-    
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = ["tool_call_id", "name", "role"]
@@ -35,9 +39,13 @@ class ToolMessage(BaseModel):
         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
+            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
@@ -47,4 +55,3 @@ class ToolMessage(BaseModel):
                 m[k] = val
 
         return m
-        

mistralai/models/tooltypes.py

@@ -0,0 +1,8 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import UnrecognizedStr
+from typing import Literal, Union
+
+
+ToolTypes = Union[Literal["function"], UnrecognizedStr]

mistralai/models/trainingfile.py

@@ -9,9 +9,9 @@ from typing_extensions import NotRequired
 class TrainingFileTypedDict(TypedDict):
     file_id: str
     weight: NotRequired[float]
-    
+
 
 class TrainingFile(BaseModel):
     file_id: str
+
     weight: Optional[float] = 1
-