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

mistralai/models/modellist.py

@@ -0,0 +1,18 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .modelcard import ModelCard, ModelCardTypedDict
+from mistralai.types import BaseModel
+from typing import List, Optional, TypedDict
+from typing_extensions import NotRequired
+
+
+class ModelListTypedDict(TypedDict):
+    object: NotRequired[str]
+    data: NotRequired[List[ModelCardTypedDict]]
+    
+
+class ModelList(BaseModel):
+    object: Optional[str] = "list"
+    data: Optional[List[ModelCard]] = None
+    

mistralai/models/responseformat.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 typing import Literal, Optional, TypedDict
+from typing_extensions import NotRequired
+
+
+ResponseFormats = Literal["text", "json_object"]
+r"""An object specifying the format that the model must output. Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which guarantees the message the model generates is in JSON. When using JSON mode you MUST also instruct the model to produce JSON yourself with a system or a user message."""
+
+class ResponseFormatTypedDict(TypedDict):
+    type: NotRequired[ResponseFormats]
+    
+
+class ResponseFormat(BaseModel):
+    type: Optional[ResponseFormats] = "text"
+    

mistralai/models/retrieve_model_v1_models_model_id_getop.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 RetrieveModelV1ModelsModelIDGetRequestTypedDict(TypedDict):
+    model_id: str
+    
+
+class RetrieveModelV1ModelsModelIDGetRequest(BaseModel):
+    model_id: Annotated[str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))]
+    

mistralai/models/retrievefileout.py

@@ -0,0 +1,76 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .sampletype import SampleType
+from .source import Source
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+import pydantic
+from pydantic import model_serializer
+from typing import Final, TypedDict
+from typing_extensions import Annotated, NotRequired
+
+
+class RetrieveFileOutTypedDict(TypedDict):
+    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
+    num_lines: NotRequired[Nullable[int]]
+    
+
+class RetrieveFileOut(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[str], pydantic.Field(alias="purpose")] = "fine-tune" # type: ignore
+    r"""The intended purpose of the uploaded file. Only accepts fine-tuning (`fine-tune`) for now."""
+    num_lines: OptionalNullable[int] = UNSET
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["num_lines"]
+        nullable_fields = ["num_lines"]
+        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/sampletype.py

@@ -0,0 +1,7 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from typing import Literal
+
+
+SampleType = Literal["pretrain", "instruct"]

mistralai/models/sdkerror.py

@@ -0,0 +1,22 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from dataclasses import dataclass
+from typing import Optional
+import httpx
+
+
+@dataclass
+class SDKError(Exception):
+    """Represents an error returned by the API."""
+
+    message: str
+    status_code: int = -1
+    body: str = ""
+    raw_response: Optional[httpx.Response] = None
+
+    def __str__(self):
+        body = ""
+        if len(self.body) > 0:
+            body = f"\n{self.body}"
+
+        return f"{self.message}: Status {self.status_code}{body}"

mistralai/models/security.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, SecurityMetadata
+from typing import TypedDict
+from typing_extensions import Annotated
+
+
+class SecurityTypedDict(TypedDict):
+    api_key: str
+    
+
+class Security(BaseModel):
+    api_key: Annotated[str, FieldMetadata(security=SecurityMetadata(scheme=True, scheme_type="http", sub_type="bearer", field_name="Authorization"))]
+    

mistralai/models/source.py

@@ -0,0 +1,7 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from typing import Literal
+
+
+Source = Literal["upload", "repository"]

mistralai/models/systemmessage.py

@@ -0,0 +1,26 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .contentchunk import ContentChunk, ContentChunkTypedDict
+from mistralai.types import BaseModel
+from typing import List, Literal, Optional, TypedDict, Union
+from typing_extensions import NotRequired
+
+
+Role = Literal["system"]
+
+class SystemMessageTypedDict(TypedDict):
+    content: ContentTypedDict
+    role: NotRequired[Role]
+    
+
+class SystemMessage(BaseModel):
+    content: Content
+    role: Optional[Role] = "system"
+    
+
+ContentTypedDict = Union[str, List[ContentChunkTypedDict]]
+
+
+Content = Union[str, List[ContentChunk]]
+

mistralai/models/textchunk.py

@@ -0,0 +1,17 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel
+import pydantic
+from typing import Final, Optional, TypedDict
+from typing_extensions import Annotated
+
+
+class TextChunkTypedDict(TypedDict):
+    text: str
+    
+
+class TextChunk(BaseModel):
+    text: str
+    TYPE: Annotated[Final[Optional[str]], pydantic.Field(alias="type")] = "text" # type: ignore
+    

mistralai/models/tool.py

@@ -0,0 +1,18 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .function import Function, FunctionTypedDict
+from mistralai.types import BaseModel
+import pydantic
+from typing import Final, Optional, TypedDict
+from typing_extensions import Annotated
+
+
+class ToolTypedDict(TypedDict):
+    function: FunctionTypedDict
+    
+
+class Tool(BaseModel):
+    function: Function
+    TYPE: Annotated[Final[Optional[str]], pydantic.Field(alias="type")] = "function" # type: ignore
+    

mistralai/models/toolcall.py

@@ -0,0 +1,20 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .functioncall import FunctionCall, FunctionCallTypedDict
+from mistralai.types import BaseModel
+import pydantic
+from typing import Final, Optional, TypedDict
+from typing_extensions import Annotated, NotRequired
+
+
+class ToolCallTypedDict(TypedDict):
+    function: FunctionCallTypedDict
+    id: NotRequired[str]
+    
+
+class ToolCall(BaseModel):
+    function: FunctionCall
+    id: Optional[str] = "null"
+    TYPE: Annotated[Final[Optional[str]], pydantic.Field(alias="type")] = "function" # type: ignore
+    

mistralai/models/toolmessage.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 Literal, Optional, TypedDict
+from typing_extensions import NotRequired
+
+
+ToolMessageRole = Literal["tool"]
+
+class ToolMessageTypedDict(TypedDict):
+    content: str
+    tool_call_id: NotRequired[Nullable[str]]
+    name: NotRequired[Nullable[str]]
+    role: NotRequired[ToolMessageRole]
+    
+
+class ToolMessage(BaseModel):
+    content: str
+    tool_call_id: OptionalNullable[str] = UNSET
+    name: OptionalNullable[str] = UNSET
+    role: Optional[ToolMessageRole] = "tool"
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["tool_call_id", "name", "role"]
+        nullable_fields = ["tool_call_id", "name"]
+        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/trainingfile.py

@@ -0,0 +1,17 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel
+from typing import Optional, TypedDict
+from typing_extensions import NotRequired
+
+
+class TrainingFileTypedDict(TypedDict):
+    file_id: str
+    weight: NotRequired[float]
+    
+
+class TrainingFile(BaseModel):
+    file_id: str
+    weight: Optional[float] = 1
+    

mistralai/models/trainingparameters.py

@@ -0,0 +1,53 @@
+"""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, TypedDict
+from typing_extensions import NotRequired
+
+
+class TrainingParametersTypedDict(TypedDict):
+    training_steps: NotRequired[Nullable[int]]
+    learning_rate: NotRequired[float]
+    epochs: NotRequired[Nullable[float]]
+    fim_ratio: NotRequired[Nullable[float]]
+    
+
+class TrainingParameters(BaseModel):
+    training_steps: OptionalNullable[int] = UNSET
+    learning_rate: Optional[float] = 0.0001
+    epochs: OptionalNullable[float] = UNSET
+    fim_ratio: OptionalNullable[float] = UNSET
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["training_steps", "learning_rate", "epochs", "fim_ratio"]
+        nullable_fields = ["training_steps", "epochs", "fim_ratio"]
+        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/trainingparametersin.py

@@ -0,0 +1,61 @@
+"""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, TypedDict
+from typing_extensions import NotRequired
+
+
+class TrainingParametersInTypedDict(TypedDict):
+    r"""The fine-tuning hyperparameter settings used in a 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."""
+    epochs: NotRequired[Nullable[float]]
+    fim_ratio: NotRequired[Nullable[float]]
+    
+
+class TrainingParametersIn(BaseModel):
+    r"""The fine-tuning hyperparameter settings used in a 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."""
+    epochs: OptionalNullable[float] = UNSET
+    fim_ratio: OptionalNullable[float] = UNSET
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["training_steps", "learning_rate", "epochs", "fim_ratio"]
+        nullable_fields = ["training_steps", "epochs", "fim_ratio"]
+        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/unarchiveftmodelout.py

@@ -0,0 +1,19 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel
+import pydantic
+from typing import Final, Optional, TypedDict
+from typing_extensions import Annotated, NotRequired
+
+
+class UnarchiveFTModelOutTypedDict(TypedDict):
+    id: str
+    archived: NotRequired[bool]
+    
+
+class UnarchiveFTModelOut(BaseModel):
+    id: str
+    OBJECT: Annotated[Final[Optional[str]], pydantic.Field(alias="object")] = "model" # type: ignore
+    archived: Optional[bool] = False
+    

mistralai/models/updateftmodelin.py

@@ -0,0 +1,49 @@
+"""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 UpdateFTModelInTypedDict(TypedDict):
+    name: NotRequired[Nullable[str]]
+    description: NotRequired[Nullable[str]]
+    
+
+class UpdateFTModelIn(BaseModel):
+    name: OptionalNullable[str] = UNSET
+    description: OptionalNullable[str] = UNSET
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["name", "description"]
+        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)
+
+            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/uploadfileout.py

@@ -0,0 +1,76 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .sampletype import SampleType
+from .source import Source
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+import pydantic
+from pydantic import model_serializer
+from typing import Final, TypedDict
+from typing_extensions import Annotated, NotRequired
+
+
+class UploadFileOutTypedDict(TypedDict):
+    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
+    num_lines: NotRequired[Nullable[int]]
+    
+
+class UploadFileOut(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[str], pydantic.Field(alias="purpose")] = "fine-tune" # type: ignore
+    r"""The intended purpose of the uploaded file. Only accepts fine-tuning (`fine-tune`) for now."""
+    num_lines: OptionalNullable[int] = UNSET
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["num_lines"]
+        nullable_fields = ["num_lines"]
+        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/usageinfo.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 typing import TypedDict
+
+
+class UsageInfoTypedDict(TypedDict):
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+    
+
+class UsageInfo(BaseModel):
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+    

mistralai/models/usermessage.py

@@ -0,0 +1,26 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .textchunk import TextChunk, TextChunkTypedDict
+from mistralai.types import BaseModel
+from typing import List, Literal, Optional, TypedDict, Union
+from typing_extensions import NotRequired
+
+
+UserMessageRole = Literal["user"]
+
+class UserMessageTypedDict(TypedDict):
+    content: UserMessageContentTypedDict
+    role: NotRequired[UserMessageRole]
+    
+
+class UserMessage(BaseModel):
+    content: UserMessageContent
+    role: Optional[UserMessageRole] = "user"
+    
+
+UserMessageContentTypedDict = Union[str, List[TextChunkTypedDict]]
+
+
+UserMessageContent = Union[str, List[TextChunk]]
+