mistralai 1.5.2rc1__py3-none-any.whl → 1.7.0__py3-none-any.whl

mistralai/models/chatmoderationrequest.py

@@ -9,8 +9,8 @@ from mistralai.types import BaseModel
 from mistralai.utils import get_discriminator
 import pydantic
 from pydantic import Discriminator, Tag
-from typing import List, Optional, Union
-from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+from typing import List, Union
+from typing_extensions import Annotated, TypeAliasType, TypedDict
 
 
 TwoTypedDict = TypeAliasType(
@@ -71,16 +71,13 @@ r"""Chat to classify"""
 
 
 class ChatModerationRequestTypedDict(TypedDict):
-    model: str
     inputs: ChatModerationRequestInputsTypedDict
     r"""Chat to classify"""
-    truncate_for_context_length: NotRequired[bool]
+    model: str
 
 
 class ChatModerationRequest(BaseModel):
-    model: str
-
     inputs: Annotated[ChatModerationRequestInputs, pydantic.Field(alias="input")]
     r"""Chat to classify"""
 
-    truncate_for_context_length: Optional[bool] = False
+    model: str

mistralai/models/classificationresponse.py

@@ -1,21 +1,24 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from .classificationobject import ClassificationObject, ClassificationObjectTypedDict
+from .classificationtargetresult import (
+    ClassificationTargetResult,
+    ClassificationTargetResultTypedDict,
+)
 from mistralai.types import BaseModel
-from typing import List, Optional
-from typing_extensions import NotRequired, TypedDict
+from typing import Dict, List
+from typing_extensions import TypedDict
 
 
 class ClassificationResponseTypedDict(TypedDict):
-    id: NotRequired[str]
-    model: NotRequired[str]
-    results: NotRequired[List[ClassificationObjectTypedDict]]
+    id: str
+    model: str
+    results: List[Dict[str, ClassificationTargetResultTypedDict]]
 
 
 class ClassificationResponse(BaseModel):
-    id: Optional[str] = None
+    id: str
 
-    model: Optional[str] = None
+    model: str
 
-    results: Optional[List[ClassificationObject]] = None
+    results: List[Dict[str, ClassificationTargetResult]]

mistralai/models/classificationtargetresult.py

@@ -0,0 +1,14 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel
+from typing import Dict
+from typing_extensions import TypedDict
+
+
+class ClassificationTargetResultTypedDict(TypedDict):
+    scores: Dict[str, float]
+
+
+class ClassificationTargetResult(BaseModel):
+    scores: Dict[str, float]

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