mistralai 0.4.2__py3-none-any.whl → 0.5.5a50__py3-none-any.whl

mistralai/models/jobout.py

@@ -0,0 +1,112 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .finetuneablemodel import FineTuneableModel
+from .githubrepositoryout import GithubRepositoryOut, GithubRepositoryOutTypedDict
+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
+import pydantic
+from pydantic import model_serializer
+from typing import Final, List, Literal, Optional, TypedDict
+from typing_extensions import Annotated, NotRequired
+
+
+Status = Literal["QUEUED", "STARTED", "VALIDATING", "VALIDATED", "RUNNING", "FAILED_VALIDATION", "FAILED", "SUCCESS", "CANCELLED", "CANCELLATION_REQUESTED"]
+r"""The current status of the fine-tuning job."""
+
+class JobOutTypedDict(TypedDict):
+    id: str
+    r"""The ID of the job."""
+    auto_start: bool
+    hyperparameters: TrainingParametersTypedDict
+    model: FineTuneableModel
+    r"""The name of the model to fine-tune."""
+    status: Status
+    r"""The current status of the fine-tuning job."""
+    job_type: str
+    r"""The type of job (`FT` for fine-tuning)."""
+    created_at: int
+    r"""The UNIX timestamp (in seconds) for when the fine-tuning job was created."""
+    modified_at: int
+    r"""The UNIX timestamp (in seconds) for when the fine-tuning job was last modified."""
+    training_files: List[str]
+    r"""A list containing the IDs of uploaded files that contain training data."""
+    validation_files: NotRequired[Nullable[List[str]]]
+    r"""A list containing the IDs of uploaded files that contain validation data."""
+    fine_tuned_model: NotRequired[Nullable[str]]
+    r"""The name of the fine-tuned model that is being created. The value will be `null` if the fine-tuning job is still running."""
+    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`."""
+    integrations: NotRequired[Nullable[List[WandbIntegrationOutTypedDict]]]
+    r"""A list of integrations enabled for your fine-tuning job."""
+    trained_tokens: NotRequired[Nullable[int]]
+    r"""Total number of tokens trained."""
+    repositories: NotRequired[List[GithubRepositoryOutTypedDict]]
+    metadata: NotRequired[Nullable[JobMetadataOutTypedDict]]
+    
+
+class JobOut(BaseModel):
+    id: str
+    r"""The ID of the job."""
+    auto_start: bool
+    hyperparameters: TrainingParameters
+    model: FineTuneableModel
+    r"""The name of the model to fine-tune."""
+    status: Status
+    r"""The current status of the fine-tuning job."""
+    job_type: str
+    r"""The type of job (`FT` for fine-tuning)."""
+    created_at: int
+    r"""The UNIX timestamp (in seconds) for when the fine-tuning job was created."""
+    modified_at: int
+    r"""The UNIX timestamp (in seconds) for when the fine-tuning job was last modified."""
+    training_files: List[str]
+    r"""A list containing the IDs of uploaded files that contain training data."""
+    validation_files: OptionalNullable[List[str]] = UNSET
+    r"""A list containing the IDs of uploaded files that contain validation data."""
+    OBJECT: Annotated[Final[Optional[str]], pydantic.Field(alias="object")] = "job" # type: ignore
+    r"""The object type of the fine-tuning job."""
+    fine_tuned_model: OptionalNullable[str] = UNSET
+    r"""The name of the fine-tuned model that is being created. The value will be `null` if the fine-tuning job is still running."""
+    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`."""
+    integrations: OptionalNullable[List[WandbIntegrationOut]] = UNSET
+    r"""A list of integrations enabled for your fine-tuning job."""
+    trained_tokens: OptionalNullable[int] = UNSET
+    r"""Total number of tokens trained."""
+    repositories: Optional[List[GithubRepositoryOut]] = None
+    metadata: OptionalNullable[JobMetadataOut] = UNSET
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["validation_files", "object", "fine_tuned_model", "suffix", "integrations", "trained_tokens", "repositories", "metadata"]
+        nullable_fields = ["validation_files", "fine_tuned_model", "suffix", "integrations", "trained_tokens", "metadata"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields
+                or (
+                    k in optional_fields
+                    and k in nullable_fields
+                    and (
+                        self.__pydantic_fields_set__.intersection({n})
+                        or k in null_default_fields
+                    )  # pylint: disable=no-member
+                )
+            ):
+                m[k] = val
+
+        return m
+        

mistralai/models/jobs_api_routes_fine_tuning_archive_fine_tuned_modelop.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 import TypedDict
+from typing_extensions import Annotated
+
+
+class JobsAPIRoutesFineTuningArchiveFineTunedModelRequestTypedDict(TypedDict):
+    model_id: str
+    
+
+class JobsAPIRoutesFineTuningArchiveFineTunedModelRequest(BaseModel):
+    model_id: Annotated[str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))]
+    

mistralai/models/jobs_api_routes_fine_tuning_cancel_fine_tuning_jobop.py

@@ -0,0 +1,18 @@
+"""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 import TypedDict
+from typing_extensions import Annotated
+
+
+class JobsAPIRoutesFineTuningCancelFineTuningJobRequestTypedDict(TypedDict):
+    job_id: str
+    r"""The ID of the job to cancel."""
+    
+
+class JobsAPIRoutesFineTuningCancelFineTuningJobRequest(BaseModel):
+    job_id: Annotated[str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))]
+    r"""The ID of the job to cancel."""
+    

mistralai/models/jobs_api_routes_fine_tuning_create_fine_tuning_jobop.py

@@ -0,0 +1,73 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .jobin import JobIn, JobInTypedDict
+from .jobout import JobOut, JobOutTypedDict
+from .legacyjobmetadataout import LegacyJobMetadataOut, LegacyJobMetadataOutTypedDict
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from mistralai.utils import FieldMetadata, QueryParamMetadata, RequestMetadata
+from pydantic import model_serializer
+from typing import TypedDict, Union
+from typing_extensions import Annotated, NotRequired
+
+
+class JobsAPIRoutesFineTuningCreateFineTuningJobRequestTypedDict(TypedDict):
+    job_in: JobInTypedDict
+    dry_run: NotRequired[Nullable[bool]]
+    r"""* If `true` the job is not spawned, instead the query returns a handful of useful metadata
+    for the user to perform sanity checks (see `LegacyJobMetadataOut` response).
+    * Otherwise, the job is started and the query returns the job ID along with some of the
+    input parameters (see `JobOut` response).
+
+    """
+    
+
+class JobsAPIRoutesFineTuningCreateFineTuningJobRequest(BaseModel):
+    job_in: Annotated[JobIn, FieldMetadata(request=RequestMetadata(media_type="application/json"))]
+    dry_run: Annotated[OptionalNullable[bool], FieldMetadata(query=QueryParamMetadata(style="form", explode=True))] = UNSET
+    r"""* If `true` the job is not spawned, instead the query returns a handful of useful metadata
+    for the user to perform sanity checks (see `LegacyJobMetadataOut` response).
+    * Otherwise, the job is started and the query returns the job ID along with some of the
+    input parameters (see `JobOut` response).
+
+    """
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["dry_run"]
+        nullable_fields = ["dry_run"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields
+                or (
+                    k in optional_fields
+                    and k in nullable_fields
+                    and (
+                        self.__pydantic_fields_set__.intersection({n})
+                        or k in null_default_fields
+                    )  # pylint: disable=no-member
+                )
+            ):
+                m[k] = val
+
+        return m
+        
+
+JobsAPIRoutesFineTuningCreateFineTuningJobResponseTypedDict = Union[LegacyJobMetadataOutTypedDict, JobOutTypedDict]
+r"""OK"""
+
+
+JobsAPIRoutesFineTuningCreateFineTuningJobResponse = Union[LegacyJobMetadataOut, JobOut]
+r"""OK"""
+

mistralai/models/jobs_api_routes_fine_tuning_get_fine_tuning_jobop.py

@@ -0,0 +1,18 @@
+"""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 import TypedDict
+from typing_extensions import Annotated
+
+
+class JobsAPIRoutesFineTuningGetFineTuningJobRequestTypedDict(TypedDict):
+    job_id: str
+    r"""The ID of the job to analyse."""
+    
+
+class JobsAPIRoutesFineTuningGetFineTuningJobRequest(BaseModel):
+    job_id: Annotated[str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))]
+    r"""The ID of the job to analyse."""
+    

mistralai/models/jobs_api_routes_fine_tuning_get_fine_tuning_jobsop.py

@@ -0,0 +1,86 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from datetime import datetime
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from mistralai.utils import FieldMetadata, QueryParamMetadata
+from pydantic import model_serializer
+from typing import Literal, Optional, TypedDict
+from typing_extensions import Annotated, NotRequired
+
+
+QueryParamStatus = Literal["QUEUED", "STARTED", "VALIDATING", "VALIDATED", "RUNNING", "FAILED_VALIDATION", "FAILED", "SUCCESS", "CANCELLED", "CANCELLATION_REQUESTED"]
+r"""The current job state to filter on. When set, the other results are not displayed."""
+
+class JobsAPIRoutesFineTuningGetFineTuningJobsRequestTypedDict(TypedDict):
+    page: NotRequired[int]
+    r"""The page number of the results to be returned."""
+    page_size: NotRequired[int]
+    r"""The number of items to return per page."""
+    model: NotRequired[Nullable[str]]
+    r"""The model name used for fine-tuning to filter on. When set, the other results are not displayed."""
+    created_after: NotRequired[Nullable[datetime]]
+    r"""The date/time to filter on. When set, the results for previous creation times are not displayed."""
+    created_by_me: NotRequired[bool]
+    r"""When set, only return results for jobs created by the API caller. Other results are not displayed."""
+    status: NotRequired[Nullable[QueryParamStatus]]
+    r"""The current job state to filter on. When set, the other results are not displayed."""
+    wandb_project: NotRequired[Nullable[str]]
+    r"""The Weights and Biases project to filter on. When set, the other results are not displayed."""
+    wandb_name: NotRequired[Nullable[str]]
+    r"""The Weight and Biases run name to filter on. When set, the other results are not displayed."""
+    suffix: NotRequired[Nullable[str]]
+    r"""The model suffix to filter on. When set, the other results are not displayed."""
+    
+
+class JobsAPIRoutesFineTuningGetFineTuningJobsRequest(BaseModel):
+    page: Annotated[Optional[int], FieldMetadata(query=QueryParamMetadata(style="form", explode=True))] = 0
+    r"""The page number of the results to be returned."""
+    page_size: Annotated[Optional[int], FieldMetadata(query=QueryParamMetadata(style="form", explode=True))] = 100
+    r"""The number of items to return per page."""
+    model: Annotated[OptionalNullable[str], FieldMetadata(query=QueryParamMetadata(style="form", explode=True))] = UNSET
+    r"""The model name used for fine-tuning to filter on. When set, the other results are not displayed."""
+    created_after: Annotated[OptionalNullable[datetime], FieldMetadata(query=QueryParamMetadata(style="form", explode=True))] = UNSET
+    r"""The date/time to filter on. When set, the results for previous creation times are not displayed."""
+    created_by_me: Annotated[Optional[bool], FieldMetadata(query=QueryParamMetadata(style="form", explode=True))] = False
+    r"""When set, only return results for jobs created by the API caller. Other results are not displayed."""
+    status: Annotated[OptionalNullable[QueryParamStatus], FieldMetadata(query=QueryParamMetadata(style="form", explode=True))] = UNSET
+    r"""The current job state to filter on. When set, the other results are not displayed."""
+    wandb_project: Annotated[OptionalNullable[str], FieldMetadata(query=QueryParamMetadata(style="form", explode=True))] = UNSET
+    r"""The Weights and Biases project to filter on. When set, the other results are not displayed."""
+    wandb_name: Annotated[OptionalNullable[str], FieldMetadata(query=QueryParamMetadata(style="form", explode=True))] = UNSET
+    r"""The Weight and Biases run name to filter on. When set, the other results are not displayed."""
+    suffix: Annotated[OptionalNullable[str], FieldMetadata(query=QueryParamMetadata(style="form", explode=True))] = UNSET
+    r"""The model suffix to filter on. When set, the other results are not displayed."""
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["page", "page_size", "model", "created_after", "created_by_me", "status", "wandb_project", "wandb_name", "suffix"]
+        nullable_fields = ["model", "created_after", "status", "wandb_project", "wandb_name", "suffix"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields
+                or (
+                    k in optional_fields
+                    and k in nullable_fields
+                    and (
+                        self.__pydantic_fields_set__.intersection({n})
+                        or k in null_default_fields
+                    )  # pylint: disable=no-member
+                )
+            ):
+                m[k] = val
+
+        return m
+        

mistralai/models/jobs_api_routes_fine_tuning_start_fine_tuning_jobop.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 import TypedDict
+from typing_extensions import Annotated
+
+
+class JobsAPIRoutesFineTuningStartFineTuningJobRequestTypedDict(TypedDict):
+    job_id: str
+    
+
+class JobsAPIRoutesFineTuningStartFineTuningJobRequest(BaseModel):
+    job_id: Annotated[str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))]
+    

mistralai/models/jobs_api_routes_fine_tuning_unarchive_fine_tuned_modelop.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 import TypedDict
+from typing_extensions import Annotated
+
+
+class JobsAPIRoutesFineTuningUnarchiveFineTunedModelRequestTypedDict(TypedDict):
+    model_id: str
+    
+
+class JobsAPIRoutesFineTuningUnarchiveFineTunedModelRequest(BaseModel):
+    model_id: Annotated[str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))]
+    

mistralai/models/jobs_api_routes_fine_tuning_update_fine_tuned_modelop.py

@@ -0,0 +1,19 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .updateftmodelin import UpdateFTModelIn, UpdateFTModelInTypedDict
+from mistralai.types import BaseModel
+from mistralai.utils import FieldMetadata, PathParamMetadata, RequestMetadata
+from typing import TypedDict
+from typing_extensions import Annotated
+
+
+class JobsAPIRoutesFineTuningUpdateFineTunedModelRequestTypedDict(TypedDict):
+    model_id: str
+    update_ft_model_in: UpdateFTModelInTypedDict
+    
+
+class JobsAPIRoutesFineTuningUpdateFineTunedModelRequest(BaseModel):
+    model_id: Annotated[str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))]
+    update_ft_model_in: Annotated[UpdateFTModelIn, FieldMetadata(request=RequestMetadata(media_type="application/json"))]
+    

mistralai/models/jobsout.py

@@ -0,0 +1,20 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .jobout import JobOut, JobOutTypedDict
+from mistralai.types import BaseModel
+import pydantic
+from typing import Final, List, Optional, TypedDict
+from typing_extensions import Annotated, NotRequired
+
+
+class JobsOutTypedDict(TypedDict):
+    total: int
+    data: NotRequired[List[JobOutTypedDict]]
+    
+
+class JobsOut(BaseModel):
+    total: int
+    data: Optional[List[JobOut]] = None
+    OBJECT: Annotated[Final[Optional[str]], pydantic.Field(alias="object")] = "list" # type: ignore
+    

mistralai/models/legacyjobmetadataout.py

@@ -0,0 +1,85 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+import pydantic
+from pydantic import model_serializer
+from typing import Final, Optional, TypedDict
+from typing_extensions import Annotated, NotRequired
+
+
+class LegacyJobMetadataOutTypedDict(TypedDict):
+    details: str
+    expected_duration_seconds: NotRequired[Nullable[int]]
+    r"""The approximated time (in seconds) for the fine-tuning process to complete."""
+    cost: NotRequired[Nullable[float]]
+    r"""The cost of the fine-tuning job."""
+    cost_currency: NotRequired[Nullable[str]]
+    r"""The currency used for the fine-tuning job cost."""
+    train_tokens_per_step: NotRequired[Nullable[int]]
+    r"""The number of tokens consumed by one training step."""
+    train_tokens: NotRequired[Nullable[int]]
+    r"""The total number of tokens used during the fine-tuning process."""
+    data_tokens: NotRequired[Nullable[int]]
+    r"""The total number of tokens in the training dataset."""
+    estimated_start_time: NotRequired[Nullable[int]]
+    deprecated: NotRequired[bool]
+    epochs: NotRequired[Nullable[float]]
+    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."""
+    OBJECT: Annotated[Final[Optional[str]], pydantic.Field(alias="object")] = "job.metadata" # type: ignore
+    
+    @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"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields
+                or (
+                    k in optional_fields
+                    and k in nullable_fields
+                    and (
+                        self.__pydantic_fields_set__.intersection({n})
+                        or k in null_default_fields
+                    )  # pylint: disable=no-member
+                )
+            ):
+                m[k] = val
+
+        return m
+        

mistralai/models/listfilesout.py

@@ -0,0 +1,17 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .fileschema import FileSchema, FileSchemaTypedDict
+from mistralai.types import BaseModel
+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

@@ -0,0 +1,55 @@
+"""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 TypedDict
+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"]
+        nullable_fields = ["train_loss", "valid_loss", "valid_mean_token_accuracy"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields
+                or (
+                    k in optional_fields
+                    and k in nullable_fields
+                    and (
+                        self.__pydantic_fields_set__.intersection({n})
+                        or k in null_default_fields
+                    )  # pylint: disable=no-member
+                )
+            ):
+                m[k] = val
+
+        return m
+        

mistralai/models/modelcapabilities.py

@@ -0,0 +1,21 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel
+from typing import Optional, TypedDict
+from typing_extensions import NotRequired
+
+
+class ModelCapabilitiesTypedDict(TypedDict):
+    completion_chat: NotRequired[bool]
+    completion_fim: NotRequired[bool]
+    function_calling: NotRequired[bool]
+    fine_tuning: 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
+    

mistralai/models/modelcard.py

@@ -0,0 +1,71 @@
+"""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
+from pydantic import model_serializer
+from typing import List, Optional, TypedDict
+from typing_extensions import NotRequired
+
+
+class ModelCardTypedDict(TypedDict):
+    id: str
+    capabilities: ModelCapabilitiesTypedDict
+    object: NotRequired[str]
+    created: NotRequired[int]
+    owned_by: NotRequired[str]
+    root: NotRequired[Nullable[str]]
+    archived: NotRequired[bool]
+    name: NotRequired[Nullable[str]]
+    description: NotRequired[Nullable[str]]
+    max_context_length: NotRequired[int]
+    aliases: NotRequired[List[str]]
+    deprecation: NotRequired[Nullable[datetime]]
+    
+
+class ModelCard(BaseModel):
+    id: str
+    capabilities: ModelCapabilities
+    object: Optional[str] = "model"
+    created: Optional[int] = None
+    owned_by: Optional[str] = "mistralai"
+    root: OptionalNullable[str] = UNSET
+    archived: Optional[bool] = False
+    name: OptionalNullable[str] = UNSET
+    description: OptionalNullable[str] = UNSET
+    max_context_length: Optional[int] = 32768
+    aliases: Optional[List[str]] = None
+    deprecation: OptionalNullable[datetime] = UNSET
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["object", "created", "owned_by", "root", "archived", "name", "description", "max_context_length", "aliases", "deprecation"]
+        nullable_fields = ["root", "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)
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields
+                or (
+                    k in optional_fields
+                    and k in nullable_fields
+                    and (
+                        self.__pydantic_fields_set__.intersection({n})
+                        or k in null_default_fields
+                    )  # pylint: disable=no-member
+                )
+            ):
+                m[k] = val
+
+        return m
+