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

mistralai/models/files_api_routes_upload_fileop.py

@@ -12,17 +12,30 @@ from typing_extensions import Annotated, NotRequired
 
 FilesAPIRoutesUploadFilePurpose = Union[Literal["fine-tune"], UnrecognizedStr]
 
+
 class FileTypedDict(TypedDict):
     file_name: str
     content: Union[bytes, IO[bytes], io.BufferedReader]
     content_type: NotRequired[str]
-    
+
 
 class File(BaseModel):
-    file_name: Annotated[str, pydantic.Field(alias="file"), FieldMetadata(multipart=True)]
-    content: Annotated[Union[bytes, IO[bytes], io.BufferedReader], pydantic.Field(alias=""), FieldMetadata(multipart=MultipartFormMetadata(content=True))]
-    content_type: Annotated[Optional[str], pydantic.Field(alias="Content-Type"), FieldMetadata(multipart=True)] = None
-    
+    file_name: Annotated[
+        str, pydantic.Field(alias="file"), FieldMetadata(multipart=True)
+    ]
+
+    content: Annotated[
+        Union[bytes, IO[bytes], io.BufferedReader],
+        pydantic.Field(alias=""),
+        FieldMetadata(multipart=MultipartFormMetadata(content=True)),
+    ]
+
+    content_type: Annotated[
+        Optional[str],
+        pydantic.Field(alias="Content-Type"),
+        FieldMetadata(multipart=True),
+    ] = None
+
 
 class FilesAPIRoutesUploadFileMultiPartBodyParamsTypedDict(TypedDict):
     file: FileTypedDict
@@ -36,10 +49,14 @@ class FilesAPIRoutesUploadFileMultiPartBodyParamsTypedDict(TypedDict):
     file=@path/to/your/file.jsonl
     ```
     """
-    
+
 
 class FilesAPIRoutesUploadFileMultiPartBodyParams(BaseModel):
-    file: Annotated[File, pydantic.Field(alias=""), FieldMetadata(multipart=MultipartFormMetadata(file=True))]
+    file: Annotated[
+        File,
+        pydantic.Field(alias=""),
+        FieldMetadata(multipart=MultipartFormMetadata(file=True)),
+    ]
     r"""The File object (not file name) to be uploaded.
     To upload a file and specify a custom file name you should format your request as such:
     ```bash
@@ -50,5 +67,7 @@ class FilesAPIRoutesUploadFileMultiPartBodyParams(BaseModel):
     file=@path/to/your/file.jsonl
     ```
     """
+
+    # fmt: off
     PURPOSE: Annotated[Final[Annotated[Optional[FilesAPIRoutesUploadFilePurpose], PlainValidator(validate_open_enum(False))]], pydantic.Field(alias="purpose"), FieldMetadata(multipart=True)] = "fine-tune" # type: ignore
-    
+    # fmt: on

mistralai/models/fileschema.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
 FileSchemaPurpose = Union[Literal["fine-tune"], UnrecognizedStr]
 r"""The intended purpose of the uploaded file. Only accepts fine-tuning (`fine-tune`) for now."""
 
+
 class FileSchemaTypedDict(TypedDict):
     id: str
     r"""The unique identifier of the file."""
@@ -29,25 +37,35 @@ class FileSchemaTypedDict(TypedDict):
     sample_type: SampleType
     source: Source
     num_lines: NotRequired[Nullable[int]]
-    
+
 
 class FileSchema(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[FileSchemaPurpose, 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 FileSchema(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 FileSchema(BaseModel):
                 m[k] = val
 
         return m
-        

mistralai/models/fimcompletionrequest.py

@@ -39,7 +39,7 @@ class FIMCompletionRequestTypedDict(TypedDict):
     r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
     suffix: NotRequired[Nullable[str]]
     r"""Optional text/code that adds more context for the model. When given a `prompt` and a `suffix` the model will fill what is between them. When `suffix` is not provided, the model will simply execute completion starting with `prompt`."""
-    
+
 
 class FIMCompletionRequest(BaseModel):
     model: Nullable[str]
@@ -47,28 +47,46 @@ class FIMCompletionRequest(BaseModel):
     - `codestral-2405`
     - `codestral-latest`
     """
+
     prompt: str
     r"""The text/code to complete."""
+
     temperature: Optional[float] = 0.7
     r"""What sampling temperature to use, between 0.0 and 1.0. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. We generally recommend altering this or `top_p` but not both."""
+
     top_p: Optional[float] = 1
     r"""Nucleus sampling, where the model considers the results of the tokens with `top_p` probability mass. So 0.1 means only the tokens comprising the top 10% probability mass are considered. We generally recommend altering this or `temperature` but not both."""
+
     max_tokens: OptionalNullable[int] = UNSET
     r"""The maximum number of tokens to generate in the completion. The token count of your prompt plus `max_tokens` cannot exceed the model's context length."""
+
     min_tokens: OptionalNullable[int] = UNSET
     r"""The minimum number of tokens to generate in the completion."""
+
     stream: Optional[bool] = False
     r"""Whether to stream back partial progress. If set, tokens will be sent as data-only server-side events as they become available, with the stream terminated by a data: [DONE] message. Otherwise, the server will hold the request open until the timeout or until completion, with the response containing the full result as JSON."""
+
     stop: Optional[FIMCompletionRequestStop] = None
     r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
+
     random_seed: OptionalNullable[int] = UNSET
     r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
+
     suffix: OptionalNullable[str] = UNSET
     r"""Optional text/code that adds more context for the model. When given a `prompt` and a `suffix` the model will fill what is between them. When `suffix` is not provided, the model will simply execute completion starting with `prompt`."""
-    
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["temperature", "top_p", "max_tokens", "min_tokens", "stream", "stop", "random_seed", "suffix"]
+        optional_fields = [
+            "temperature",
+            "top_p",
+            "max_tokens",
+            "min_tokens",
+            "stream",
+            "stop",
+            "random_seed",
+            "suffix",
+        ]
         nullable_fields = ["model", "max_tokens", "min_tokens", "random_seed", "suffix"]
         null_default_fields = []
 
@@ -79,9 +97,13 @@ class FIMCompletionRequest(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
@@ -91,4 +113,3 @@ class FIMCompletionRequest(BaseModel):
                 m[k] = val
 
         return m
-        

mistralai/models/fimcompletionresponse.py

@@ -15,13 +15,17 @@ class FIMCompletionResponseTypedDict(TypedDict):
     usage: UsageInfoTypedDict
     created: NotRequired[int]
     choices: NotRequired[List[ChatCompletionChoiceTypedDict]]
-    
+
 
 class FIMCompletionResponse(BaseModel):
     id: str
+
     object: str
+
     model: str
+
     usage: UsageInfo
+
     created: Optional[int] = None
+
     choices: Optional[List[ChatCompletionChoice]] = None
-    

mistralai/models/fimcompletionstreamrequest.py

@@ -38,7 +38,7 @@ class FIMCompletionStreamRequestTypedDict(TypedDict):
     r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
     suffix: NotRequired[Nullable[str]]
     r"""Optional text/code that adds more context for the model. When given a `prompt` and a `suffix` the model will fill what is between them. When `suffix` is not provided, the model will simply execute completion starting with `prompt`."""
-    
+
 
 class FIMCompletionStreamRequest(BaseModel):
     model: Nullable[str]
@@ -46,27 +46,45 @@ class FIMCompletionStreamRequest(BaseModel):
     - `codestral-2405`
     - `codestral-latest`
     """
+
     prompt: str
     r"""The text/code to complete."""
+
     temperature: Optional[float] = 0.7
     r"""What sampling temperature to use, between 0.0 and 1.0. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. We generally recommend altering this or `top_p` but not both."""
+
     top_p: Optional[float] = 1
     r"""Nucleus sampling, where the model considers the results of the tokens with `top_p` probability mass. So 0.1 means only the tokens comprising the top 10% probability mass are considered. We generally recommend altering this or `temperature` but not both."""
+
     max_tokens: OptionalNullable[int] = UNSET
     r"""The maximum number of tokens to generate in the completion. The token count of your prompt plus `max_tokens` cannot exceed the model's context length."""
+
     min_tokens: OptionalNullable[int] = UNSET
     r"""The minimum number of tokens to generate in the completion."""
+
     stream: Optional[bool] = True
+
     stop: Optional[FIMCompletionStreamRequestStop] = None
     r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
+
     random_seed: OptionalNullable[int] = UNSET
     r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
+
     suffix: OptionalNullable[str] = UNSET
     r"""Optional text/code that adds more context for the model. When given a `prompt` and a `suffix` the model will fill what is between them. When `suffix` is not provided, the model will simply execute completion starting with `prompt`."""
-    
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["temperature", "top_p", "max_tokens", "min_tokens", "stream", "stop", "random_seed", "suffix"]
+        optional_fields = [
+            "temperature",
+            "top_p",
+            "max_tokens",
+            "min_tokens",
+            "stream",
+            "stop",
+            "random_seed",
+            "suffix",
+        ]
         nullable_fields = ["model", "max_tokens", "min_tokens", "random_seed", "suffix"]
         null_default_fields = []
 
@@ -77,9 +95,13 @@ class FIMCompletionStreamRequest(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
@@ -89,4 +111,3 @@ class FIMCompletionStreamRequest(BaseModel):
                 m[k] = val
 
         return m
-        

mistralai/models/finetuneablemodel.py

@@ -4,5 +4,11 @@ from __future__ import annotations
 from typing import Literal
 
 
-FineTuneableModel = Literal["open-mistral-7b", "mistral-small-latest", "codestral-latest", "mistral-large-latest", "open-mistral-nemo"]
+FineTuneableModel = Literal[
+    "open-mistral-7b",
+    "mistral-small-latest",
+    "codestral-latest",
+    "mistral-large-latest",
+    "open-mistral-nemo",
+]
 r"""The name of the model to fine-tune."""

mistralai/models/ftmodelcapabilitiesout.py

@@ -11,11 +11,13 @@ class FTModelCapabilitiesOutTypedDict(TypedDict):
     completion_fim: NotRequired[bool]
     function_calling: NotRequired[bool]
     fine_tuning: NotRequired[bool]
-    
+
 
 class FTModelCapabilitiesOut(BaseModel):
     completion_chat: Optional[bool] = True
+
     completion_fim: Optional[bool] = False
+
     function_calling: Optional[bool] = False
+
     fine_tuning: Optional[bool] = False
-    

mistralai/models/ftmodelcard.py

@@ -0,0 +1,103 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .modelcapabilities import ModelCapabilities, ModelCapabilitiesTypedDict
+from datetime import datetime
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+import pydantic
+from pydantic import model_serializer
+from typing import Final, List, Optional, TypedDict
+from typing_extensions import Annotated, NotRequired
+
+
+class FTModelCardTypedDict(TypedDict):
+    r"""Extra fields for fine-tuned models."""
+
+    id: str
+    capabilities: ModelCapabilitiesTypedDict
+    job: str
+    root: str
+    object: NotRequired[str]
+    created: NotRequired[int]
+    owned_by: NotRequired[str]
+    name: NotRequired[Nullable[str]]
+    description: NotRequired[Nullable[str]]
+    max_context_length: NotRequired[int]
+    aliases: NotRequired[List[str]]
+    deprecation: NotRequired[Nullable[datetime]]
+    archived: NotRequired[bool]
+
+
+class FTModelCard(BaseModel):
+    r"""Extra fields for fine-tuned models."""
+
+    id: str
+
+    capabilities: ModelCapabilities
+
+    job: str
+
+    root: str
+
+    object: Optional[str] = "model"
+
+    created: Optional[int] = None
+
+    owned_by: Optional[str] = "mistralai"
+
+    name: OptionalNullable[str] = UNSET
+
+    description: OptionalNullable[str] = UNSET
+
+    max_context_length: Optional[int] = 32768
+
+    aliases: Optional[List[str]] = None
+
+    deprecation: OptionalNullable[datetime] = UNSET
+
+    # fmt: off
+    TYPE: Annotated[Final[Optional[str]], pydantic.Field(alias="type")] = "fine-tuned" # type: ignore
+    # fmt: on
+
+    archived: Optional[bool] = False
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "object",
+            "created",
+            "owned_by",
+            "name",
+            "description",
+            "max_context_length",
+            "aliases",
+            "deprecation",
+            "type",
+            "archived",
+        ]
+        nullable_fields = ["name", "description", "deprecation"]
+        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/ftmodelout.py

@@ -1,7 +1,10 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from .ftmodelcapabilitiesout import FTModelCapabilitiesOut, FTModelCapabilitiesOutTypedDict
+from .ftmodelcapabilitiesout import (
+    FTModelCapabilitiesOut,
+    FTModelCapabilitiesOutTypedDict,
+)
 from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 import pydantic
 from pydantic import model_serializer
@@ -11,6 +14,7 @@ from typing_extensions import Annotated, NotRequired
 
 FTModelOutObject = Literal["model"]
 
+
 class FTModelOutTypedDict(TypedDict):
     id: str
     created: int
@@ -23,25 +27,44 @@ class FTModelOutTypedDict(TypedDict):
     description: NotRequired[Nullable[str]]
     max_context_length: NotRequired[int]
     aliases: NotRequired[List[str]]
-    
+
 
 class FTModelOut(BaseModel):
     id: str
+
     created: int
+
     owned_by: str
+
     root: str
+
     archived: bool
+
     capabilities: FTModelCapabilitiesOut
+
     job: str
+
+    # fmt: off
     OBJECT: Annotated[Final[Optional[FTModelOutObject]], pydantic.Field(alias="object")] = "model" # type: ignore
+    # fmt: on
+
     name: OptionalNullable[str] = UNSET
+
     description: OptionalNullable[str] = UNSET
+
     max_context_length: Optional[int] = 32768
+
     aliases: Optional[List[str]] = None
-    
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["object", "name", "description", "max_context_length", "aliases"]
+        optional_fields = [
+            "object",
+            "name",
+            "description",
+            "max_context_length",
+            "aliases",
+        ]
         nullable_fields = ["name", "description"]
         null_default_fields = []
 
@@ -52,9 +75,13 @@ class FTModelOut(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
@@ -64,4 +91,3 @@ class FTModelOut(BaseModel):
                 m[k] = val
 
         return m
-        

mistralai/models/function.py

@@ -10,10 +10,11 @@ class FunctionTypedDict(TypedDict):
     name: str
     parameters: Dict[str, Any]
     description: NotRequired[str]
-    
+
 
 class Function(BaseModel):
     name: str
+
     parameters: Dict[str, Any]
+
     description: Optional[str] = ""
-    

mistralai/models/functioncall.py

@@ -14,9 +14,9 @@ Arguments = Union[Dict[str, Any], str]
 class FunctionCallTypedDict(TypedDict):
     name: str
     arguments: ArgumentsTypedDict
-    
+
 
 class FunctionCall(BaseModel):
     name: str
+
     arguments: Arguments
-    

mistralai/models/functionname.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 TypedDict
+
+
+class FunctionNameTypedDict(TypedDict):
+    r"""this restriction of `Function` is used to select a specific function to call"""
+
+    name: str
+
+
+class FunctionName(BaseModel):
+    r"""this restriction of `Function` is used to select a specific function to call"""
+
+    name: str

mistralai/models/githubrepositoryin.py

@@ -10,22 +10,30 @@ from typing_extensions import Annotated, NotRequired
 
 GithubRepositoryInType = Literal["github"]
 
+
 class GithubRepositoryInTypedDict(TypedDict):
     name: str
     owner: str
     token: str
     ref: NotRequired[Nullable[str]]
     weight: NotRequired[float]
-    
+
 
 class GithubRepositoryIn(BaseModel):
     name: str
+
     owner: str
+
     token: str
+
+    # fmt: off
     TYPE: Annotated[Final[Optional[GithubRepositoryInType]], pydantic.Field(alias="type")] = "github" # type: ignore
+    # fmt: on
+
     ref: OptionalNullable[str] = UNSET
+
     weight: Optional[float] = 1
-    
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = ["type", "ref", "weight"]
@@ -39,9 +47,13 @@ class GithubRepositoryIn(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
@@ -51,4 +63,3 @@ class GithubRepositoryIn(BaseModel):
                 m[k] = val
 
         return m
-