mistralai 1.6.0__py3-none-any.whl → 1.7.1__py3-none-any.whl

mistralai/models/classifierdetailedjobout.py

@@ -0,0 +1,156 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .checkpointout import CheckpointOut, CheckpointOutTypedDict
+from .classifiertargetout import ClassifierTargetOut, ClassifierTargetOutTypedDict
+from .classifiertrainingparameters import (
+    ClassifierTrainingParameters,
+    ClassifierTrainingParametersTypedDict,
+)
+from .eventout import EventOut, EventOutTypedDict
+from .jobmetadataout import JobMetadataOut, JobMetadataOutTypedDict
+from .wandbintegrationout import WandbIntegrationOut, WandbIntegrationOutTypedDict
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import List, Literal, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+ClassifierDetailedJobOutStatus = Literal[
+    "QUEUED",
+    "STARTED",
+    "VALIDATING",
+    "VALIDATED",
+    "RUNNING",
+    "FAILED_VALIDATION",
+    "FAILED",
+    "SUCCESS",
+    "CANCELLED",
+    "CANCELLATION_REQUESTED",
+]
+
+ClassifierDetailedJobOutObject = Literal["job"]
+
+ClassifierDetailedJobOutIntegrationsTypedDict = WandbIntegrationOutTypedDict
+
+
+ClassifierDetailedJobOutIntegrations = WandbIntegrationOut
+
+
+ClassifierDetailedJobOutJobType = Literal["classifier"]
+
+
+class ClassifierDetailedJobOutTypedDict(TypedDict):
+    id: str
+    auto_start: bool
+    model: str
+    r"""The name of the model to fine-tune."""
+    status: ClassifierDetailedJobOutStatus
+    created_at: int
+    modified_at: int
+    training_files: List[str]
+    hyperparameters: ClassifierTrainingParametersTypedDict
+    classifier_targets: List[ClassifierTargetOutTypedDict]
+    validation_files: NotRequired[Nullable[List[str]]]
+    object: NotRequired[ClassifierDetailedJobOutObject]
+    fine_tuned_model: NotRequired[Nullable[str]]
+    suffix: NotRequired[Nullable[str]]
+    integrations: NotRequired[
+        Nullable[List[ClassifierDetailedJobOutIntegrationsTypedDict]]
+    ]
+    trained_tokens: NotRequired[Nullable[int]]
+    metadata: NotRequired[Nullable[JobMetadataOutTypedDict]]
+    job_type: NotRequired[ClassifierDetailedJobOutJobType]
+    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 ClassifierDetailedJobOut(BaseModel):
+    id: str
+
+    auto_start: bool
+
+    model: str
+    r"""The name of the model to fine-tune."""
+
+    status: ClassifierDetailedJobOutStatus
+
+    created_at: int
+
+    modified_at: int
+
+    training_files: List[str]
+
+    hyperparameters: ClassifierTrainingParameters
+
+    classifier_targets: List[ClassifierTargetOut]
+
+    validation_files: OptionalNullable[List[str]] = UNSET
+
+    object: Optional[ClassifierDetailedJobOutObject] = "job"
+
+    fine_tuned_model: OptionalNullable[str] = UNSET
+
+    suffix: OptionalNullable[str] = UNSET
+
+    integrations: OptionalNullable[List[ClassifierDetailedJobOutIntegrations]] = UNSET
+
+    trained_tokens: OptionalNullable[int] = UNSET
+
+    metadata: OptionalNullable[JobMetadataOut] = UNSET
+
+    job_type: Optional[ClassifierDetailedJobOutJobType] = "classifier"
+
+    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",
+            "metadata",
+            "job_type",
+            "events",
+            "checkpoints",
+        ]
+        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)
+            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/classifierftmodelout.py

@@ -0,0 +1,101 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .classifiertargetout import ClassifierTargetOut, ClassifierTargetOutTypedDict
+from .ftmodelcapabilitiesout import (
+    FTModelCapabilitiesOut,
+    FTModelCapabilitiesOutTypedDict,
+)
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import List, Literal, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+ClassifierFTModelOutObject = Literal["model"]
+
+ClassifierFTModelOutModelType = Literal["classifier"]
+
+
+class ClassifierFTModelOutTypedDict(TypedDict):
+    id: str
+    created: int
+    owned_by: str
+    root: str
+    archived: bool
+    capabilities: FTModelCapabilitiesOutTypedDict
+    job: str
+    classifier_targets: List[ClassifierTargetOutTypedDict]
+    object: NotRequired[ClassifierFTModelOutObject]
+    name: NotRequired[Nullable[str]]
+    description: NotRequired[Nullable[str]]
+    max_context_length: NotRequired[int]
+    aliases: NotRequired[List[str]]
+    model_type: NotRequired[ClassifierFTModelOutModelType]
+
+
+class ClassifierFTModelOut(BaseModel):
+    id: str
+
+    created: int
+
+    owned_by: str
+
+    root: str
+
+    archived: bool
+
+    capabilities: FTModelCapabilitiesOut
+
+    job: str
+
+    classifier_targets: List[ClassifierTargetOut]
+
+    object: Optional[ClassifierFTModelOutObject] = "model"
+
+    name: OptionalNullable[str] = UNSET
+
+    description: OptionalNullable[str] = UNSET
+
+    max_context_length: Optional[int] = 32768
+
+    aliases: Optional[List[str]] = None
+
+    model_type: Optional[ClassifierFTModelOutModelType] = "classifier"
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "object",
+            "name",
+            "description",
+            "max_context_length",
+            "aliases",
+            "model_type",
+        ]
+        nullable_fields = ["name", "description"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

mistralai/models/classifierjobout.py

@@ -0,0 +1,165 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .classifiertrainingparameters import (
+    ClassifierTrainingParameters,
+    ClassifierTrainingParametersTypedDict,
+)
+from .jobmetadataout import JobMetadataOut, JobMetadataOutTypedDict
+from .wandbintegrationout import WandbIntegrationOut, WandbIntegrationOutTypedDict
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import List, Literal, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+ClassifierJobOutStatus = Literal[
+    "QUEUED",
+    "STARTED",
+    "VALIDATING",
+    "VALIDATED",
+    "RUNNING",
+    "FAILED_VALIDATION",
+    "FAILED",
+    "SUCCESS",
+    "CANCELLED",
+    "CANCELLATION_REQUESTED",
+]
+r"""The current status of the fine-tuning job."""
+
+ClassifierJobOutObject = Literal["job"]
+r"""The object type of the fine-tuning job."""
+
+ClassifierJobOutIntegrationsTypedDict = WandbIntegrationOutTypedDict
+
+
+ClassifierJobOutIntegrations = WandbIntegrationOut
+
+
+ClassifierJobOutJobType = Literal["classifier"]
+r"""The type of job (`FT` for fine-tuning)."""
+
+
+class ClassifierJobOutTypedDict(TypedDict):
+    id: str
+    r"""The ID of the job."""
+    auto_start: bool
+    model: str
+    r"""The name of the model to fine-tune."""
+    status: ClassifierJobOutStatus
+    r"""The current status of the fine-tuning job."""
+    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."""
+    hyperparameters: ClassifierTrainingParametersTypedDict
+    validation_files: NotRequired[Nullable[List[str]]]
+    r"""A list containing the IDs of uploaded files that contain validation data."""
+    object: NotRequired[ClassifierJobOutObject]
+    r"""The object type of the fine-tuning job."""
+    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[ClassifierJobOutIntegrationsTypedDict]]]
+    r"""A list of integrations enabled for your fine-tuning job."""
+    trained_tokens: NotRequired[Nullable[int]]
+    r"""Total number of tokens trained."""
+    metadata: NotRequired[Nullable[JobMetadataOutTypedDict]]
+    job_type: NotRequired[ClassifierJobOutJobType]
+    r"""The type of job (`FT` for fine-tuning)."""
+
+
+class ClassifierJobOut(BaseModel):
+    id: str
+    r"""The ID of the job."""
+
+    auto_start: bool
+
+    model: str
+    r"""The name of the model to fine-tune."""
+
+    status: ClassifierJobOutStatus
+    r"""The current status of the fine-tuning job."""
+
+    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."""
+
+    hyperparameters: ClassifierTrainingParameters
+
+    validation_files: OptionalNullable[List[str]] = UNSET
+    r"""A list containing the IDs of uploaded files that contain validation data."""
+
+    object: Optional[ClassifierJobOutObject] = "job"
+    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[ClassifierJobOutIntegrations]] = UNSET
+    r"""A list of integrations enabled for your fine-tuning job."""
+
+    trained_tokens: OptionalNullable[int] = UNSET
+    r"""Total number of tokens trained."""
+
+    metadata: OptionalNullable[JobMetadataOut] = UNSET
+
+    job_type: Optional[ClassifierJobOutJobType] = "classifier"
+    r"""The type of job (`FT` for fine-tuning)."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "validation_files",
+            "object",
+            "fine_tuned_model",
+            "suffix",
+            "integrations",
+            "trained_tokens",
+            "metadata",
+            "job_type",
+        ]
+        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)
+            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/classifiertargetin.py

@@ -0,0 +1,55 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .ftclassifierlossfunction import FTClassifierLossFunction
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import List, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class ClassifierTargetInTypedDict(TypedDict):
+    name: str
+    labels: List[str]
+    weight: NotRequired[float]
+    loss_function: NotRequired[Nullable[FTClassifierLossFunction]]
+
+
+class ClassifierTargetIn(BaseModel):
+    name: str
+
+    labels: List[str]
+
+    weight: Optional[float] = 1
+
+    loss_function: OptionalNullable[FTClassifierLossFunction] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["weight", "loss_function"]
+        nullable_fields = ["loss_function"]
+        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/classifiertargetout.py

@@ -0,0 +1,24 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .ftclassifierlossfunction import FTClassifierLossFunction
+from mistralai.types import BaseModel
+from typing import List
+from typing_extensions import TypedDict
+
+
+class ClassifierTargetOutTypedDict(TypedDict):
+    name: str
+    labels: List[str]
+    weight: float
+    loss_function: FTClassifierLossFunction
+
+
+class ClassifierTargetOut(BaseModel):
+    name: str
+
+    labels: List[str]
+
+    weight: float
+
+    loss_function: FTClassifierLossFunction

mistralai/models/classifiertrainingparameters.py

@@ -0,0 +1,73 @@
+"""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 Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class ClassifierTrainingParametersTypedDict(TypedDict):
+    training_steps: NotRequired[Nullable[int]]
+    learning_rate: NotRequired[float]
+    weight_decay: NotRequired[Nullable[float]]
+    warmup_fraction: NotRequired[Nullable[float]]
+    epochs: NotRequired[Nullable[float]]
+    seq_len: NotRequired[Nullable[int]]
+
+
+class ClassifierTrainingParameters(BaseModel):
+    training_steps: OptionalNullable[int] = UNSET
+
+    learning_rate: Optional[float] = 0.0001
+
+    weight_decay: OptionalNullable[float] = UNSET
+
+    warmup_fraction: OptionalNullable[float] = UNSET
+
+    epochs: OptionalNullable[float] = UNSET
+
+    seq_len: OptionalNullable[int] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "training_steps",
+            "learning_rate",
+            "weight_decay",
+            "warmup_fraction",
+            "epochs",
+            "seq_len",
+        ]
+        nullable_fields = [
+            "training_steps",
+            "weight_decay",
+            "warmup_fraction",
+            "epochs",
+            "seq_len",
+        ]
+        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/classifiertrainingparametersin.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
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class ClassifierTrainingParametersInTypedDict(TypedDict):
+    r"""The fine-tuning hyperparameter settings used in a classifier fine-tune job."""
+
+    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."""
+    learning_rate: NotRequired[float]
+    r"""A parameter describing how much to adjust the pre-trained model's weights in response to the estimated error each time the weights are updated during the fine-tuning process."""
+    weight_decay: NotRequired[Nullable[float]]
+    r"""(Advanced Usage) Weight decay adds a term to the loss function that is proportional to the sum of the squared weights. This term reduces the magnitude of the weights and prevents them from growing too large."""
+    warmup_fraction: NotRequired[Nullable[float]]
+    r"""(Advanced Usage) A parameter that specifies the percentage of the total training steps at which the learning rate warm-up phase ends. During this phase, the learning rate gradually increases from a small value to the initial learning rate, helping to stabilize the training process and improve convergence. Similar to `pct_start` in [mistral-finetune](https://github.com/mistralai/mistral-finetune)"""
+    epochs: NotRequired[Nullable[float]]
+    seq_len: NotRequired[Nullable[int]]
+
+
+class ClassifierTrainingParametersIn(BaseModel):
+    r"""The fine-tuning hyperparameter settings used in a classifier fine-tune job."""
+
+    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."""
+
+    learning_rate: Optional[float] = 0.0001
+    r"""A parameter describing how much to adjust the pre-trained model's weights in response to the estimated error each time the weights are updated during the fine-tuning process."""
+
+    weight_decay: OptionalNullable[float] = UNSET
+    r"""(Advanced Usage) Weight decay adds a term to the loss function that is proportional to the sum of the squared weights. This term reduces the magnitude of the weights and prevents them from growing too large."""
+
+    warmup_fraction: OptionalNullable[float] = UNSET
+    r"""(Advanced Usage) A parameter that specifies the percentage of the total training steps at which the learning rate warm-up phase ends. During this phase, the learning rate gradually increases from a small value to the initial learning rate, helping to stabilize the training process and improve convergence. Similar to `pct_start` in [mistral-finetune](https://github.com/mistralai/mistral-finetune)"""
+
+    epochs: OptionalNullable[float] = UNSET
+
+    seq_len: OptionalNullable[int] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "training_steps",
+            "learning_rate",
+            "weight_decay",
+            "warmup_fraction",
+            "epochs",
+            "seq_len",
+        ]
+        nullable_fields = [
+            "training_steps",
+            "weight_decay",
+            "warmup_fraction",
+            "epochs",
+            "seq_len",
+        ]
+        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