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

mistralai/models/fimcompletionrequest.py

@@ -0,0 +1,99 @@
+"""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 List, Optional, TypedDict, Union
+from typing_extensions import NotRequired
+
+
+class FIMCompletionRequestTypedDict(TypedDict):
+    prompt: str
+    r"""The text/code to complete."""
+    model: NotRequired[Nullable[str]]
+    r"""ID of the model to use. Only compatible for now with:
+    - `codestral-2405`
+    - `codestral-latest`
+    """
+    temperature: NotRequired[float]
+    r"""What sampling temperature to use, between 0.0 and 1.0. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. We generally recommend altering this or `top_p` but not both."""
+    top_p: NotRequired[float]
+    r"""Nucleus sampling, where the model considers the results of the tokens with `top_p` probability mass. So 0.1 means only the tokens comprising the top 10% probability mass are considered. We generally recommend altering this or `temperature` but not both."""
+    max_tokens: NotRequired[Nullable[int]]
+    r"""The maximum number of tokens to generate in the completion. The token count of your prompt plus `max_tokens` cannot exceed the model's context length."""
+    min_tokens: NotRequired[Nullable[int]]
+    r"""The minimum number of tokens to generate in the completion."""
+    stream: NotRequired[bool]
+    r"""Whether to stream back partial progress. If set, tokens will be sent as data-only server-side events as they become available, with the stream terminated by a data: [DONE] message. Otherwise, the server will hold the request open until the timeout or until completion, with the response containing the full result as JSON."""
+    stop: NotRequired[FIMCompletionRequestStopTypedDict]
+    r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
+    random_seed: NotRequired[Nullable[int]]
+    r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
+    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`."""
+    
+
+class FIMCompletionRequest(BaseModel):
+    prompt: str
+    r"""The text/code to complete."""
+    model: OptionalNullable[str] = UNSET
+    r"""ID of the model to use. Only compatible for now with:
+    - `codestral-2405`
+    - `codestral-latest`
+    """
+    temperature: Optional[float] = 0.7
+    r"""What sampling temperature to use, between 0.0 and 1.0. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. We generally recommend altering this or `top_p` but not both."""
+    top_p: Optional[float] = 1
+    r"""Nucleus sampling, where the model considers the results of the tokens with `top_p` probability mass. So 0.1 means only the tokens comprising the top 10% probability mass are considered. We generally recommend altering this or `temperature` but not both."""
+    max_tokens: OptionalNullable[int] = UNSET
+    r"""The maximum number of tokens to generate in the completion. The token count of your prompt plus `max_tokens` cannot exceed the model's context length."""
+    min_tokens: OptionalNullable[int] = UNSET
+    r"""The minimum number of tokens to generate in the completion."""
+    stream: Optional[bool] = False
+    r"""Whether to stream back partial progress. If set, tokens will be sent as data-only server-side events as they become available, with the stream terminated by a data: [DONE] message. Otherwise, the server will hold the request open until the timeout or until completion, with the response containing the full result as JSON."""
+    stop: Optional[FIMCompletionRequestStop] = None
+    r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
+    random_seed: OptionalNullable[int] = UNSET
+    r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
+    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`."""
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["model", "temperature", "top_p", "max_tokens", "min_tokens", "stream", "stop", "random_seed", "suffix"]
+        nullable_fields = ["model", "max_tokens", "min_tokens", "random_seed", "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
+        
+
+FIMCompletionRequestStopTypedDict = Union[str, List[str]]
+r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
+
+
+FIMCompletionRequestStop = Union[str, List[str]]
+r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
+

mistralai/models/fimcompletionresponse.py

@@ -0,0 +1,27 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .chatcompletionchoice import ChatCompletionChoice, ChatCompletionChoiceTypedDict
+from .usageinfo import UsageInfo, UsageInfoTypedDict
+from mistralai.types import BaseModel
+from typing import List, Optional, TypedDict
+from typing_extensions import NotRequired
+
+
+class FIMCompletionResponseTypedDict(TypedDict):
+    id: str
+    object: str
+    model: str
+    usage: UsageInfoTypedDict
+    created: NotRequired[int]
+    choices: NotRequired[List[ChatCompletionChoiceTypedDict]]
+    
+
+class FIMCompletionResponse(BaseModel):
+    id: str
+    object: str
+    model: str
+    usage: UsageInfo
+    created: Optional[int] = None
+    choices: Optional[List[ChatCompletionChoice]] = None
+    

mistralai/models/fimcompletionstreamrequest.py

@@ -0,0 +1,97 @@
+"""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 List, Optional, TypedDict, Union
+from typing_extensions import NotRequired
+
+
+class FIMCompletionStreamRequestTypedDict(TypedDict):
+    prompt: str
+    r"""The text/code to complete."""
+    model: NotRequired[Nullable[str]]
+    r"""ID of the model to use. Only compatible for now with:
+    - `codestral-2405`
+    - `codestral-latest`
+    """
+    temperature: NotRequired[float]
+    r"""What sampling temperature to use, between 0.0 and 1.0. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. We generally recommend altering this or `top_p` but not both."""
+    top_p: NotRequired[float]
+    r"""Nucleus sampling, where the model considers the results of the tokens with `top_p` probability mass. So 0.1 means only the tokens comprising the top 10% probability mass are considered. We generally recommend altering this or `temperature` but not both."""
+    max_tokens: NotRequired[Nullable[int]]
+    r"""The maximum number of tokens to generate in the completion. The token count of your prompt plus `max_tokens` cannot exceed the model's context length."""
+    min_tokens: NotRequired[Nullable[int]]
+    r"""The minimum number of tokens to generate in the completion."""
+    stream: NotRequired[bool]
+    stop: NotRequired[FIMCompletionStreamRequestStopTypedDict]
+    r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
+    random_seed: NotRequired[Nullable[int]]
+    r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
+    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`."""
+    
+
+class FIMCompletionStreamRequest(BaseModel):
+    prompt: str
+    r"""The text/code to complete."""
+    model: OptionalNullable[str] = UNSET
+    r"""ID of the model to use. Only compatible for now with:
+    - `codestral-2405`
+    - `codestral-latest`
+    """
+    temperature: Optional[float] = 0.7
+    r"""What sampling temperature to use, between 0.0 and 1.0. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. We generally recommend altering this or `top_p` but not both."""
+    top_p: Optional[float] = 1
+    r"""Nucleus sampling, where the model considers the results of the tokens with `top_p` probability mass. So 0.1 means only the tokens comprising the top 10% probability mass are considered. We generally recommend altering this or `temperature` but not both."""
+    max_tokens: OptionalNullable[int] = UNSET
+    r"""The maximum number of tokens to generate in the completion. The token count of your prompt plus `max_tokens` cannot exceed the model's context length."""
+    min_tokens: OptionalNullable[int] = UNSET
+    r"""The minimum number of tokens to generate in the completion."""
+    stream: Optional[bool] = True
+    stop: Optional[FIMCompletionStreamRequestStop] = None
+    r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
+    random_seed: OptionalNullable[int] = UNSET
+    r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
+    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`."""
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["model", "temperature", "top_p", "max_tokens", "min_tokens", "stream", "stop", "random_seed", "suffix"]
+        nullable_fields = ["model", "max_tokens", "min_tokens", "random_seed", "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
+        
+
+FIMCompletionStreamRequestStopTypedDict = Union[str, List[str]]
+r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
+
+
+FIMCompletionStreamRequestStop = Union[str, List[str]]
+r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
+

mistralai/models/finetuneablemodel.py

@@ -0,0 +1,8 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from typing import Literal
+
+
+FineTuneableModel = Literal["open-mistral-7b", "mistral-small-latest", "codestral-latest", "mistral-large-latest", "open-mistral-nemo"]
+r"""The name of the model to fine-tune."""

mistralai/models/ftmodelcapabilitiesout.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 FTModelCapabilitiesOutTypedDict(TypedDict):
+    completion_chat: NotRequired[bool]
+    completion_fim: NotRequired[bool]
+    function_calling: NotRequired[bool]
+    fine_tuning: NotRequired[bool]
+    
+
+class FTModelCapabilitiesOut(BaseModel):
+    completion_chat: Optional[bool] = True
+    completion_fim: Optional[bool] = False
+    function_calling: Optional[bool] = False
+    fine_tuning: Optional[bool] = False
+    

mistralai/models/ftmodelout.py

@@ -0,0 +1,70 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .ftmodelcapabilitiesout import FTModelCapabilitiesOut, FTModelCapabilitiesOutTypedDict
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+import pydantic
+from pydantic import model_serializer
+from typing import Final, List, Optional, TypedDict
+from typing_extensions import Annotated, NotRequired
+
+
+class FTModelOutTypedDict(TypedDict):
+    id: str
+    created: int
+    owned_by: str
+    root: str
+    archived: bool
+    capabilities: FTModelCapabilitiesOutTypedDict
+    job: str
+    name: NotRequired[Nullable[str]]
+    description: NotRequired[Nullable[str]]
+    max_context_length: NotRequired[int]
+    aliases: NotRequired[List[str]]
+    
+
+class FTModelOut(BaseModel):
+    id: str
+    created: int
+    owned_by: str
+    root: str
+    archived: bool
+    capabilities: FTModelCapabilitiesOut
+    job: str
+    OBJECT: Annotated[Final[Optional[str]], pydantic.Field(alias="object")] = "model" # type: ignore
+    name: OptionalNullable[str] = UNSET
+    description: OptionalNullable[str] = UNSET
+    max_context_length: Optional[int] = 32768
+    aliases: Optional[List[str]] = None
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["object", "name", "description", "max_context_length", "aliases"]
+        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/function.py

@@ -0,0 +1,19 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel
+from typing import Any, Dict, Optional, TypedDict
+from typing_extensions import NotRequired
+
+
+class FunctionTypedDict(TypedDict):
+    name: str
+    parameters: Dict[str, Any]
+    description: NotRequired[str]
+    
+
+class Function(BaseModel):
+    name: str
+    parameters: Dict[str, Any]
+    description: Optional[str] = ""
+    

mistralai/models/functioncall.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 typing import TypedDict
+
+
+class FunctionCallTypedDict(TypedDict):
+    name: str
+    arguments: str
+    
+
+class FunctionCall(BaseModel):
+    name: str
+    arguments: str
+    

mistralai/models/githubrepositoryin.py

@@ -0,0 +1,57 @@
+"""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 GithubRepositoryInTypedDict(TypedDict):
+    name: str
+    owner: str
+    token: str
+    ref: NotRequired[Nullable[str]]
+    weight: NotRequired[float]
+    
+
+class GithubRepositoryIn(BaseModel):
+    name: str
+    owner: str
+    token: str
+    TYPE: Annotated[Final[Optional[str]], pydantic.Field(alias="type")] = "github" # type: ignore
+    ref: OptionalNullable[str] = UNSET
+    weight: Optional[float] = 1
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["type", "ref", "weight"]
+        nullable_fields = ["ref"]
+        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/githubrepositoryout.py

@@ -0,0 +1,57 @@
+"""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 GithubRepositoryOutTypedDict(TypedDict):
+    name: str
+    owner: str
+    commit_id: str
+    ref: NotRequired[Nullable[str]]
+    weight: NotRequired[float]
+    
+
+class GithubRepositoryOut(BaseModel):
+    name: str
+    owner: str
+    commit_id: str
+    TYPE: Annotated[Final[Optional[str]], pydantic.Field(alias="type")] = "github" # type: ignore
+    ref: OptionalNullable[str] = UNSET
+    weight: Optional[float] = 1
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["type", "ref", "weight"]
+        nullable_fields = ["ref"]
+        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/httpvalidationerror.py

@@ -0,0 +1,23 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .validationerror import ValidationError
+from mistralai.types import BaseModel
+import mistralai.utils as utils
+from typing import List, Optional
+
+class HTTPValidationErrorData(BaseModel):
+    detail: Optional[List[ValidationError]] = None
+    
+
+
+class HTTPValidationError(Exception):
+    r"""Validation Error"""
+    data: HTTPValidationErrorData
+
+    def __init__(self, data: HTTPValidationErrorData):
+        self.data = data
+
+    def __str__(self) -> str:
+        return utils.marshal_json(self.data, HTTPValidationErrorData)
+

mistralai/models/jobin.py

@@ -0,0 +1,78 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .finetuneablemodel import FineTuneableModel
+from .githubrepositoryin import GithubRepositoryIn, GithubRepositoryInTypedDict
+from .trainingfile import TrainingFile, TrainingFileTypedDict
+from .trainingparametersin import TrainingParametersIn, TrainingParametersInTypedDict
+from .wandbintegration import WandbIntegration, WandbIntegrationTypedDict
+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 JobInTypedDict(TypedDict):
+    model: FineTuneableModel
+    r"""The name of the model to fine-tune."""
+    hyperparameters: TrainingParametersInTypedDict
+    r"""The fine-tuning hyperparameter settings used in a fine-tune job."""
+    training_files: NotRequired[List[TrainingFileTypedDict]]
+    validation_files: NotRequired[Nullable[List[str]]]
+    r"""A list containing the IDs of uploaded files that contain validation data. If you provide these files, the data is used to generate validation metrics periodically during fine-tuning. These metrics can be viewed in `checkpoints` when getting the status of a running fine-tuning job. The same data should not be present in both train and validation files."""
+    suffix: NotRequired[Nullable[str]]
+    r"""A string that will be added to your fine-tuning model name. For example, a suffix of \"my-great-model\" would produce a model name like `ft:open-mistral-7b:my-great-model:xxx...`"""
+    integrations: NotRequired[Nullable[List[WandbIntegrationTypedDict]]]
+    r"""A list of integrations to enable for your fine-tuning job."""
+    repositories: NotRequired[List[GithubRepositoryInTypedDict]]
+    auto_start: NotRequired[bool]
+    r"""This field will be required in a future release."""
+    
+
+class JobIn(BaseModel):
+    model: FineTuneableModel
+    r"""The name of the model to fine-tune."""
+    hyperparameters: TrainingParametersIn
+    r"""The fine-tuning hyperparameter settings used in a fine-tune job."""
+    training_files: Optional[List[TrainingFile]] = None
+    validation_files: OptionalNullable[List[str]] = UNSET
+    r"""A list containing the IDs of uploaded files that contain validation data. If you provide these files, the data is used to generate validation metrics periodically during fine-tuning. These metrics can be viewed in `checkpoints` when getting the status of a running fine-tuning job. The same data should not be present in both train and validation files."""
+    suffix: OptionalNullable[str] = UNSET
+    r"""A string that will be added to your fine-tuning model name. For example, a suffix of \"my-great-model\" would produce a model name like `ft:open-mistral-7b:my-great-model:xxx...`"""
+    integrations: OptionalNullable[List[WandbIntegration]] = UNSET
+    r"""A list of integrations to enable for your fine-tuning job."""
+    repositories: Optional[List[GithubRepositoryIn]] = None
+    auto_start: Optional[bool] = None
+    r"""This field will be required in a future release."""
+    
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["training_files", "validation_files", "suffix", "integrations", "repositories", "auto_start"]
+        nullable_fields = ["validation_files", "suffix", "integrations"]
+        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/jobmetadataout.py

@@ -0,0 +1,59 @@
+"""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 JobMetadataOutTypedDict(TypedDict):
+    expected_duration_seconds: NotRequired[Nullable[int]]
+    cost: NotRequired[Nullable[float]]
+    cost_currency: NotRequired[Nullable[str]]
+    train_tokens_per_step: NotRequired[Nullable[int]]
+    train_tokens: NotRequired[Nullable[int]]
+    data_tokens: NotRequired[Nullable[int]]
+    estimated_start_time: NotRequired[Nullable[int]]
+    
+
+class JobMetadataOut(BaseModel):
+    expected_duration_seconds: OptionalNullable[int] = UNSET
+    cost: OptionalNullable[float] = UNSET
+    cost_currency: OptionalNullable[str] = UNSET
+    train_tokens_per_step: OptionalNullable[int] = UNSET
+    train_tokens: OptionalNullable[int] = UNSET
+    data_tokens: OptionalNullable[int] = UNSET
+    estimated_start_time: OptionalNullable[int] = UNSET
+    
+    @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"]
+        nullable_fields = ["expected_duration_seconds", "cost", "cost_currency", "train_tokens_per_step", "train_tokens", "data_tokens", "estimated_start_time"]
+        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
+