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

mistralai/models/detailedjobout.py

@@ -9,13 +9,26 @@ from .jobmetadataout import JobMetadataOut, JobMetadataOutTypedDict
 from .trainingparameters import TrainingParameters, TrainingParametersTypedDict
 from .wandbintegrationout import WandbIntegrationOut, WandbIntegrationOutTypedDict
 from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from mistralai.utils import validate_const
 import pydantic
 from pydantic import model_serializer
-from typing import Final, List, Literal, Optional, TypedDict
-from typing_extensions import Annotated, NotRequired
-
-
-DetailedJobOutStatus = Literal["QUEUED", "STARTED", "VALIDATING", "VALIDATED", "RUNNING", "FAILED_VALIDATION", "FAILED", "SUCCESS", "CANCELLED", "CANCELLATION_REQUESTED"]
+from pydantic.functional_validators import AfterValidator
+from typing import List, Literal, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+DetailedJobOutStatus = Literal[
+    "QUEUED",
+    "STARTED",
+    "VALIDATING",
+    "VALIDATED",
+    "RUNNING",
+    "FAILED_VALIDATION",
+    "FAILED",
+    "SUCCESS",
+    "CANCELLED",
+    "CANCELLATION_REQUESTED",
+]
 
 DetailedJobOutObject = Literal["job"]
 
@@ -43,6 +56,7 @@ class DetailedJobOutTypedDict(TypedDict):
     modified_at: int
     training_files: List[str]
     validation_files: NotRequired[Nullable[List[str]]]
+    object: DetailedJobOutObject
     fine_tuned_model: NotRequired[Nullable[str]]
     suffix: NotRequired[Nullable[str]]
     integrations: NotRequired[Nullable[List[DetailedJobOutIntegrationsTypedDict]]]
@@ -52,35 +66,76 @@ class DetailedJobOutTypedDict(TypedDict):
     events: NotRequired[List[EventOutTypedDict]]
     r"""Event items are created every time the status of a fine-tuning job changes. The timestamped list of all events is accessible here."""
     checkpoints: NotRequired[List[CheckpointOutTypedDict]]
-    
+
 
 class DetailedJobOut(BaseModel):
     id: str
+
     auto_start: bool
+
     hyperparameters: TrainingParameters
+
     model: FineTuneableModel
     r"""The name of the model to fine-tune."""
+
     status: DetailedJobOutStatus
+
     job_type: str
+
     created_at: int
+
     modified_at: int
+
     training_files: List[str]
+
     validation_files: OptionalNullable[List[str]] = UNSET
-    OBJECT: Annotated[Final[Optional[DetailedJobOutObject]], pydantic.Field(alias="object")] = "job" # type: ignore
+
+    OBJECT: Annotated[
+        Annotated[
+            Optional[DetailedJobOutObject], AfterValidator(validate_const("job"))
+        ],
+        pydantic.Field(alias="object"),
+    ] = "job"
+
     fine_tuned_model: OptionalNullable[str] = UNSET
+
     suffix: OptionalNullable[str] = UNSET
+
     integrations: OptionalNullable[List[DetailedJobOutIntegrations]] = UNSET
+
     trained_tokens: OptionalNullable[int] = UNSET
+
     repositories: Optional[List[DetailedJobOutRepositories]] = None
+
     metadata: OptionalNullable[JobMetadataOut] = UNSET
+
     events: Optional[List[EventOut]] = None
     r"""Event items are created every time the status of a fine-tuning job changes. The timestamped list of all events is accessible here."""
+
     checkpoints: Optional[List[CheckpointOut]] = None
-    
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["validation_files", "object", "fine_tuned_model", "suffix", "integrations", "trained_tokens", "repositories", "metadata", "events", "checkpoints"]
-        nullable_fields = ["validation_files", "fine_tuned_model", "suffix", "integrations", "trained_tokens", "metadata"]
+        optional_fields = [
+            "validation_files",
+            "object",
+            "fine_tuned_model",
+            "suffix",
+            "integrations",
+            "trained_tokens",
+            "repositories",
+            "metadata",
+            "events",
+            "checkpoints",
+        ]
+        nullable_fields = [
+            "validation_files",
+            "fine_tuned_model",
+            "suffix",
+            "integrations",
+            "trained_tokens",
+            "metadata",
+        ]
         null_default_fields = []
 
         serialized = handler(self)
@@ -90,9 +145,13 @@ class DetailedJobOut(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
@@ -102,4 +161,3 @@ class DetailedJobOut(BaseModel):
                 m[k] = val
 
         return m
-        

mistralai/models/embeddingrequest.py

@@ -4,8 +4,8 @@ from __future__ import annotations
 from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 import pydantic
 from pydantic import model_serializer
-from typing import List, TypedDict, Union
-from typing_extensions import Annotated, NotRequired
+from typing import List, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 InputsTypedDict = Union[str, List[str]]
@@ -19,23 +19,25 @@ r"""Text to embed."""
 class EmbeddingRequestTypedDict(TypedDict):
     inputs: InputsTypedDict
     r"""Text to embed."""
-    model: str
+    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: str
+
+    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 = ["encoding_format"]
+        optional_fields = ["model", "encoding_format"]
         nullable_fields = ["encoding_format"]
         null_default_fields = []
 
@@ -46,9 +48,13 @@ class EmbeddingRequest(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
@@ -58,4 +64,3 @@ class EmbeddingRequest(BaseModel):
                 m[k] = val
 
         return m
-        

mistralai/models/embeddingresponse.py

@@ -4,7 +4,8 @@ from __future__ import annotations
 from .embeddingresponsedata import EmbeddingResponseData, EmbeddingResponseDataTypedDict
 from .usageinfo import UsageInfo, UsageInfoTypedDict
 from mistralai.types import BaseModel
-from typing import List, TypedDict
+from typing import List
+from typing_extensions import TypedDict
 
 
 class EmbeddingResponseTypedDict(TypedDict):
@@ -13,12 +14,15 @@ class EmbeddingResponseTypedDict(TypedDict):
     model: str
     usage: UsageInfoTypedDict
     data: List[EmbeddingResponseDataTypedDict]
-    
+
 
 class EmbeddingResponse(BaseModel):
     id: str
+
     object: str
+
     model: str
+
     usage: UsageInfo
+
     data: List[EmbeddingResponseData]
-    

mistralai/models/embeddingresponsedata.py

@@ -2,18 +2,19 @@
 
 from __future__ import annotations
 from mistralai.types import BaseModel
-from typing import List, Optional, TypedDict
-from typing_extensions import NotRequired
+from typing import List, Optional
+from typing_extensions import NotRequired, TypedDict
 
 
 class EmbeddingResponseDataTypedDict(TypedDict):
     object: NotRequired[str]
     embedding: NotRequired[List[float]]
     index: NotRequired[int]
-    
+
 
 class EmbeddingResponseData(BaseModel):
     object: Optional[str] = None
+
     embedding: Optional[List[float]] = None
+
     index: Optional[int] = None
-    

mistralai/models/eventout.py

@@ -3,8 +3,8 @@
 from __future__ import annotations
 from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from pydantic import model_serializer
-from typing import Any, Dict, TypedDict
-from typing_extensions import NotRequired
+from typing import Any, Dict
+from typing_extensions import NotRequired, TypedDict
 
 
 class EventOutTypedDict(TypedDict):
@@ -13,15 +13,17 @@ class EventOutTypedDict(TypedDict):
     created_at: int
     r"""The UNIX timestamp (in seconds) of the event."""
     data: NotRequired[Nullable[Dict[str, Any]]]
-    
+
 
 class EventOut(BaseModel):
     name: str
     r"""The name of the event."""
+
     created_at: int
     r"""The UNIX timestamp (in seconds) of the event."""
+
     data: OptionalNullable[Dict[str, Any]] = UNSET
-    
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = ["data"]
@@ -35,9 +37,13 @@ class EventOut(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 EventOut(BaseModel):
                 m[k] = val
 
         return m
-        

mistralai/models/filepurpose.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
+
+
+FilePurpose = Union[Literal["fine-tune", "batch"], UnrecognizedStr]

mistralai/models/files_api_routes_delete_fileop.py

@@ -3,14 +3,14 @@
 from __future__ import annotations
 from mistralai.types import BaseModel
 from mistralai.utils import FieldMetadata, PathParamMetadata
-from typing import TypedDict
-from typing_extensions import Annotated
+from typing_extensions import Annotated, TypedDict
 
 
 class FilesAPIRoutesDeleteFileRequestTypedDict(TypedDict):
     file_id: str
-    
+
 
 class FilesAPIRoutesDeleteFileRequest(BaseModel):
-    file_id: Annotated[str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))]
-    
+    file_id: Annotated[
+        str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))
+    ]

mistralai/models/files_api_routes_download_fileop.py

@@ -0,0 +1,16 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel
+from mistralai.utils import FieldMetadata, PathParamMetadata
+from typing_extensions import Annotated, TypedDict
+
+
+class FilesAPIRoutesDownloadFileRequestTypedDict(TypedDict):
+    file_id: str
+
+
+class FilesAPIRoutesDownloadFileRequest(BaseModel):
+    file_id: Annotated[
+        str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))
+    ]

mistralai/models/files_api_routes_list_filesop.py

@@ -0,0 +1,96 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .filepurpose import FilePurpose
+from .sampletype import SampleType
+from .source import Source
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from mistralai.utils import FieldMetadata, QueryParamMetadata, validate_open_enum
+from pydantic import model_serializer
+from pydantic.functional_validators import PlainValidator
+from typing import List, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class FilesAPIRoutesListFilesRequestTypedDict(TypedDict):
+    page: NotRequired[int]
+    page_size: NotRequired[int]
+    sample_type: NotRequired[Nullable[List[SampleType]]]
+    source: NotRequired[Nullable[List[Source]]]
+    search: NotRequired[Nullable[str]]
+    purpose: NotRequired[Nullable[FilePurpose]]
+
+
+class FilesAPIRoutesListFilesRequest(BaseModel):
+    page: Annotated[
+        Optional[int],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = 0
+
+    page_size: Annotated[
+        Optional[int],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = 100
+
+    sample_type: Annotated[
+        OptionalNullable[
+            List[Annotated[SampleType, PlainValidator(validate_open_enum(False))]]
+        ],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = UNSET
+
+    source: Annotated[
+        OptionalNullable[
+            List[Annotated[Source, PlainValidator(validate_open_enum(False))]]
+        ],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = UNSET
+
+    search: Annotated[
+        OptionalNullable[str],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = UNSET
+
+    purpose: Annotated[
+        Annotated[
+            OptionalNullable[FilePurpose], PlainValidator(validate_open_enum(False))
+        ],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "page",
+            "page_size",
+            "sample_type",
+            "source",
+            "search",
+            "purpose",
+        ]
+        nullable_fields = ["sample_type", "source", "search", "purpose"]
+        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/files_api_routes_retrieve_fileop.py

@@ -3,14 +3,14 @@
 from __future__ import annotations
 from mistralai.types import BaseModel
 from mistralai.utils import FieldMetadata, PathParamMetadata
-from typing import TypedDict
-from typing_extensions import Annotated
+from typing_extensions import Annotated, TypedDict
 
 
 class FilesAPIRoutesRetrieveFileRequestTypedDict(TypedDict):
     file_id: str
-    
+
 
 class FilesAPIRoutesRetrieveFileRequest(BaseModel):
-    file_id: Annotated[str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))]
-    
+    file_id: Annotated[
+        str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))
+    ]

mistralai/models/files_api_routes_upload_fileop.py

@@ -1,28 +1,39 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .filepurpose import FilePurpose
 import io
-from mistralai.types import BaseModel, UnrecognizedStr
+from mistralai.types import BaseModel
 from mistralai.utils import FieldMetadata, MultipartFormMetadata, validate_open_enum
 import pydantic
 from pydantic.functional_validators import PlainValidator
-from typing import Final, IO, Literal, Optional, TypedDict, Union
-from typing_extensions import Annotated, NotRequired
+from typing import IO, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypedDict
 
 
-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 +47,15 @@ class FilesAPIRoutesUploadFileMultiPartBodyParamsTypedDict(TypedDict):
     file=@path/to/your/file.jsonl
     ```
     """
-    
+    purpose: NotRequired[FilePurpose]
+
 
 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 +66,8 @@ class FilesAPIRoutesUploadFileMultiPartBodyParams(BaseModel):
     file=@path/to/your/file.jsonl
     ```
     """
-    PURPOSE: Annotated[Final[Annotated[Optional[FilesAPIRoutesUploadFilePurpose], PlainValidator(validate_open_enum(False))]], pydantic.Field(alias="purpose"), FieldMetadata(multipart=True)] = "fine-tune" # type: ignore
-    
+
+    purpose: Annotated[
+        Annotated[Optional[FilePurpose], PlainValidator(validate_open_enum(False))],
+        FieldMetadata(multipart=True),
+    ] = None

mistralai/models/fileschema.py

@@ -1,20 +1,16 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .filepurpose import FilePurpose
 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
 from mistralai.utils import validate_open_enum
-import pydantic
 from pydantic import model_serializer
 from pydantic.functional_validators import PlainValidator
-from typing import Final, Literal, TypedDict, Union
-from typing_extensions import Annotated, NotRequired
+from typing_extensions import Annotated, NotRequired, TypedDict
 
 
-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."""
@@ -26,28 +22,36 @@ class FileSchemaTypedDict(TypedDict):
     r"""The UNIX timestamp (in seconds) of the event."""
     filename: str
     r"""The name of the uploaded file."""
+    purpose: FilePurpose
     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
-    PURPOSE: Annotated[Final[Annotated[FileSchemaPurpose, PlainValidator(validate_open_enum(False))]], pydantic.Field(alias="purpose")] = "fine-tune" # type: ignore
-    r"""The intended purpose of the uploaded file. Only accepts fine-tuning (`fine-tune`) for now."""
+
+    purpose: Annotated[FilePurpose, PlainValidator(validate_open_enum(False))]
+
+    sample_type: Annotated[SampleType, PlainValidator(validate_open_enum(False))]
+
+    source: Annotated[Source, PlainValidator(validate_open_enum(False))]
+
     num_lines: OptionalNullable[int] = UNSET
-    
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = ["num_lines"]
@@ -61,9 +65,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 +81,3 @@ class FileSchema(BaseModel):
                 m[k] = val
 
         return m
-